Request 5437 (accepted)

sview.changes Changed

@@ -1,4 +1,54 @@
 -------------------------------------------------------------------
+Tue Aug 24 12:45:46 UTC 2021 - Luigi Baldoni <aloisio@gmx.com>
+
+- Update to version 20.08
+  * Added support for Equiangular Cubemaps (EAC).
+  version 20.05:
+  * Added Spanish translation files.
+  * Image Viewer - added trilinear texture filtering option
+    generating mip-maps.
+  * Image Viewer - support 1x6 cubemap layout.
+  * Image Viewer - panorama is now automatically enabled for
+    JPEG files with GPano:ProjectionType tag.
+  * Image Viewer - panorama is now automatically enabled for
+    JPEG files with 360Stereo/360Mono tags (game screenshots).
+  * Image Viewer - support DDS-packed cubemaps.
+  * Movie Player - image-based subtitles size can be now
+    adjusted.
+  * Movie Player - workaround subtitles seeking issues for
+    attached SRT files.
+  * Movie Player - fixed ASS subtitles formatting issue on files
+    without closure tags.
+  * Movie Player - added handling of image-based subtitles
+    encoded as stereoscopic pair (side-by-side).
+  * Image Viewer - fixed poor quality on saving JPEG (yuv420p)
+    image into PNG (rgb).
+  * Image Viewer - fixed displaying WebP images with alpha
+    channel (yuva pixel formats).
+  * fontconfig library is now used to retrieve paths to system
+    fonts.
+  version 19.08:
+  * Introduced VR180 (hemisphere) and cylindrical panorama input
+    support.
+  * Image Viewer now redirects video file to Movie Player and
+    vice versa.
+  * Added single-finger swipe gesture for opening next/previous
+    file in playlist.
+  * FFmpeg 4.1 support.
+  * Fixed sporadic text formatting issues.
+  version 17.10:
+  * Image Viewer - added Slideshow delay parameter to Settings.
+  * Movie Player - added general information about the stream
+    (bitrate, codec, PAR, DAR) in File Info dialog.
+  * Movie Player - fixed seeking to the very beginning of the
+    file.
+  * Movie Player - fixed (workaround) displaying attached image
+    within some mp3 files.
+  * Fixed text rendering artifacts when using glyphs with
+    kerning defined.
+  * Fixed compilation on glibc 2.26+.
+
+-------------------------------------------------------------------
 Fri May  4 14:03:47 UTC 2018 - olaf@aepfle.de
 
 - Use ffmpeg3 versions of pkgconfig(libav*)

sview.spec Changed

@@ -1,6 +1,7 @@
 #
 # spec file for package sview
 #
+# Copyright (c) 2021 Packman Team <packman@links2linux.de>
 # Copyright (c) 2015 SUSE LINUX GmbH, Nuernberg, Germany.
 #
 # All modifications and additions to the file contributed by third parties
@@ -16,27 +17,27 @@
 #
 
 
-%define src_ver 17_04
+%define src_ver 20_08
 %define src_name sView
 %define ffmpeg_includedir %(pkg-config --variable=includedir libavcodec)
 Name:           sview
-Version:        17.04
+Version:        20.08
 Release:        0
 Summary:        Stereoscopic media player
-License:        GPL-3.0+ and LGPL-3.0+
+License:        GPL-3.0-or-later AND LGPL-3.0-or-later
 Group:          Productivity/Multimedia/Video/Players
-Url:            http://www.sview.ru/en/
+URL:            http://www.sview.ru/en/
 Source:         https://github.com/gkv311/sview/archive/%{src_ver}.tar.gz#/%{name}-%{src_ver}.tar.gz
 BuildRequires:  dos2unix
-BuildRequires:  gcc-c++
 BuildRequires:  fdupes
+BuildRequires:  gcc-c++
 BuildRequires:  hicolor-icon-theme
 BuildRequires:  make
 BuildRequires:  pkgconfig
 BuildRequires:  update-desktop-files
+BuildRequires:  pkgconfig(freetype2)
 BuildRequires:  pkgconfig(gl)
 BuildRequires:  pkgconfig(gtk+-2.0)
-BuildRequires:  pkgconfig(freetype2)
 BuildRequires:  pkgconfig(libavcodec) = 57.107.100
 BuildRequires:  pkgconfig(libavformat) = 57.83.100
 BuildRequires:  pkgconfig(libavutil) = 55.78.100
@@ -48,7 +49,6 @@
 Requires:       xdg-utils
 #Recommends:     mongoose
 ExclusiveArch:  %{ix86} x86_64
-BuildRoot:      %{_tmppath}/%{name}-%{version}-build
 
 %description
 Stereoscopic Image Viewer and Movie Player.
@@ -66,7 +66,7 @@
     -e '/^CFLAGS/s/$/\ %{optflags}/' \
     -e '/^CXXFLAGS/s/$/\ %{optflags}/' \
     -i Makefile
-# Remove %%_smp_mflags to avoid compilation errors
+# Remove %%{?_smp_mflags} to avoid compilation errors
 make -j1 EXTRA_LDFLAGS="-Wl,-rpath,%{_libdir}/%{src_name}"
 
 %install
@@ -98,8 +98,7 @@
 %desktop_database_postun
 
 %files
-%defattr(-,root,root)
-%doc LICENSE*
+%license LICENSE*
 %{_bindir}/%{src_name}
 %{_libdir}/%{src_name}/
 %{_datadir}/applications/%{src_name}IV.desktop

sview-17_04.tar.gz/.gitignore -> sview-20_08.tar.gz/.gitignore Changed

sview-17_04.tar.gz/.travis.yml -> sview-20_08.tar.gz/.travis.yml Changed

sview-17_04.tar.gz/3rdparty/FFmpeg/rebuild.sh -> sview-20_08.tar.gz/3rdparty/FFmpeg/rebuild.sh Changed

@@ -4,12 +4,13 @@
 
 echo "Usage: $0 [FFmpegPath] [GPL || LGPL] [DEBUG || RELEASE] [GCC_PREFIX]"
 
-rebuildTarget="FFmpeg"
-rebuildLicense="LGPL"
+rebuildTarget="ffmpeg.git"
+rebuildLicense="lgpl"
 rebuildDebug="false"
 rebuildAndroid="false"
 compilerPrefix=""
 androidTarget=""
+androidAbi="armeabi-v7a"
 androidNdkRoot="$HOME/develop/android-ndk-r12b"
 aSystem=`uname -s`
 aPwdBack=$PWD
@@ -17,9 +18,9 @@
 for i in $*
 do
   if [ "$i" == "gpl"       ] || [ "$i" == "GPL" ]; then
-    rebuildLicense="GPL"
+    rebuildLicense="gpl"
   elif [ "$i" == "lgpl"    ] || [ "$i" == "LGPL" ]; then
-    rebuildLicense="LGPL"
+    rebuildLicense="lgpl"
   elif [ "$i" == "android" ]; then
     rebuildAndroid="true"
   elif [ "$i" == "debug"   ] || [ "$i" == "DEBUG" ]; then
@@ -51,8 +52,10 @@
 if [ "$rebuildAndroid" == "true" ]; then
   if [ "$androidTarget" == "arm64" ]; then
     aPrefixShort="aarch64-linux-android"
+    androidAbi="arm64-v8a"
   else
     aPrefixShort="arm-linux-androideabi"
+    androidAbi="armeabi-v7a"
   fi
 
   compilerPrefix="${androidNdkRoot}/toolchains/${aPrefixShort}-4.8/prebuilt/linux-x86_64/bin/${aPrefixShort}-"
@@ -72,18 +75,19 @@
 echo "  Start building FFmpeg $rebuildLicense from $rebuildTarget"
 cd $rebuildTarget
 
-# releases extract the version number from the VERSION file
-ffmpegVersion=$(cat VERSION 2> /dev/null)
+# releases extract the version number from the RELEASE file
+ffmpegVersion=$(cat RELEASE 2> /dev/null)
 ffmpegRevision=$(git log -1 --pretty=format:%h 2> /dev/null)
 ffmpegDate=$(git show -s --format="%ci" 2> /dev/null)
 ffmpegDate=${ffmpegDate:0:10}
-test $ffmpegRevision && ffmpegRevision=git-$ffmpegRevision
+test $ffmpegRevision && ffmpegRevision=git-$ffmpegDate-$ffmpegRevision
 test $ffmpegVersion || ffmpegVersion=$ffmpegRevision
 
 # remove slashes
 rebuildTarget="${rebuildTarget//\//}"
-SOURCES_NAME="FFmpeg-$ffmpegDate-$ffmpegVersion"
-OUTPUT_NAME="$SOURCES_NAME-$gccMachine-$gccVersion-$rebuildLicense"
+SOURCES_NAME="ffmpeg-$ffmpegVersion"
+#OUTPUT_NAME="$SOURCES_NAME-$gccMachine-$gccVersion-$rebuildLicense"
+OUTPUT_NAME="$SOURCES_NAME-$gccMachine-$rebuildLicense"
 SOURCES_NAME="$SOURCES_NAME-src"
 if [ "$rebuildDebug" == "true" ]; then
   OUTPUT_NAME="$OUTPUT_NAME-debug"
@@ -97,9 +101,9 @@
   OUTPUT_FOLDER_LIB="$OUTPUT_FOLDER/Frameworks"
 fi
 if [ "$androidTarget" == "arm64" ]; then
-  OUTPUT_FOLDER_LIB="$OUTPUT_FOLDER/libs/arm64-v8a"
+  OUTPUT_FOLDER_LIB="$OUTPUT_FOLDER/libs/$androidAbi"
 elif [ "$androidTarget" == "arm" ]; then
-  OUTPUT_FOLDER_LIB="$OUTPUT_FOLDER/libs/armeabi-v7a"
+  OUTPUT_FOLDER_LIB="$OUTPUT_FOLDER/libs/$androidAbi"
 fi
 
 rm -f -r $OUTPUT_FOLDER
@@ -115,6 +119,12 @@
 mkdir -p $OUTPUT_FOLDER_INC/libswscale
 mkdir -p $OUTPUT_FOLDER_INC/libswresample
 
+# include some information about FFmpeg into archive
+echo \<pre\>> $OUTPUT_FOLDER/VERSION.html
+git status >> $OUTPUT_FOLDER/VERSION.html
+git log -n 100 >> $OUTPUT_FOLDER/VERSION.html
+echo \</pre\>>> $OUTPUT_FOLDER/VERSION.html
+
 echo "  make distclean"
 make distclean &>/dev/null
 
@@ -125,10 +135,17 @@
   then
     echo "Sources archive '$SOURCES_NAME.7z' already exists"
   else
+
+    if [ ! -f ../exclude.lst ]; then
+      echo -e ".svn\n.git\n" > ../exclude.lst
+    fi
     7za a -t7z -m0=lzma -mx=9 -mfb=64 -md=32m -ms=on ../$SOURCES_NAME.7z ../$rebuildTarget '-xr@../exclude.lst'
   fi
 fi
 
+# --extra-cflags parameters
+anExtraCFlags=
+
 #--enable-memalign-hack
 configArguments="\
  --extra-version=sView.ru \
@@ -138,7 +155,6 @@
  --enable-avfilter \
  --enable-hardcoded-tables \
  --enable-pthreads \
- --disable-libopenjpeg \
  --disable-doc \
  --enable-runtime-cpudetect"
 
@@ -147,6 +163,8 @@
   configArguments="$configArguments --enable-vda --libdir=@executable_path/../Frameworks"
 fi
 
+export PKG_CONFIG_LIBDIR=
+
 #if [ "$gccMachine" != "$GCC_MACHINE_LINUX_64" ]; then
 if [ "$gccMachine" == "$GCC_MACHINE_MINGW_32" ] || [ "$gccMachine" == "$GCC_MACHINE_MINGW_32_1" ] \
 || [ "$gccMachine" == "$GCC_MACHINE_MINGW_64" ] || [ "$gccMachine" == "$GCC_MACHINE_MINGW_64_1" ]; then
@@ -154,14 +172,19 @@
   # you should use with --enable-pthreads instead to enable full multithreading support!
   #configArguments="$configArguments --enable-w32threads"
   configArguments="$configArguments --disable-w32threads"
-  if [ "$rebuildLicense" == "GPL" ]; then
+  if [ "$rebuildLicense" == "gpl" ]; then
     configArguments="$configArguments --enable-avisynth"
   fi
 
+  aMingwRoot=${compilerPrefix::-1}
+  export PKG_CONFIG_LIBDIR=/usr/$aMingwRoot/share/pkgconfig
+
   configArguments="$configArguments --enable-libopenjpeg"
 
   # avoid dynamic linkage with libgcc_s_sjlj-1.dll
   configArguments="$configArguments --extra-ldflags=-static-libgcc"
+else
+  configArguments="$configArguments --disable-libopenjpeg"
 fi
 
 # cross-compiling options
@@ -169,19 +192,31 @@
   targetFlags="--cross-prefix=$compilerPrefix --arch=x86_32"
   configArguments="$configArguments --enable-cross-compile --target-os=mingw32 $targetFlags"
 elif [ "$gccMachine" == "$GCC_MACHINE_MINGW_64" ] || [ "$gccMachine" == "$GCC_MACHINE_MINGW_64_1" ]; then
+  anExtraCFlags="$anExtraCFlags -Dstrtod=__strtod"
   targetFlags="--cross-prefix=$compilerPrefix --arch=x86_64 --extra-cflags=-Dstrtod=__strtod"
   configArguments="$configArguments --enable-cross-compile --target-os=mingw32 $targetFlags"
 elif [ "$rebuildAndroid" == "true" ]; then
+  anAndArch=arm
+  anAndSysRoot=${androidNdkRoot}/platforms/android-15/arch-arm
   if [ "$androidTarget" == "arm64" ]; then
-    targetFlags="--cross-prefix=$compilerPrefix --sysroot=${androidNdkRoot}/platforms/android-21/arch-arm64 --arch=aarch64"
-  else
-    targetFlags="--cross-prefix=$compilerPrefix --sysroot=${androidNdkRoot}/platforms/android-15/arch-arm --arch=arm"
+    anAndArch=aarch64
+    anAndSysRoot=${androidNdkRoot}/platforms/android-21/arch-arm64
   fi
+  configArguments="$configArguments --enable-cross-compile --target-os=android --cross-prefix=$compilerPrefix --sysroot=${anAndSysRoot} --arch=${anAndArch}"
+  #if [ -x "${androidNdkRoot}/sysroot" ]; then
+    #configArguments="$configArguments --sysinclude=${androidNdkRoot}/sysroot/usr/include"
+  #fi
 
-  configArguments="$configArguments --enable-cross-compile --target-os=android $targetFlags"
-  #configArguments="$configArguments --extra-cflags='-fno-builtin-sin -fno-builtin-sinf'"
+  if [ "$androidTarget" == "arm64" ]; then
+    anExtraCFlags="$anExtraCFlags -march=armv8-a"
+  else
+    anExtraCFlags="$anExtraCFlags -march=armv7-a -mfloat-abi=softfp -fno-builtin-sin -fno-builtin-sinf"
+  fi
 
   configArguments="$configArguments --enable-jni --enable-mediacodec"
+
+  configArguments="$configArguments --enable-mbedtls --extra-ldflags=-L$aPwdBack/mbedtls-2.16.2-android/libs/$androidAbi"
+  anExtraCFlags="$anExtraCFlags -I$aPwdBack/mbedtls-2.16.2-android/include"
 fi
 
 # More options
@@ -200,7 +235,7 @@
 # enable (L)GPL version 3
 configArguments="$configArguments --enable-version3"
 
-if [ "$rebuildLicense" == "GPL" ]; then
+if [ "$rebuildLicense" == "gpl" ]; then
   configArguments="$configArguments --enable-gpl"
   # enable libx264 encoder (should be compiled and installed!)
   #configArguments="$configArguments --enable-libx264"
@@ -212,30 +247,28 @@
 set -o pipefail
 
 aNbJobs="$(getconf _NPROCESSORS_ONLN)"
+"$compilerPrefix"gcc --version > $OUTPUT_FOLDER/gccInfo-$gccMachine-$rebuildLicense.log
+
+# --extra-cflags should be passed as single dedicated argument
+anExtraCFlags="--extra-cflags=${anExtraCFlags}"
 
 echo
-echo "  ./configure $configArguments"
+echo "  ./configure $configArguments $anExtraCFlags"
 echo
 if [ "$rebuildAndroid" == "true" ]; then
-  if [ "$androidTarget" == "arm64" ]; then
-    ./configure $configArguments --disable-symver --extra-cflags='-march=armv8-a' 2>&1 | tee $OUTPUT_FOLDER/config.log
-  else
-    ./configure $configArguments --disable-symver --extra-cflags='-march=armv7-a -mfloat-abi=softfp -fno-builtin-sin -fno-builtin-sinf' 2>&1 | tee $OUTPUT_FOLDER/config.log
-  fi
+  ./configure $configArguments --disable-symver "$anExtraCFlags" 2>&1 | tee $OUTPUT_FOLDER/config-$gccMachine-$rebuildLicense.log
 else
-  ./configure $configArguments 2>&1 | tee -a $OUTPUT_FOLDER/config.log
+  ./configure $configArguments 2>&1 | tee -a $OUTPUT_FOLDER/config-$gccMachine-$rebuildLicense.log
 fi
 aResult=$?; if [[ $aResult != 0 ]]; then exit $aResult; fi
 
-make -j $aNbJobs 2>&1 | tee -a $OUTPUT_FOLDER/make.log
+make -j $aNbJobs 2>&1 | tee -a $OUTPUT_FOLDER/make-$gccMachine-$rebuildLicense.log
 aResult=$?; if [[ $aResult != 0 ]]; then exit $aResult; fi
 
 # Now copy result files
 echo
 echo "  Now copy result files into $OUTPUT_FOLDER"
 
-"$compilerPrefix"gcc --version > $OUTPUT_FOLDER/gccInfo.log
-
 if [ -f libavcodec/avcodec.dll ]; then
   cp -f libavcodec/*.dll $OUTPUT_FOLDER_BIN
   cp -f libavcodec/*.lib $OUTPUT_FOLDER_LIB &>/dev/null

sview-17_04.tar.gz/3rdparty/include/mongoose.c -> sview-20_08.tar.gz/3rdparty/include/mongoose.c Changed

sview-20_08.tar.gz/3rdparty/mbedtls Added

sview-20_08.tar.gz/3rdparty/mbedtls/sview_mbedtls_build_android.bat Added

@@ -0,0 +1,92 @@
+@echo OFF
+
+rem Auxiliary script for semi-automated building of mbedtls (https://tls.mbed.org/) for Android platform.
+rem Script should be placed into root of mbedtls repository, edited with paths
+rem to CMake, 3rd-parties, Android NDK and MinGW64 make tool.
+
+rem CMake toolchain definition should be cloned from the following git repository:
+rem https://github.com/taka-no-me/android-cmake
+
+rem CMake can be downloaded from official site:
+rem https://cmake.org/download/
+
+rem Android NDK can be downloaded from offical site:
+rem https://developer.android.com/ndk/downloads
+
+rem x86 build is broken on old gcc due to https://github.com/ARMmbed/mbedtls/issues/1910
+rem include/mbedtls/bn_mul.h
+rem -#if defined(__i386__) && defined(__OPTIMIZE__) && !defined(__ANDROID__)
+rem +#if defined(__i386__) && defined(__OPTIMIZE__) && !defined(__ANDROID__)
+rem
+rem #define MULADDC_INIT
+
+set "anMbedTlsSrc=%~dp0"
+set aNbJobs=%NUMBER_OF_PROCESSORS%
+
+call c:\develop\MinGW\TDM-GCC-64\mingwvars.bat
+set "PATH=c:\develop\CMake\bin;%PATH%"
+set "anNdkPath=c:/develop/android/android-ndk-r12"
+set "aToolchain=c:/develop/android-cmake/android.toolchain.cmake"
+
+set "anInstDir=%~dp0work/mbedtls-android"
+if exist "%anInstDir%" ( rmdir /S /Q "%anInstDir%" )
+
+call :cmakeGenerate "15" "armeabi-v7a"
+call :cmakeGenerate "21" "arm64-v8a"
+call :cmakeGenerate "15" "x86"
+
+pause
+
+goto :eof
+
+:cmakeGenerate
+set "anApi=%1"
+set "anAbi=%2"
+set "aPlatformAndCompiler=android-%anAbi%-gcc"
+set "aWorkDir=work\%aPlatformAndCompiler%-make"
+set "aLogFile=%~dp0build-%anAbi%.log"
+if not exist "%aWorkDir%" ( mkdir "%aWorkDir%" )
+if     exist "%aLogFile%" ( del   "%aLogFile%" )
+
+pushd "%aWorkDir%"
+
+echo Configuring mbedtls for Android %anAbi% (API level %anApi%)...
+cmake -G "MinGW Makefiles" ^
+ -D CMAKE_TOOLCHAIN_FILE:FILEPATH="%aToolchain%" ^
+ -D ANDROID_NDK:FILEPATH="%anNdkPath%" ^
+ -D CMAKE_BUILD_TYPE:STRING="Release" ^
+ -D ANDROID_ABI:STRING="%anAbi%" ^
+ -D ANDROID_NATIVE_API_LEVEL:STRING="%anApi%" ^
+ -D ANDROID_STL:STRING="gnustl_shared" ^
+ -D CMAKE_INSTALL_PREFIX:PATH="%anInstDir%" ^
+ -D LIBRARY_OUTPUT_PATH:PATH="%anInstDir%/libs/%anAbi%" ^
+ -D USE_SHARED_MBEDTLS_LIBRARY:BOOL="OFF" ^
+ -D USE_STATIC_MBEDTLS_LIBRARY:BOOL="ON" ^
+ -D ENABLE_TESTING:BOOL="OFF" ^
+ -D ENABLE_PROGRAMS:BOOL="OFF" ^
+ "%anMbedTlsSrc%"
+
+if errorlevel 1 (
+  popd
+  pause
+  exit /B
+  goto :eof
+)
+
+mingw32-make clean
+
+echo Building mbedtls...
+mingw32-make -j %aNbJobs% 2>> %aLogFile%
+type %aLogFile%
+if errorlevel 1 (
+  popd
+  pause
+  exit /B
+  goto :eof
+)
+echo Installing mbedtls into %~dp0work/%aPlatformAndCompiler%...
+mingw32-make install 2>> %aLogFile%
+if exist "%anInstDir%/lib" ( rmdir /S /Q "%anInstDir%/lib" )
+
+popd
+goto :eof

sview-17_04.tar.gz/Makefile -> sview-20_08.tar.gz/Makefile Changed

@@ -2,6 +2,8 @@
 
 WORKDIR = $(shell pwd)
 SRCDIR = $(WORKDIR)
+JAVA_HOME = /usr
+APP_PREFIX = /usr
 
 $(info SRCDIR=$(SRCDIR))
 
@@ -13,7 +15,17 @@
 .mm.o:
 	$(CXX) -c $(CXXFLAGS) $< -o $@
 
+# Compile java files.
+# javac takes output folder, not file, and actually sometimes generates multiple files from single .java input.
+# To fool make (avoid recompiling on each build) - copy result .class file to source folder;
+# this, however, might lead to incomplete build on .java change without make clean.
+.SUFFIXES: .class .java
+.java.class:
+	$(JAVA_HOME)/bin/javac -source 1.7 -target 1.7 -d $(BUILD_ROOT)/java/classes -classpath $(ANDROID_PLATFORM) -sourcepath $(SRCDIR)/sview/src:$(BUILD_ROOT)/java/gen $<
+	cp -f $(BUILD_ROOT)/java/classes/com/sview/$(@F) $@
+
 TARGET_OS = linux
+TARGET_ARCH2 =
 
 #ANDROID_NDK = $(HOME)/develop/android-ndk-r12b
 ifeq ($(OS),Windows_NT)
@@ -25,6 +37,7 @@
 endif
 ifeq ($(UNAME_S),Darwin)
 TARGET_OS = osx
+TARGET_OS_VERSION = 10.10
 endif
 endif
 
@@ -40,12 +53,19 @@
 BUILD_ROOT = $(BUILD_ROOT_BUNDLE)/Contents/MacOS
 endif
 
+ST_DEBUG = 0
 FFMPEG_ROOT =
 FREETYPE_ROOT =
 OPENAL_ROOT =
 LIBCONFIG_ROOT =
 LIBSUBFOLDER = lib
 LIBSUFFIX = so
+ANDROID_BUILD_TOOLS = $(ANDROID_HOME)/build-tools/26.0.3
+ANDROID_PLATFORM = $(ANDROID_HOME)/platforms/android-26/android.jar
+ANDROID_KEYSTORE = $(BUILD_ROOT)/sview_debug.key
+ANDROID_KEYSTORE_PASSWORD = sview_store_pswd
+ANDROID_KEY = "sview android key"
+ANDROID_KEY_PASSWORD = sview_pswd
 
 # function defining library install_name to @executable_path on OS X
 libinstname =
@@ -62,6 +82,7 @@
 LIB_CONFIG =
 LIB_ANDROID =
 LIB_IOKIT =
+LIB_COREVIDEO =
 LIB_OPENAL = -lopenal
 LIB_OUTPUTS = -lStOutAnaglyph -lStOutDual -lStOutInterlace -lStOutPageFlip -lStOutIZ3D -lStOutDistorted
 TOOLCHAIN =
@@ -81,7 +102,10 @@
 LIB_PTHREAD = -lobjc
 LIB_GLX = -framework OpenGL -framework Appkit
 LIB_IOKIT = -framework IOKit
-LIB_OPENAL = -framework OpenAL
+LIB_COREVIDEO = -framework CoreVideo
+ifeq ($(OPENAL_ROOT),)
+  LIB_OPENAL = -framework OpenAL
+endif
 endif
 
 # Android libraries
@@ -122,28 +146,45 @@
 LDSTRIP = -s
 LDZDEF = -z defs
 EXTRA_CFLAGS   =
-EXTRA_CXXFLAGS =
+EXTRA_CXXFLAGS = -DAPP_PREFIX="\"$(APP_PREFIX)\""
 EXTRA_LDFLAGS  =
 ifeq ($(TARGET_OS),osx)
 LDZDEF =
 endif
 
+CCVERSION := $(shell $(CC) -dumpversion)
+CCMACHINE := $(shell $(CC) -dumpmachine)
+
+ifneq (,$(findstring i586,$(CCMACHINE)))
+TARGET_ARCH2 = x86
+else ifneq (,$(findstring i686,$(CCMACHINE)))
+TARGET_ARCH2 = x86
+else ifneq (,$(findstring x86,$(CCMACHINE)))
+TARGET_ARCH2 = x86
+else ifneq (,$(findstring mingw,$(CCMACHINE)))
+TARGET_ARCH2 = x86
+endif
+
 # to activate debug build
+ifneq ($(ST_DEBUG),0)
+EXTRA_CXXFLAGS = -DST_DEBUG
+LDSTRIP =
+STRIPFLAGS = --info
+endif
 #EXTRA_CXXFLAGS = -DST_DEBUG_LOG_TO_FILE=\"/sdcard/Android/data/com.sview/files/sview.log\" -DST_DEBUG
 #EXTRA_CXXFLAGS += -DST_DEBUG_GL
 #EXTRA_CXXFLAGS += -DST_DEBUG_FFMPEG_VERBOSE
 #EXTRA_CXXFLAGS += -DST_DEBUG_SYSLOG
 #EXTRA_CXXFLAGS += -DST_DEBUG_THREADID
-#LDSTRIP =
-#STRIPFLAGS = --info
 
 ifdef ANDROID_NDK
 LIBSUBFOLDER = libs/$(ANDROID_EABI)
 EXTRA_CFLAGS   += $(ANDROID_SYSROOT) $(ANDROID_MARCH)
 EXTRA_CXXFLAGS += $(ANDROID_SYSROOT) $(ANDROID_MARCH)
-EXTRA_CXXFLAGS += -I$(ANDROID_NDK)/sources/cxx-stl/gnu-libstdc++/4.9/include -I$(ANDROID_NDK)/sources/cxx-stl/gnu-libstdc++/4.9/libs/$(ANDROID_EABI)/include -DST_HAVE_EGL -DST_NO_UPDATES_CHECK
+EXTRA_CXXFLAGS += -I$(ANDROID_NDK)/sources/cxx-stl/gnu-libstdc++/4.9/include -I$(ANDROID_NDK)/sources/cxx-stl/gnu-libstdc++/4.9/libs/$(ANDROID_EABI)/include -DST_HAVE_EGL
 EXTRA_LDFLAGS  += $(ANDROID_SYSROOT) -L$(ANDROID_NDK)/sources/cxx-stl/gnu-libstdc++/4.9/libs/$(ANDROID_EABI) -lstdc++ -lgnustl_shared
-else
+else ifeq ($(TARGET_ARCH2),x86)
+# necessary for 32-bit x86 builds, where MMX and SSE are not enabled by default
 EXTRA_CFLAGS   += -mmmx -msse
 EXTRA_CXXFLAGS += -mmmx -msse
 endif
@@ -152,6 +193,13 @@
 # todo
 LDSTRIP =
 
+# minimal supported version of macOS:
+# - CMake: CMAKE_OSX_DEPLOYMENT
+# - qmake: QMAKE_MACOSX_DEPLOYMENT_TARGET = $(TARGET_OS_VERSION)
+# - environment variable: export MACOSX_DEPLOYMENT_TARGET=$(TARGET_OS_VERSION)
+EXTRA_CFLAGS   += -mmacosx-version-min=$(TARGET_OS_VERSION)
+EXTRA_CXXFLAGS += -mmacosx-version-min=$(TARGET_OS_VERSION)
+
 # workaround homebrew
 HAS_PKGCONF := $(shell command -v pkg-config 2> /dev/null)
 ifdef HAS_PKGCONF
@@ -182,11 +230,23 @@
 
 ifeq ($(TARGET_OS),linux)
 EXTRA_CXXFLAGS += `pkg-config gtk+-2.0 --cflags`
+# notification about updates available on sview.ru
+#EXTRA_CXXFLAGS += -DST_UPDATES_CHECK
+endif
+
+# optionally fail on any compiler warning except #warning and deprecations
+WERROR_LEVEL = 0
+ifeq ($(WERROR_LEVEL),1)
+EXTRA_CXXFLAGS += -Werror -Wno-error=cpp -Wno-error=deprecated-declarations
 endif
 
 INC =  -I$(SRCDIR)/3rdparty/include -I$(SRCDIR)/include
 CFLAGS   = -fPIC $(HAVE_MONGOOSE) $(INC) $(EXTRA_CFLAGS)
+ifneq ($(ST_DEBUG),0)
+CXXFLAGS = -g -std=c++0x -Wall -fPIC $(HAVE_MONGOOSE) $(INC) $(EXTRA_CXXFLAGS)
+else
 CXXFLAGS = -O3 -std=c++0x -Wall -fPIC $(HAVE_MONGOOSE) $(INC) $(EXTRA_CXXFLAGS)
+endif
 LIBDIR = -L$(BUILD_ROOT)
 LIB =
 LDFLAGS = $(LDSTRIP) $(LDZDEF) $(EXTRA_LDFLAGS)
@@ -207,13 +267,16 @@
 sViewAndroidCad := libsviewcad.$(LIBSUFFIX)
 sView           := sView
 sViewAndroid    := libsview.$(LIBSUFFIX)
-
-aDestAndroid    := sview
-
-all:         pre_all $(aStShared) $(aStGLWidgets) $(aStCore) $(aStOutAnaglyph) $(aStOutDual) $(aStOutInterlace) $(aStOutPageFlip) $(aStOutIZ3D) $(aStOutDistorted) $(aStImageViewer) $(aStMoviePlayer) $(aStDiagnostics) $(sView)
-android_cad: aDestAndroid = StCADViewer
-android_cad: pre_all $(aStShared) $(aStGLWidgets) $(aStCore) $(aStOutAnaglyph) $(aStOutInterlace) $(aStOutDistorted) $(aStImageViewer) $(aStMoviePlayer) $(sViewAndroidCad) install_android install_android_cad_libs
-android:     pre_all $(aStShared) $(aStGLWidgets) $(aStCore) $(aStOutAnaglyph) $(aStOutInterlace) $(aStOutDistorted) $(aStImageViewer) $(aStMoviePlayer) $(sViewAndroid)    install_android install_android_libs
+sViewApk        := $(SRCDIR)/build/sView.apk
+sViewApkSigned  := $(SRCDIR)/build/sView.signed.apk.tmp
+sViewApkUnsigned:= $(SRCDIR)/build/sView.unsigned.apk.tmp
+aDestAndroid    := build/apk-tmp
+sViewDex        := $(aDestAndroid)/classes.dex
+
+all:         shared $(aStDiagnostics) $(sView)
+android_cad: pre_all_android shared $(sViewAndroidCad) $(sViewApk) install_android install_android_cad_libs
+android:     pre_all_android shared $(sViewAndroid)    $(sViewApk) install_android install_android_libs
+shared:      pre_all $(aStShared) $(aStGLWidgets) $(aStCore) outputs_all $(aStImageViewer) $(aStMoviePlayer)
 clean:       clean_StShared clean_StGLWidgets clean_StCore clean_sView clean_StOutAnaglyph clean_StOutDual clean_StOutInterlace clean_StOutPageFlip clean_StOutIZ3D clean_StOutDistorted clean_StImageViewer clean_StMoviePlayer clean_StDiagnostics clean_StCADViewer clean_sViewAndroid
 distclean:   clean
 
@@ -224,33 +287,34 @@
 endif
 
 install:
-	mkdir -p $(DESTDIR)/usr/bin
-	mkdir -p $(DESTDIR)/usr/$(USR_LIB)/sView
-	mkdir -p $(DESTDIR)/usr/$(USR_LIB)/firefox/plugins
-	mkdir -p $(DESTDIR)/usr/$(USR_LIB)/mozilla/plugins
-	mkdir -p $(DESTDIR)/usr/share
-	mkdir -p $(DESTDIR)/usr/share/sView/info
-	mkdir -p $(DESTDIR)/usr/share/sView/lang
-	mkdir -p $(DESTDIR)/usr/share/sView/shaders
-	mkdir -p $(DESTDIR)/usr/share/sView/textures
-	mkdir -p $(DESTDIR)/usr/share/sView/web
-	cp -f -r share/*                     $(DESTDIR)/usr/share/
-	cp -f -r $(BUILD_ROOT)/lang/*        $(DESTDIR)/usr/share/sView/lang/
-	cp -f -r $(BUILD_ROOT)/shaders/*     $(DESTDIR)/usr/share/sView/shaders/
-	cp -f -r $(BUILD_ROOT)/textures/*    $(DESTDIR)/usr/share/sView/textures/
-	cp -f -r $(BUILD_ROOT)/web/*         $(DESTDIR)/usr/share/sView/web/
-	cp -f    license-gpl-3.0.txt         $(DESTDIR)/usr/share/sView/info/license.txt
-	cp -f -r $(BUILD_ROOT)/*.$(LIBSUFFIX) $(DESTDIR)/usr/$(USR_LIB)/
-	cp -f    $(BUILD_ROOT)/sView         $(DESTDIR)/usr/$(USR_LIB)/sView/sView
-	ln --force --symbolic ../$(USR_LIB)/sView/sView       $(DESTDIR)/usr/bin/sView
-	ln --force --symbolic ../../share/sView/demo/demo.jps $(DESTDIR)/usr/$(USR_LIB)/sView/demo.jps
-	rm -f    $(DESTDIR)/usr/$(USR_LIB)/sView/*.a
+	mkdir -p $(DESTDIR)/$(APP_PREFIX)/bin
+	mkdir -p $(DESTDIR)/$(APP_PREFIX)/$(USR_LIB)/sView
+	mkdir -p $(DESTDIR)/$(APP_PREFIX)/$(USR_LIB)/firefox/plugins
+	mkdir -p $(DESTDIR)/$(APP_PREFIX)/$(USR_LIB)/mozilla/plugins
+	mkdir -p $(DESTDIR)/$(APP_PREFIX)/share
+	mkdir -p $(DESTDIR)/$(APP_PREFIX)/share/sView/info
+	mkdir -p $(DESTDIR)/$(APP_PREFIX)/share/sView/lang
+	mkdir -p $(DESTDIR)/$(APP_PREFIX)/share/sView/shaders
+	mkdir -p $(DESTDIR)/$(APP_PREFIX)/share/sView/textures
+	mkdir -p $(DESTDIR)/$(APP_PREFIX)/share/sView/web
+	cp -f -r share/*                     $(DESTDIR)/$(APP_PREFIX)/share/
+	cp -f -r $(BUILD_ROOT)/lang/*        $(DESTDIR)/$(APP_PREFIX)/share/sView/lang/
+	cp -f -r $(BUILD_ROOT)/shaders/*     $(DESTDIR)/$(APP_PREFIX)/share/sView/shaders/
+	cp -f -r $(BUILD_ROOT)/textures/*    $(DESTDIR)/$(APP_PREFIX)/share/sView/textures/
+	cp -f -r $(BUILD_ROOT)/web/*         $(DESTDIR)/$(APP_PREFIX)/share/sView/web/
+	cp -f    license-gpl-3.0.txt         $(DESTDIR)/$(APP_PREFIX)/share/sView/info/license.txt
+	cp -f -r $(BUILD_ROOT)/*.$(LIBSUFFIX) $(DESTDIR)/$(APP_PREFIX)/$(USR_LIB)/
+	cp -f    $(BUILD_ROOT)/sView         $(DESTDIR)/$(APP_PREFIX)/$(USR_LIB)/sView/sView
+	ln --force --symbolic ../$(USR_LIB)/sView/sView       $(DESTDIR)/$(APP_PREFIX)/bin/sView
+	ln --force --symbolic ../../share/sView/demo/demo.jps $(DESTDIR)/$(APP_PREFIX)/$(USR_LIB)/sView/demo.jps
+	rm -f    $(DESTDIR)/$(APP_PREFIX)/$(USR_LIB)/sView/*.a
 
 install_android:
 	mkdir -p $(aDestAndroid)/assets/info
 	mkdir -p $(aDestAndroid)/assets/lang/German
 	mkdir -p $(aDestAndroid)/assets/lang/French
 	mkdir -p $(aDestAndroid)/assets/lang/English
+	mkdir -p $(aDestAndroid)/assets/lang/Spanish
 	mkdir -p $(aDestAndroid)/assets/lang/Russian
 	mkdir -p $(aDestAndroid)/assets/lang/Czech
 	mkdir -p $(aDestAndroid)/assets/lang/ChineseS
@@ -260,6 +324,7 @@
 	cp -f -r $(BUILD_ROOT)/lang/Deutsch/*  $(aDestAndroid)/assets/lang/German/
 	cp -f -r $(BUILD_ROOT)/lang/français/* $(aDestAndroid)/assets/lang/French/
 	cp -f -r $(BUILD_ROOT)/lang/English/*  $(aDestAndroid)/assets/lang/English/
+	cp -f -r $(BUILD_ROOT)/lang/Español/*  $(aDestAndroid)/assets/lang/Spanish/
 	cp -f -r $(BUILD_ROOT)/lang/русский/*  $(aDestAndroid)/assets/lang/Russian/
 	cp -f -r $(BUILD_ROOT)/lang/Czech/*    $(aDestAndroid)/assets/lang/Czech/
 	cp -f -r $(BUILD_ROOT)/lang/ChineseS/* $(aDestAndroid)/assets/lang/ChineseS/
@@ -267,51 +332,53 @@
 	cp -f -r $(BUILD_ROOT)/shaders/*       $(aDestAndroid)/assets/shaders/
 	cp -f -r $(BUILD_ROOT)/textures/*      $(aDestAndroid)/assets/textures/
 	cp -f    license-gpl-3.0.txt           $(aDestAndroid)/assets/info/license.txt
+	$(ANDROID_BUILD_TOOLS)/aapt package -v -f -m -S $(SRCDIR)/sview/res -J $(BUILD_ROOT)/java/gen -M $(SRCDIR)/sview/AndroidManifest.xml -I $(ANDROID_PLATFORM)
 
 install_android_libs: $(aStShared) $(aStGLWidgets) $(aStCore) $(aStOutAnaglyph) $(aStOutInterlace) $(aStOutDistorted) $(aStImageViewer) $(aStMoviePlayer) $(sViewAndroid)
-	cp -f $(BUILD_ROOT)/$(aStShared)       $(aDestAndroid)/libs/$(ANDROID_EABI)/
-	cp -f $(BUILD_ROOT)/$(aStGLWidgets)    $(aDestAndroid)/libs/$(ANDROID_EABI)/
-	cp -f $(BUILD_ROOT)/$(aStCore)         $(aDestAndroid)/libs/$(ANDROID_EABI)/
-	cp -f $(BUILD_ROOT)/$(aStOutAnaglyph)  $(aDestAndroid)/libs/$(ANDROID_EABI)/
-	cp -f $(BUILD_ROOT)/$(aStOutInterlace) $(aDestAndroid)/libs/$(ANDROID_EABI)/
-	cp -f $(BUILD_ROOT)/$(aStOutDistorted) $(aDestAndroid)/libs/$(ANDROID_EABI)/
-	cp -f $(BUILD_ROOT)/$(aStImageViewer)  $(aDestAndroid)/libs/$(ANDROID_EABI)/
-	cp -f $(BUILD_ROOT)/$(aStMoviePlayer)  $(aDestAndroid)/libs/$(ANDROID_EABI)/
-	cp -f $(BUILD_ROOT)/$(sViewAndroid)    $(aDestAndroid)/libs/$(ANDROID_EABI)/
-	cp -f $(ANDROID_NDK)/sources/cxx-stl/gnu-libstdc++/4.9/libs/$(ANDROID_EABI)/libgnustl_shared.so $(aDestAndroid)/libs/$(ANDROID_EABI)/
-	$(STRIP) $(STRIPFLAGS) $(aDestAndroid)/libs/$(ANDROID_EABI)/libgnustl_shared.so
-	cp -f $(FREETYPE_ROOT)/libs/$(ANDROID_EABI)/libfreetype.so    $(aDestAndroid)/libs/$(ANDROID_EABI)/
-	cp -f $(OPENAL_ROOT)/libs/$(ANDROID_EABI)/libopenal.so        $(aDestAndroid)/libs/$(ANDROID_EABI)/
-	cp -f $(FFMPEG_ROOT)/libs/$(ANDROID_EABI)/libavcodec.so       $(aDestAndroid)/libs/$(ANDROID_EABI)/
-	cp -f $(FFMPEG_ROOT)/libs/$(ANDROID_EABI)/libavdevice.so      $(aDestAndroid)/libs/$(ANDROID_EABI)/
-	cp -f $(FFMPEG_ROOT)/libs/$(ANDROID_EABI)/libavformat.so      $(aDestAndroid)/libs/$(ANDROID_EABI)/
-	cp -f $(FFMPEG_ROOT)/libs/$(ANDROID_EABI)/libavutil.so        $(aDestAndroid)/libs/$(ANDROID_EABI)/
-	cp -f $(FFMPEG_ROOT)/libs/$(ANDROID_EABI)/libswresample.so    $(aDestAndroid)/libs/$(ANDROID_EABI)/
-	cp -f $(FFMPEG_ROOT)/libs/$(ANDROID_EABI)/libswscale.so       $(aDestAndroid)/libs/$(ANDROID_EABI)/
+	cp -f $(BUILD_ROOT)/$(aStShared)       $(aDestAndroid)/lib/$(ANDROID_EABI)/
+	cp -f $(BUILD_ROOT)/$(aStGLWidgets)    $(aDestAndroid)/lib/$(ANDROID_EABI)/
+	cp -f $(BUILD_ROOT)/$(aStCore)         $(aDestAndroid)/lib/$(ANDROID_EABI)/
+	cp -f $(BUILD_ROOT)/$(aStOutAnaglyph)  $(aDestAndroid)/lib/$(ANDROID_EABI)/
+	cp -f $(BUILD_ROOT)/$(aStOutInterlace) $(aDestAndroid)/lib/$(ANDROID_EABI)/
+	cp -f $(BUILD_ROOT)/$(aStOutDistorted) $(aDestAndroid)/lib/$(ANDROID_EABI)/
+	cp -f $(BUILD_ROOT)/$(aStImageViewer)  $(aDestAndroid)/lib/$(ANDROID_EABI)/
+	cp -f $(BUILD_ROOT)/$(aStMoviePlayer)  $(aDestAndroid)/lib/$(ANDROID_EABI)/
+	cp -f $(BUILD_ROOT)/$(sViewAndroid)    $(aDestAndroid)/lib/$(ANDROID_EABI)/
+	cp -f $(ANDROID_NDK)/sources/cxx-stl/gnu-libstdc++/4.9/libs/$(ANDROID_EABI)/libgnustl_shared.so $(aDestAndroid)/lib/$(ANDROID_EABI)/
+	$(STRIP) $(STRIPFLAGS) $(aDestAndroid)/lib/$(ANDROID_EABI)/libgnustl_shared.so
+	cp -f $(FREETYPE_ROOT)/libs/$(ANDROID_EABI)/libfreetype.so    $(aDestAndroid)/lib/$(ANDROID_EABI)/
+	cp -f $(OPENAL_ROOT)/libs/$(ANDROID_EABI)/libopenal.so        $(aDestAndroid)/lib/$(ANDROID_EABI)/
+	cp -f $(FFMPEG_ROOT)/libs/$(ANDROID_EABI)/libavcodec.so       $(aDestAndroid)/lib/$(ANDROID_EABI)/
+	cp -f $(FFMPEG_ROOT)/libs/$(ANDROID_EABI)/libavdevice.so      $(aDestAndroid)/lib/$(ANDROID_EABI)/
+	cp -f $(FFMPEG_ROOT)/libs/$(ANDROID_EABI)/libavformat.so      $(aDestAndroid)/lib/$(ANDROID_EABI)/
+	cp -f $(FFMPEG_ROOT)/libs/$(ANDROID_EABI)/libavutil.so        $(aDestAndroid)/lib/$(ANDROID_EABI)/
+	cp -f $(FFMPEG_ROOT)/libs/$(ANDROID_EABI)/libswresample.so    $(aDestAndroid)/lib/$(ANDROID_EABI)/
+	cp -f $(FFMPEG_ROOT)/libs/$(ANDROID_EABI)/libswscale.so       $(aDestAndroid)/lib/$(ANDROID_EABI)/
 
 install_android_cad_libs: $(aStShared) $(aStGLWidgets) $(aStCore) $(aStOutAnaglyph) $(aStOutInterlace) $(aStOutDistorted) $(aStImageViewer) $(aStMoviePlayer) $(sViewAndroidCad)
-	cp -f $(BUILD_ROOT)/$(aStShared)       $(aDestAndroid)/libs/$(ANDROID_EABI)/
-	cp -f $(BUILD_ROOT)/$(aStGLWidgets)    $(aDestAndroid)/libs/$(ANDROID_EABI)/
-	cp -f $(BUILD_ROOT)/$(aStCore)         $(aDestAndroid)/libs/$(ANDROID_EABI)/
-	cp -f $(BUILD_ROOT)/$(aStOutAnaglyph)  $(aDestAndroid)/libs/$(ANDROID_EABI)/
-	cp -f $(BUILD_ROOT)/$(aStOutInterlace) $(aDestAndroid)/libs/$(ANDROID_EABI)/
-	cp -f $(BUILD_ROOT)/$(aStOutDistorted) $(aDestAndroid)/libs/$(ANDROID_EABI)/
-	cp -f $(BUILD_ROOT)/$(aStImageViewer)  $(aDestAndroid)/libs/$(ANDROID_EABI)/
-	cp -f $(BUILD_ROOT)/$(aStMoviePlayer)  $(aDestAndroid)/libs/$(ANDROID_EABI)/
-	cp -f $(BUILD_ROOT)/$(sViewAndroidCad) $(aDestAndroid)/libs/$(ANDROID_EABI)/
-	cp -f $(FREETYPE_ROOT)/libs/$(ANDROID_EABI)/libfreetype.so    $(aDestAndroid)/libs/$(ANDROID_EABI)/
-	cp -f $(OPENAL_ROOT)/libs/$(ANDROID_EABI)/libopenal.so        $(aDestAndroid)/libs/$(ANDROID_EABI)/
-	cp -f $(FFMPEG_ROOT)/libs/$(ANDROID_EABI)/libavcodec.so       $(aDestAndroid)/libs/$(ANDROID_EABI)/
-	cp -f $(FFMPEG_ROOT)/libs/$(ANDROID_EABI)/libavdevice.so      $(aDestAndroid)/libs/$(ANDROID_EABI)/
-	cp -f $(FFMPEG_ROOT)/libs/$(ANDROID_EABI)/libavformat.so      $(aDestAndroid)/libs/$(ANDROID_EABI)/
-	cp -f $(FFMPEG_ROOT)/libs/$(ANDROID_EABI)/libavutil.so        $(aDestAndroid)/libs/$(ANDROID_EABI)/
-	cp -f $(FFMPEG_ROOT)/libs/$(ANDROID_EABI)/libswresample.so    $(aDestAndroid)/libs/$(ANDROID_EABI)/
-	cp -f $(FFMPEG_ROOT)/libs/$(ANDROID_EABI)/libswscale.so       $(aDestAndroid)/libs/$(ANDROID_EABI)/
+	cp -f $(BUILD_ROOT)/$(aStShared)       $(aDestAndroid)/lib/$(ANDROID_EABI)/
+	cp -f $(BUILD_ROOT)/$(aStGLWidgets)    $(aDestAndroid)/lib/$(ANDROID_EABI)/
+	cp -f $(BUILD_ROOT)/$(aStCore)         $(aDestAndroid)/lib/$(ANDROID_EABI)/
+	cp -f $(BUILD_ROOT)/$(aStOutAnaglyph)  $(aDestAndroid)/lib/$(ANDROID_EABI)/
+	cp -f $(BUILD_ROOT)/$(aStOutInterlace) $(aDestAndroid)/lib/$(ANDROID_EABI)/
+	cp -f $(BUILD_ROOT)/$(aStOutDistorted) $(aDestAndroid)/lib/$(ANDROID_EABI)/
+	cp -f $(BUILD_ROOT)/$(aStImageViewer)  $(aDestAndroid)/lib/$(ANDROID_EABI)/
+	cp -f $(BUILD_ROOT)/$(aStMoviePlayer)  $(aDestAndroid)/lib/$(ANDROID_EABI)/
+	cp -f $(BUILD_ROOT)/$(sViewAndroidCad) $(aDestAndroid)/lib/$(ANDROID_EABI)/
+	cp -f $(FREETYPE_ROOT)/libs/$(ANDROID_EABI)/libfreetype.so    $(aDestAndroid)/lib/$(ANDROID_EABI)/
+	cp -f $(OPENAL_ROOT)/libs/$(ANDROID_EABI)/libopenal.so        $(aDestAndroid)/lib/$(ANDROID_EABI)/
+	cp -f $(FFMPEG_ROOT)/libs/$(ANDROID_EABI)/libavcodec.so       $(aDestAndroid)/lib/$(ANDROID_EABI)/
+	cp -f $(FFMPEG_ROOT)/libs/$(ANDROID_EABI)/libavdevice.so      $(aDestAndroid)/lib/$(ANDROID_EABI)/
+	cp -f $(FFMPEG_ROOT)/libs/$(ANDROID_EABI)/libavformat.so      $(aDestAndroid)/lib/$(ANDROID_EABI)/
+	cp -f $(FFMPEG_ROOT)/libs/$(ANDROID_EABI)/libavutil.so        $(aDestAndroid)/lib/$(ANDROID_EABI)/
+	cp -f $(FFMPEG_ROOT)/libs/$(ANDROID_EABI)/libswresample.so    $(aDestAndroid)/lib/$(ANDROID_EABI)/
+	cp -f $(FFMPEG_ROOT)/libs/$(ANDROID_EABI)/libswscale.so       $(aDestAndroid)/lib/$(ANDROID_EABI)/
 	mkdir -p $(aDestAndroid)/assets/shaders
 	mkdir -p $(aDestAndroid)/assets/lang
 
 pre_all:
 	mkdir -p $(BUILD_ROOT)/lang/English
+	mkdir -p $(BUILD_ROOT)/lang/Español
 	mkdir -p $(BUILD_ROOT)/lang/русский
 	mkdir -p $(BUILD_ROOT)/lang/français
 	mkdir -p $(BUILD_ROOT)/lang/Deutsch
@@ -320,10 +387,13 @@
 	mkdir -p $(BUILD_ROOT)/lang/Korean
 	mkdir -p $(BUILD_ROOT)/textures
 	mkdir -p $(BUILD_ROOT)/web
-	mkdir -p sview/libs/$(ANDROID_EABI)
-	mkdir -p StCADViewer/libs/$(ANDROID_EABI)
 	cp -f -r textures/* $(BUILD_ROOT)/textures/
 
+pre_all_android:
+	mkdir -p $(aDestAndroid)/lib/$(ANDROID_EABI)
+	mkdir -p $(BUILD_ROOT)/java/gen
+	mkdir -p $(BUILD_ROOT)/java/classes
+
 # StShared shared library
 aStShared_SRCS1 := $(sort $(wildcard $(SRCDIR)/StShared/*.cpp))
 aStShared_OBJS1 := ${aStShared_SRCS1:.cpp=.o}
@@ -378,6 +448,7 @@
 	mkdir -p $(BUILD_ROOT)/shaders/StOutAnaglyph/
 	cp -f -r StOutAnaglyph/shaders/*      $(BUILD_ROOT)/shaders/StOutAnaglyph/
 	cp -f -r StOutAnaglyph/lang/english/* $(BUILD_ROOT)/lang/English/
+	cp -f -r StOutAnaglyph/lang/spanish/* $(BUILD_ROOT)/lang/Español/
 	cp -f -r StOutAnaglyph/lang/russian/* $(BUILD_ROOT)/lang/русский/
 	cp -f -r StOutAnaglyph/lang/french/*  $(BUILD_ROOT)/lang/français/
 	cp -f -r StOutAnaglyph/lang/german/*  $(BUILD_ROOT)/lang/Deutsch/
@@ -398,6 +469,7 @@
 	$(LD) -shared $(call libinstname,$@) $(LDFLAGS) $(LIBDIR) $(aStOutDual_OBJS) $(aStOutDual_LIB) -o $(BUILD_ROOT)/$@
 pre_StOutDual:
 	cp -f -r StOutDual/lang/english/* $(BUILD_ROOT)/lang/English/
+	cp -f -r StOutDual/lang/spanish/* $(BUILD_ROOT)/lang/Español/
 	cp -f -r StOutDual/lang/russian/* $(BUILD_ROOT)/lang/русский/
 	cp -f -r StOutDual/lang/french/*  $(BUILD_ROOT)/lang/français/
 	cp -f -r StOutDual/lang/german/*  $(BUILD_ROOT)/lang/Deutsch/
@@ -419,6 +491,7 @@
 	mkdir -p $(BUILD_ROOT)/shaders/StOutIZ3D/
 	cp -f -r StOutIZ3D/shaders/*      $(BUILD_ROOT)/shaders/StOutIZ3D/
 	cp -f -r StOutIZ3D/lang/english/* $(BUILD_ROOT)/lang/English/
+	cp -f -r StOutIZ3D/lang/spanish/* $(BUILD_ROOT)/lang/Español/
 	cp -f -r StOutIZ3D/lang/russian/* $(BUILD_ROOT)/lang/русский/
 	cp -f -r StOutIZ3D/lang/french/*  $(BUILD_ROOT)/lang/français/
 	cp -f -r StOutIZ3D/lang/german/*  $(BUILD_ROOT)/lang/Deutsch/
@@ -441,6 +514,7 @@
 	mkdir -p $(BUILD_ROOT)/shaders/StOutInterlace/
 	cp -f -r StOutInterlace/shaders/*      $(BUILD_ROOT)/shaders/StOutInterlace/
 	cp -f -r StOutInterlace/lang/english/* $(BUILD_ROOT)/lang/English/
+	cp -f -r StOutInterlace/lang/spanish/* $(BUILD_ROOT)/lang/Español/
 	cp -f -r StOutInterlace/lang/russian/* $(BUILD_ROOT)/lang/русский/
 	cp -f -r StOutInterlace/lang/french/*  $(BUILD_ROOT)/lang/français/
 	cp -f -r StOutInterlace/lang/german/*  $(BUILD_ROOT)/lang/Deutsch/
@@ -467,6 +541,7 @@
 	$(LD) -shared $(call libinstname,$@) $(LDFLAGS) $(LIBDIR) $(aStOutPageFlip_OBJS1) $(aStOutPageFlip_OBJS2) $(aStOutPageFlip_LIB) -o $(BUILD_ROOT)/$@
 pre_StOutPageFlip:
 	cp -f -r StOutPageFlip/lang/english/* $(BUILD_ROOT)/lang/English/
+	cp -f -r StOutPageFlip/lang/spanish/* $(BUILD_ROOT)/lang/Español/
 	cp -f -r StOutPageFlip/lang/russian/* $(BUILD_ROOT)/lang/русский/
 	cp -f -r StOutPageFlip/lang/french/*  $(BUILD_ROOT)/lang/français/
 	cp -f -r StOutPageFlip/lang/german/*  $(BUILD_ROOT)/lang/Deutsch/
@@ -486,6 +561,7 @@
 	$(LD) -shared $(call libinstname,$@) $(LDFLAGS) $(LIBDIR) $(aStOutDistorted_OBJS) $(aStOutDistorted_LIB) -o $(BUILD_ROOT)/$@
 pre_StOutDistorted:
 	cp -f -r StOutDistorted/lang/english/* $(BUILD_ROOT)/lang/English/
+	cp -f -r StOutDistorted/lang/spanish/* $(BUILD_ROOT)/lang/Español/
 	cp -f -r StOutDistorted/lang/russian/* $(BUILD_ROOT)/lang/русский/
 	cp -f -r StOutDistorted/lang/french/*  $(BUILD_ROOT)/lang/français/
 	cp -f -r StOutDistorted/lang/german/*  $(BUILD_ROOT)/lang/Deutsch/
@@ -505,6 +581,7 @@
 	$(LD) -shared $(call libinstname,$@) $(LDFLAGS) $(LIBDIR) $(aStImageViewer_OBJS) $(aStImageViewer_LIB) -o $(BUILD_ROOT)/$@
 pre_StImageViewer:
 	cp -f -r StImageViewer/lang/english/* $(BUILD_ROOT)/lang/English/
+	cp -f -r StImageViewer/lang/spanish/* $(BUILD_ROOT)/lang/Español/
 	cp -f -r StImageViewer/lang/russian/* $(BUILD_ROOT)/lang/русский/
 	cp -f -r StImageViewer/lang/french/*  $(BUILD_ROOT)/lang/français/
 	cp -f -r StImageViewer/lang/german/*  $(BUILD_ROOT)/lang/Deutsch/
@@ -523,11 +600,12 @@
 aStMoviePlayer_OBJS2 := ${aStMoviePlayer_SRCS2:.cpp=.o}
 aStMoviePlayer_SRCS3 := $(sort $(wildcard $(SRCDIR)/StMoviePlayer/*.c))
 aStMoviePlayer_OBJS3 := ${aStMoviePlayer_SRCS3:.c=.o}
-aStMoviePlayer_LIB   := $(LIB) -lStGLWidgets -lStShared -lStCore $(LIB_OUTPUTS) $(LIB_GLX) $(LIB_GTK) -lavutil -lavformat -lavcodec -lswscale $(LIB_OPENAL) $(LIB_PTHREAD)
+aStMoviePlayer_LIB   := $(LIB) -lStGLWidgets -lStShared -lStCore $(LIB_OUTPUTS) $(LIB_GLX) $(LIB_GTK) -lavutil -lavformat -lavcodec -lswscale $(LIB_OPENAL) $(LIB_COREVIDEO) $(LIB_PTHREAD)
 $(aStMoviePlayer) : pre_StMoviePlayer $(aStGLWidgets) outputs_all $(aStMoviePlayer_OBJS1) $(aStMoviePlayer_OBJS2) $(aStMoviePlayer_OBJS3)
 	$(LD) -shared $(call libinstname,$@) $(LDFLAGS) $(LIBDIR) $(aStMoviePlayer_OBJS1) $(aStMoviePlayer_OBJS2) $(aStMoviePlayer_OBJS3) $(aStMoviePlayer_LIB) -o $(BUILD_ROOT)/$@
 pre_StMoviePlayer:
 	cp -f -r StMoviePlayer/lang/english/* $(BUILD_ROOT)/lang/English/
+	cp -f -r StMoviePlayer/lang/spanish/* $(BUILD_ROOT)/lang/Español/
 	cp -f -r StMoviePlayer/lang/russian/* $(BUILD_ROOT)/lang/русский/
 	cp -f -r StMoviePlayer/lang/french/*  $(BUILD_ROOT)/lang/français/
 	cp -f -r StMoviePlayer/lang/german/*  $(BUILD_ROOT)/lang/Deutsch/
@@ -550,6 +628,7 @@
 	$(LD) -shared $(call libinstname,$@) $(LDFLAGS) $(LIBDIR) $(aStDiagnostics_OBJS) $(aStDiagnostics_LIB) -o $(BUILD_ROOT)/$@
 pre_StDiagnostics:
 	cp -f -r StDiagnostics/lang/english/* $(BUILD_ROOT)/lang/English/
+	cp -f -r StDiagnostics/lang/spanish/* $(BUILD_ROOT)/lang/Español/
 	cp -f -r StDiagnostics/lang/russian/* $(BUILD_ROOT)/lang/русский/
 	cp -f -r StDiagnostics/lang/french/*  $(BUILD_ROOT)/lang/français/
 	cp -f -r StDiagnostics/lang/german/*  $(BUILD_ROOT)/lang/Deutsch/
@@ -581,6 +660,7 @@
 	$(LD) -shared $(call libinstname,$@) $(LDFLAGS) $(LIBDIR) $(aStCADViewer_OBJS) $(aStCADViewer_LIB) -o $(BUILD_ROOT)/$@
 pre_StCADViewer:
 	cp -f -r StCADViewer/lang/english/* $(BUILD_ROOT)/lang/English/
+	cp -f -r StCADViewer/lang/spanish/* $(BUILD_ROOT)/lang/Español/
 	cp -f -r StCADViewer/lang/russian/* $(BUILD_ROOT)/lang/русский/
 	cp -f -r StCADViewer/lang/french/*  $(BUILD_ROOT)/lang/français/
 	cp -f -r StCADViewer/lang/german/*  $(BUILD_ROOT)/lang/Deutsch/
@@ -601,6 +681,14 @@
 clean_sViewAndroid:
 	rm -f $(BUILD_ROOT)/$(sViewAndroid)
 	rm -rf sview/jni/*.o
+	rm -rf $(BUILD_ROOT)/java/classes/com/sview/*.class
+	rm -rf $(SRCDIR)/sview/src/com/sview/*class
+	rm -rf $(aDestAndroid)
+	rm -f $(sViewDex)
+	rm -f $(sViewApkUnsigned)
+	rm -f $(sViewApkSigned)
+	rm -f $(sViewApk)
+	rm -rf $(BUILD_ROOT)/java/gen/com/sview/*.java
 
 # sView executable
 sView_SRCS1 := $(sort $(wildcard $(SRCDIR)/sview/*.cpp))
@@ -635,11 +723,57 @@
 	cp -R -f $(FFMPEG_ROOT)/$(LIBSUBFOLDER)/libswscale*.dylib    $(BUILD_ROOT_BUNDLE)/Contents/Frameworks
 endif
 ifneq ($(OPENAL_ROOT),)
+	mkdir -p $(BUILD_ROOT_BUNDLE)/Contents/MacOS/openal/hrtf/
 	cp -R -f $(OPENAL_ROOT)/$(LIBSUBFOLDER)/libopenal*.dylib     $(BUILD_ROOT_BUNDLE)/Contents/Frameworks
+	cp -f -r $(OPENAL_ROOT)/hrtf/*.mhr                           $(BUILD_ROOT_BUNDLE)/Contents/MacOS/openal/hrtf/
 endif
 endif
 	@echo sView building is DONE
 
+$(sViewApk): $(sViewApkSigned)
+	$(ANDROID_BUILD_TOOLS)/zipalign -v -f 4 $< $(sViewApk)
+
+# There are three options:
+# 1) Passwords are specified within Makefile / passed as make arguments
+# 2) Passwords are asked by jarsigner itself (requires console input)
+# 3) Passwords are asked using zenity message window (requires GUI input)
+ifeq ($(MAKECMDGOALS), android)
+
+ifeq ($(ANDROID_KEY_GUI), 1)
+$(sViewApkSigned): $(sViewApkUnsigned) sView_keystore_debug
+	$(eval ANDROID_KEYSTORE_PASSWORD := $(shell zenity --password --title="Android keystore"))
+	$(eval ANDROID_KEY_PASSWORD      := $(shell zenity --password --title="Android key"))
+	$(JAVA_HOME)/bin/jarsigner -verbose -sigalg SHA1withRSA -digestalg SHA1 -keystore $(ANDROID_KEYSTORE) -storepass $(ANDROID_KEYSTORE_PASSWORD) -keypass $(ANDROID_KEY_PASSWORD) -signedjar $(sViewApkSigned) $< $(ANDROID_KEY)
+else ifeq ($(ANDROID_KEY_PASSWORD),)
+$(sViewApkSigned): $(sViewApkUnsigned) sView_keystore_debug
+	$(JAVA_HOME)/bin/jarsigner -verbose -sigalg SHA1withRSA -digestalg SHA1 -keystore $(ANDROID_KEYSTORE) -signedjar $(sViewApkSigned) $< $(ANDROID_KEY)
+else
+$(sViewApkSigned): $(sViewApkUnsigned) sView_keystore_debug
+	$(JAVA_HOME)/bin/jarsigner -verbose -sigalg SHA1withRSA -digestalg SHA1 -keystore $(ANDROID_KEYSTORE) -storepass $(ANDROID_KEYSTORE_PASSWORD) -keypass $(ANDROID_KEY_PASSWORD) -signedjar $(sViewApkSigned) $< $(ANDROID_KEY)
+endif
+endif
+
+$(sViewApkUnsigned): $(sViewDex) install_android_libs
+	rm -f $(sViewApkUnsigned)
+	$(ANDROID_BUILD_TOOLS)/aapt package -v -f -M $(SRCDIR)/sview/AndroidManifest.xml -S $(SRCDIR)/sview/res -I $(ANDROID_PLATFORM) -F $(sViewApkUnsigned) $(aDestAndroid)
+
+sView_SRCS_JAVA1 := $(sort $(wildcard $(SRCDIR)/sview/src/com/sview/*.java))
+sView_OBJS_JAVA1 := ${sView_SRCS_JAVA1:.java=.class}
+$(sViewDex): $(BUILD_ROOT)/java/gen/com/sview/R.class $(sView_OBJS_JAVA1)
+	$(ANDROID_BUILD_TOOLS)/dx --dex --verbose --output=$(sViewDex) $(BUILD_ROOT)/java/classes
+
+$(BUILD_ROOT)/java/gen/com/sview/R.java: install_android $(shell find $(SRCDIR)/sview/res -type f)
+	$(ANDROID_BUILD_TOOLS)/aapt package -v -f -m -S $(SRCDIR)/sview/res -J $(BUILD_ROOT)/java/gen -M $(SRCDIR)/sview/AndroidManifest.xml -I $(ANDROID_PLATFORM)
+
+# This target generates a dummy signing key for debugging purposes.
+# Executed only when ANDROID_KEYSTORE points to non-existing file.
+ifeq (,$(wildcard $(ANDROID_KEYSTORE)))
+sView_keystore_debug:
+	$(JAVA_HOME)/bin/keytool -genkeypair -validity 1000 -dname "CN=sview_dummy,O=Android,C=JPN" -keystore $(ANDROID_KEYSTORE) \
+	-storepass $(ANDROID_KEYSTORE_PASSWORD) -keypass $(ANDROID_KEY_PASSWORD) -alias $(ANDROID_KEY) -keyalg RSA -v
+else
+sView_keystore_debug:
+endif
 
 clean_sView:
 	rm -f $(BUILD_ROOT)/$(sView)

sview-17_04.tar.gz/StBrowserPlugin/StBrowserPlugin.rc -> sview-20_08.tar.gz/StBrowserPlugin/StBrowserPlugin.rc Changed

sview-17_04.tar.gz/StCADViewer/StCADViewer.rc -> sview-20_08.tar.gz/StCADViewer/StCADViewer.rc Changed

sview-17_04.tar.gz/StCADViewer/StCADViewerGUI.cpp -> sview-20_08.tar.gz/StCADViewer/StCADViewerGUI.cpp Changed

sview-20_08.tar.gz/StCADViewer/lang/spanish Added

sview-20_08.tar.gz/StCADViewer/lang/spanish/StCADViewer.lng Added

sview-17_04.tar.gz/StCore/StAndroidGlue.cpp -> sview-20_08.tar.gz/StCore/StAndroidGlue.cpp Changed

@@ -19,60 +19,13 @@
 #include <StStrings/StLogger.h>
 
 #include <StAV/stAV.h>
+#include <StJNI/StJNIEnv.h>
 
 #include <android/window.h>
 
-#define jexp extern "C" JNIEXPORT
-
-StJNIEnv::StJNIEnv(JavaVM* theJavaVM)
-: myJavaVM(theJavaVM),
-  myJniEnv(NULL),
-  myToDetach(false) {
-    if(myJavaVM == NULL) {
-        return;
-    }
-
-    void* aJniEnv = NULL;
-    switch(myJavaVM->GetEnv(&aJniEnv, JNI_VERSION_1_6)) {
-        case JNI_EDETACHED: {
-            if(myJavaVM->AttachCurrentThread(&myJniEnv, NULL) < 0) {
-                myJniEnv = NULL;
-                ST_ERROR_LOG("Failed to attach working thread to Java VM");
-                return;
-            }
-            myToDetach = true;
-            break;
-        }
-        case JNI_OK: {
-            myJniEnv   = (JNIEnv* )aJniEnv;
-            myToDetach = false;
-            break;
-        }
-        case JNI_EVERSION: {
-            ST_ERROR_LOG("Failed to attach working thread to Java VM - JNI version is not supported");
-            break;
-        }
-        default: {
-            ST_ERROR_LOG("Failed to attach working thread to Java VM");
-            break;
-        }
-    }
-}
-
-StJNIEnv::~StJNIEnv() {
-    detach();
-}
+#include "stvkeysandroid.h" // Android NDK keys to VKEYs lookup array
 
-void StJNIEnv::detach() {
-    if(myJavaVM != NULL
-    && myJniEnv != NULL
-    && myToDetach) {
-        myJavaVM->DetachCurrentThread();
-    }
-
-    myJniEnv   = NULL;
-    myToDetach = false;
-}
+#define jexp extern "C" JNIEXPORT
 
 StAndroidResourceManager::StAndroidResourceManager(StAndroidGlue*  theGlueApp,
                                                    const StString& theAppName)
@@ -171,6 +124,7 @@
   myWindow(NULL),
   myWindowPending(NULL),
   myIsChangingSurface(false),
+  myIsWakeLockSet(false),
   myWindowFlags(0),
   myActivityState(0),
   myMemoryClassMiB(0),
@@ -190,6 +144,7 @@
   myIsRunning(false),
   myIsStateSaved(false),
   myToDestroy(false) {
+    stMemZero(myRegKeys, sizeof(myRegKeys));
     theActivity->instance = this;
     theActivity->env->GetJavaVM(&myJavaVM);
 
@@ -210,6 +165,15 @@
         myMemoryClassMiB = aJniEnv->CallIntMethod(aJActivityMgr, aJMet_getMemoryClass);
     }
 
+    if(jclass aClassBuild = aJniEnv->FindClass("android/os/Build")) {
+        if(jfieldID aJFieldModel = aJniEnv->GetStaticFieldID(aClassBuild, "MODEL", "Ljava/lang/String;")) {
+            myBuildModel = stStringFromJava(aJniEnv, (jstring )aJniEnv->GetStaticObjectField(aClassBuild, aJFieldModel));
+        }
+        if(jfieldID aJFieldDevice = aJniEnv->GetStaticFieldID(aClassBuild, "DEVICE", "Ljava/lang/String;")) {
+            myBuildDevice = stStringFromJava(aJniEnv, (jstring )aJniEnv->GetStaticObjectField(aClassBuild, aJFieldDevice));
+        }
+    }
+
     jmethodID aJMet_getStAppClass = aJniEnv->GetMethodID(aJClass_Activity, "getStAppClass", "()Ljava/lang/String;");
     myStAppClass = stStringFromJava(aJniEnv, (jstring )aJniEnv->CallObjectMethod(myActivity->clazz, aJMet_getStAppClass));
 
@@ -220,7 +184,8 @@
     jmethodID aJMet_setCppInstance = aJniEnv->GetMethodID(aJClass_Activity, "setCppInstance", "(J)V");
     aJniEnv->CallVoidMethod(myActivity->clazz, aJMet_setCppInstance, (jlong )this);
 
-    readOpenPath();
+    // do not NULLify intent here since Activity.onCreate() crashes on some devices
+    readOpenPath(false);
 
     myCmdPollSource.id        = LooperId_MAIN;
     myCmdPollSource.app       = this;
@@ -261,11 +226,11 @@
     myMsgWrite = aMsgPipe[1];
 }
 
-void StAndroidGlue::readOpenPath() {
+void StAndroidGlue::readOpenPath(bool theToNullifyIntent) {
     JNIEnv*   aJniEnv = myActivity->env;
     jclass    aJClass_Activity   = aJniEnv->GetObjectClass(myActivity->clazz);
-    jmethodID aJMet_readOpenPath = aJniEnv->GetMethodID(aJClass_Activity, "readOpenPath", "()V");
-    aJniEnv->CallVoidMethod(myActivity->clazz, aJMet_readOpenPath);
+    jmethodID aJMet_readOpenPath = aJniEnv->GetMethodID(aJClass_Activity, "readOpenPath", "(Z)V");
+    aJniEnv->CallVoidMethod(myActivity->clazz, aJMet_readOpenPath, (jboolean )(theToNullifyIntent ? JNI_TRUE : JNI_FALSE));
 }
 
 void StAndroidGlue::setOpenPath(const jstring  theOpenPath,
@@ -295,8 +260,11 @@
 
 void StAndroidGlue::fetchState(StString&             theNewFile,
                                StQuaternion<double>& theQuaternion,
-                               bool&                 theToSwapEyes) {
+                               bool&                 theToSwapEyes,
+                               const StKeysState&    theKeys) {
     StMutexAuto aLock(myFetchLock);
+    stMemCpy(myRegKeys, theKeys.getRegisteredKeys(), sizeof(myRegKeys));
+
     theQuaternion = myQuaternion;
     theToSwapEyes = myToSwapEyesHW;
     if(!myDndPath.isEmpty()) {
@@ -376,8 +344,17 @@
 
     StMonitor aMon;
     aMon.setId(0);
+
+    const StString aBuildDevice = myBuildDevice.lowerCased();
+    const StString aBuildModel  = myBuildModel.lowerCased();
     if(myStereoApiId == "S3DV") {
         aMon.setPnPId("ST@S3DV");
+    } else if(aBuildDevice == "king7s" || aBuildModel == "pp6000") { // PPTV King 7S
+        aMon.setPnPId("ST@COL0");
+    } else if(aBuildModel == "y6 max 3d") { // DOOGEE Y6 Max 3D
+        aMon.setPnPId("ST@COL0");
+    } else if(aBuildModel == "p8 3d" || aBuildModel == "p8_3d") { // Elephone P8 3D
+        aMon.setPnPId("ST@COL0");
     }
     aMon.changeVRect().top()    = 0;
     aMon.changeVRect().left()   = 0;
@@ -523,14 +500,26 @@
         postMessage("jp.co.sharp.android.stereo3dlcd !!!");
     }*/
 
-    createApplication();
-    if(!myApp.isNull()) {
-        if(!myApp->open()) {
+    for(;;) {
+        createApplication();
+        if(myApp.isNull()) {
+            stError("Error: no application to execute!");
+            break;
+        } else if(!myApp->open()) {
             stError("Error: application can not be executed!");
+            break;
         }
         myApp->exec();
-    } else {
-        stError("Error: no application to execute!");
+
+        StHandle<StOpenInfo> anOther = myApp->getOpenFileInOtherDrawer();
+        if(anOther.isNull()) {
+            break;
+        }
+
+        myApp.nullify();
+        StArgument aDrawerArg = anOther->getArgumentsMap()["in"];
+        myDndPath = anOther->getPath();
+        myStAppClass = aDrawerArg.getValue();
     }
     myApp.nullify();
 
@@ -767,7 +756,7 @@
 
 void StAndroidGlue::setActivityState(int8_t theState) {
     if(theState == StAndroidGlue::CommandId_Resume) {
-        readOpenPath();
+        readOpenPath(true);
     }
 
     pthread_mutex_lock(&myMutex);
@@ -834,6 +823,36 @@
     ANativeActivity_setWindowFlags(myActivity, aFlagsToAdd, aFlagsToRemove);
 }
 
+void StAndroidGlue::setWakeLock(const StString& theTitle, bool theToLock) {
+    if((myIsWakeLockSet == theToLock
+     && myWakeLockTitle == theTitle)
+    || myThJniEnv == NULL) {
+        return;
+    }
+
+    jclass    aJClassActivity = myThJniEnv->GetObjectClass(myActivity->clazz);
+    jmethodID aJMet           = myThJniEnv->GetMethodID(aJClassActivity, "setPartialWakeLockOn", "(Ljava/lang/String;Z)V");
+    jstring   aJStrTitle      = myThJniEnv->NewStringUTF(theTitle.toCString());
+    myThJniEnv->CallVoidMethod(myActivity->clazz, aJMet, aJStrTitle, (jboolean )(theToLock ? JNI_TRUE : JNI_FALSE));
+    myIsWakeLockSet = theToLock;
+    myThJniEnv->DeleteLocalRef(aJStrTitle);
+    myWakeLockTitle = theTitle;
+}
+
+void StAndroidGlue::setWindowTitle(const StString& theTitle) {
+    if(myWindowTitle == theTitle
+    || myThJniEnv == NULL) {
+        return;
+    }
+
+    jclass    aJClassActivity = myThJniEnv->GetObjectClass(myActivity->clazz);
+    jmethodID aJMet           = myThJniEnv->GetMethodID(aJClassActivity, "setWindowTitle", "(Ljava/lang/String;)V");
+    jstring   aJStrTitle      = myThJniEnv->NewStringUTF(theTitle.toCString());
+    myThJniEnv->CallVoidMethod(myActivity->clazz, aJMet, aJStrTitle);
+    myThJniEnv->DeleteLocalRef(aJStrTitle);
+    myWindowTitle = theTitle;
+}
+
 void StAndroidGlue::setHardwareStereoOn(const bool theToEnable) {
     if(myToEnableStereoHW == theToEnable
     || myStereoApiId.isEmpty()
@@ -905,6 +924,20 @@
     myToSwapEyesHW = theToSwapLR;
 }
 
+bool StAndroidGlue::isKeyOverridden(int theKeyCode) {
+    StVirtKey aVKeySt = ST_VK_NULL;
+    if(theKeyCode < ST_ANDROID2ST_VK_SIZE) {
+        aVKeySt = (StVirtKey )ST_ANDROID2ST_VK[theKeyCode];
+    }
+
+    if(aVKeySt <= 0 || (int )aVKeySt >= ST_VK_NB) {
+        return false;
+    }
+
+    StMutexAuto aLock(myFetchLock);
+    return myRegKeys[aVKeySt];
+}
+
 jexp void JNICALL Java_com_sview_StActivity_cppSetOpenPath(JNIEnv* theEnv, jobject theObj, jlong theCppPtr,
                                                            jstring theOpenPath, jstring theMimeType, jboolean theIsLaunchedFromHistory) {
     ((StAndroidGlue* )theCppPtr)->setOpenPath(theOpenPath, theMimeType, theIsLaunchedFromHistory);
@@ -940,4 +973,9 @@
     ((StAndroidGlue* )theCppPtr)->setSwapEyes(theToSwap == JNI_TRUE);
 }
 
+jexp jboolean JNICALL Java_com_sview_StActivity_cppIsKeyOverridden(JNIEnv* theEnv, jobject theObj, jlong theCppPtr,
+                                                                   jint theKeyCode) {
+    return ((StAndroidGlue* )theCppPtr)->isKeyOverridden(theKeyCode);
+}
+
 #endif // __ANDROID__

sview-17_04.tar.gz/StCore/StApplication.cpp -> sview-20_08.tar.gz/StCore/StApplication.cpp Changed

@@ -1,6 +1,6 @@
 /**
  * StCore, window system independent C++ toolkit for writing OpenGL applications.
- * Copyright © 2009-2016 Kirill Gavrilov <kirill@sview.ru>
+ * Copyright © 2009-2017 Kirill Gavrilov <kirill@sview.ru>
  *
  * Distributed under the Boost Software License, Version 1.0.
  * See accompanying file license-boost.txt or copy at
@@ -21,9 +21,42 @@
 #include "StEventsBuffer.h"
 
 namespace {
+
     static const StCString ST_SETTING_RENDERER_AUTO = stCString("rendererPluginAuto");
     static const StCString ST_SETTING_RENDERER      = stCString("rendererPlugin");
     static const StCString ST_SETTING_AUTO_VALUE    = stCString("Auto");
+    static const StCString ST_SETTING_DEF_DRAWER    = stCString("defaultDrawer");
+
+    /**
+     * Auxiliary parameter.
+     */
+    class StDefaultDrawerParam : public StBoolParamNamed {
+
+            public:
+
+        /**
+         * Main constructor.
+         */
+        StDefaultDrawerParam(const StApplication* theApp, const StString& theDrawer, const StString& theTitle)
+        : StBoolParamNamed(theApp->isDefaultDrawer(theDrawer), StString(), theTitle),
+          myApp(theApp), myAppName(theDrawer) {}
+
+        /**
+         * Return list of available translations.
+         */
+        virtual bool setValue(const bool theValue) ST_ATTR_OVERRIDE {
+            const bool aResult = StBoolParamNamed::setValue(theValue);
+            myApp->setDefaultDrawer(theValue ? myAppName : StString());
+            return aResult;
+        }
+
+            private:
+
+        const StApplication* myApp;
+        StString myAppName;
+
+    };
+
 }
 
 void StApplication::doChangeDevice(const int32_t theValue) {
@@ -364,22 +397,32 @@
 
 void StApplication::registerHotKeys() {
     myKeyActions.clear();
+    StKeysState* aKeysState = !myWindow.isNull() ? &myWindow->changeKeysState() : NULL;
+    if(aKeysState != NULL) {
+        aKeysState->resetRegisteredKeys();
+    }
     for(std::map< int, StHandle<StAction> >::iterator anIter = myActions.begin();
         anIter != myActions.end(); ++anIter) {
         const StHandle<StAction>& anAction = anIter->second;
-        if(anAction->getHotKey1() != 0) {
-            StHandle<StAction> anOldAction = getActionForKey(anAction->getHotKey1());
-            if(!anOldAction.isNull()) {
-                anOldAction->setHotKey1(0);
+        for(int aHotIter = 0; aHotIter < 2; ++aHotIter) {
+            const unsigned int aHotKey = anAction->getHotKey(aHotIter);
+            if(aHotKey == 0) {
+                continue;
             }
-            myKeyActions[anAction->getHotKey1()] = anAction;
-        }
-        if(anAction->getHotKey2() != 0) {
-            StHandle<StAction> anOldAction = getActionForKey(anAction->getHotKey2());
+
+            StHandle<StAction> anOldAction = getActionForKey(aHotKey);
             if(!anOldAction.isNull()) {
-                anOldAction->setHotKey2(0);
+                for(int anOldHotIter = 0; anOldHotIter < 2; ++anOldHotIter) {
+                    if(anOldAction->getHotKey(anOldHotIter) == aHotKey) {
+                        anOldAction->setHotKey(anOldHotIter, 0);
+                    }
+                }
+            }
+            myKeyActions[aHotKey] = anAction;
+            if(aKeysState != NULL) {
+                const StVirtKey aVirtKey = getBaseKeyFromHotKey(aHotKey);
+                aKeysState->registerKey(aVirtKey);
             }
-            myKeyActions[anAction->getHotKey2()] = anAction;
         }
     }
 }
@@ -556,6 +599,41 @@
     return anInfo;
 }
 
+bool StApplication::isDefaultDrawer(const StString& theDrawer) const {
+    StSettings aGlobalSettings(myResMgr, "sview");
+    StString aDefDrawer;
+    aGlobalSettings.loadString(ST_SETTING_DEF_DRAWER, aDefDrawer);
+    return theDrawer == aDefDrawer;
+}
+
+void StApplication::setDefaultDrawer(const StString& theDrawer) const {
+    StSettings aGlobalSettings(myResMgr, "sview");
+    aGlobalSettings.saveString(ST_SETTING_DEF_DRAWER, theDrawer);
+}
+
+bool StApplication::readDefaultDrawer(StHandle<StOpenInfo>& theInfo) {
+    StHandle<StResourceManager> aResMgr = new StResourceManager();
+    StSettings aGlobalSettings(aResMgr, "sview");
+    StString aDefDrawer;
+    aGlobalSettings.loadString(ST_SETTING_DEF_DRAWER, aDefDrawer);
+    if(aDefDrawer.isEmpty()) {
+        return false;
+    }
+
+    if(theInfo.isNull()) {
+        theInfo = new StOpenInfo();
+    }
+    StArgumentsMap anArgs = theInfo->getArgumentsMap();
+    anArgs.add(StArgument("in", aDefDrawer));
+    theInfo->setArgumentsMap(anArgs);
+    return true;
+}
+
+StHandle<StBoolParamNamed> StApplication::createDefaultDrawerParam(const StString& theDrawer,
+                                                                   const StString& theTitle) const {
+    return new StDefaultDrawerParam(this, theDrawer, theTitle);
+}
+
 void StApplication::doChangeLanguage(const int32_t ) {
     myToRecreateMenu = true;
     myLangMap->resetReloaded();

sview-17_04.tar.gz/StCore/StCocoaView.h -> sview-20_08.tar.gz/StCore/StCocoaView.h Changed

sview-17_04.tar.gz/StCore/StCocoaView.mm -> sview-20_08.tar.gz/StCore/StCocoaView.mm Changed

@@ -50,8 +50,10 @@
     - (id ) initWithStWin: (StWindowImpl* ) theStWin
                     nsWin: (NSWindow* )     theNsWin {
         NSRect aBounds = [[theNsWin contentView] bounds];
+    ST_DISABLE_DEPRECATION_WARNINGS
         self = [super initWithFrame: aBounds
                         pixelFormat: [[NSOpenGLView class] defaultPixelFormat]];
+    ST_ENABLE_DEPRECATION_WARNINGS
         if(self == NULL) {
             return NULL;
         }
@@ -62,7 +64,9 @@
 
         // enable HiDPI mode
         if(myIsLionOS) {
+        ST_DISABLE_DEPRECATION_WARNINGS
             [self setWantsBestResolutionOpenGLSurface: YES];
+        ST_ENABLE_DEPRECATION_WARNINGS
         }
 
         // create blank cursor
@@ -348,17 +352,17 @@
         CGFloat aDeltaY = [theEvent deltaY];
         if(!stAreEqual(aDeltaX, 0.0f, 0.01f)) {
             myStEvent.Scroll.StepsX = aDeltaX > 0.0f ? -1 :  1;
-            myStEvent.Scroll.DeltaX = 10.0f * myStEvent.Scroll.StepsX;
+            myStEvent.Scroll.DeltaX = myStEvent.Scroll.StepsX;
         }
         if(!stAreEqual(aDeltaY, 0.0f, 0.01f)) {
             myStEvent.Scroll.StepsY = aDeltaY > 0.0f ?  1 : -1;
-            myStEvent.Scroll.DeltaY = 10.0f * myStEvent.Scroll.StepsY;
+            myStEvent.Scroll.DeltaY = myStEvent.Scroll.StepsY;
         }
 
         if(myIsLionOS
         && [theEvent hasPreciseScrollingDeltas]) {
-            myStEvent.Scroll.DeltaX = [theEvent scrollingDeltaX];
-            myStEvent.Scroll.DeltaY = [theEvent scrollingDeltaY];
+            myStEvent.Scroll.DeltaX = 0.1f * [theEvent scrollingDeltaX];
+            myStEvent.Scroll.DeltaY = 0.1f * [theEvent scrollingDeltaY];
         }
 
         //if([theEvent subtype] == NSMouseEventSubtype) {

sview-17_04.tar.gz/StCore/StCore.rc -> sview-20_08.tar.gz/StCore/StCore.rc Changed

sview-17_04.tar.gz/StCore/StKeysState.cpp -> sview-20_08.tar.gz/StCore/StKeysState.cpp Changed

sview-17_04.tar.gz/StCore/StSearchMonitors.cpp -> sview-20_08.tar.gz/StCore/StSearchMonitors.cpp Changed

@@ -222,9 +222,9 @@
         StRectI_t stRect(monInfo.rcMonitor.top, monInfo.rcMonitor.bottom, monInfo.rcMonitor.left, monInfo.rcMonitor.right);
         aMon.setVRect(stRect);
         aMon.setId(monCount);
-        aMon.setFreq((int )dm.dmDisplayFrequency);
+        aMon.setFreq((float )dm.dmDisplayFrequency);
         // TODO
-        aMon.setFreqMax((int )dm.dmDisplayFrequency);
+        aMon.setFreqMax((float )dm.dmDisplayFrequency);
 
         // ddMon.DeviceString = "Plug and Play monitor"
         // ddMon.DeviceName = "\\.\DISPLAY2\Monitor0"
@@ -424,7 +424,7 @@
                 break;
             }
             double aRate = std::floor(double(aMode.dotClock) / (double(aMode.hTotal) * double(aMode.vTotal)) + 0.5);
-            aMonitor.setFreq(int(aRate));
+            aMonitor.setFreq(float(aRate));
             break;
         }
 
@@ -461,7 +461,7 @@
                 aMaxRate = stMax(aMaxRate, aRate);
             }
         }
-        aMonitor.setFreqMax(int(aMaxRate));
+        aMonitor.setFreqMax(float(aMaxRate));
         XRRFreeOutputInfo(anOutputInfo);
 
         XRRFreeCrtcInfo(aCrtcInfo);

sview-17_04.tar.gz/StCore/StWinHandles.cpp -> sview-20_08.tar.gz/StCore/StWinHandles.cpp Changed

@@ -116,14 +116,21 @@
     #define ST_EGL_CONTEXT_OPENGL_CORE_PROFILE_BIT_KHR          0x00000001
     #define ST_EGL_CONTEXT_OPENGL_COMPATIBILITY_PROFILE_BIT_KHR 0x00000002
 
+    // for EGL_KHR_context_flush_control
+    #define ST_EGL_CONTEXT_RELEASE_BEHAVIOR_KHR       0x2097
+    #define ST_EGL_CONTEXT_RELEASE_BEHAVIOR_NONE_KHR  0x0000
+    #define ST_EGL_CONTEXT_RELEASE_BEHAVIOR_FLUSH_KHR 0x2098
+
     const char* anEglExts = eglQueryString(myDisplay, EGL_EXTENSIONS);
     if(StGLContext::stglCheckExtension(anEglExts, "EGL_KHR_create_context")) {
+        const bool khrFlushControl = StGLContext::stglCheckExtension(anEglExts, "EGL_KHR_context_flush_control");
         const EGLint anEglCtxAttribs[] = {
             ST_EGL_CONTEXT_FLAGS_KHR, theDebugCtx ? ST_EGL_CONTEXT_OPENGL_DEBUG_BIT_KHR : 0,
         #if defined(GL_ES_VERSION_2_0)
             EGL_CONTEXT_CLIENT_VERSION, 2,
         #endif
             //EGL_CONTEXT_OPENGL_PROFILE_MASK_KHR, ST_EGL_CONTEXT_OPENGL_COMPATIBILITY_PROFILE_BIT_KHR,
+            khrFlushControl ? ST_EGL_CONTEXT_RELEASE_BEHAVIOR_KHR : 0, khrFlushControl ? ST_EGL_CONTEXT_RELEASE_BEHAVIOR_NONE_KHR : 0,
             EGL_NONE
         };
 
@@ -240,6 +247,20 @@
 
 #else
 
+  // GLX_ARB_create_context
+#ifndef GLX_CONTEXT_MAJOR_VERSION_ARB
+    #define GLX_CONTEXT_DEBUG_BIT_ARB         0x00000001
+    #define GLX_CONTEXT_FORWARD_COMPATIBLE_BIT_ARB 0x00000002
+    #define GLX_CONTEXT_MAJOR_VERSION_ARB     0x2091
+    #define GLX_CONTEXT_MINOR_VERSION_ARB     0x2092
+    #define GLX_CONTEXT_FLAGS_ARB             0x2094
+
+    // GLX_ARB_create_context_profile
+    #define GLX_CONTEXT_CORE_PROFILE_BIT_ARB  0x00000001
+    #define GLX_CONTEXT_COMPATIBILITY_PROFILE_BIT_ARB 0x00000002
+    #define GLX_CONTEXT_PROFILE_MASK_ARB      0x9126
+#endif
+
 typedef GLXContext (*glXCreateContextAttribsARB_t)(Display* , GLXFBConfig , GLXContext , Bool , const int* );
 
 StWinGlrc::StWinGlrc(StHandle<StXDisplay>& theDisplay,
@@ -248,13 +269,15 @@
   myRC(NULL) {
     const char* aGlxExts = glXQueryExtensionsString(theDisplay->hDisplay, DefaultScreen(theDisplay->hDisplay));
     if(StGLContext::stglCheckExtension(aGlxExts, "GLX_ARB_create_context_profile")) {
+        const bool khrFlushControl = StGLContext::stglCheckExtension(aGlxExts, "GLX_ARB_create_context_profile");
         glXCreateContextAttribsARB_t aCreateCtxFunc = (glXCreateContextAttribsARB_t )glXGetProcAddress((const GLubyte* )"glXCreateContextAttribsARB");
 
         int aCtxAttribs[] = {
             //GLX_CONTEXT_MAJOR_VERSION_ARB, 2,
             //GLX_CONTEXT_MINOR_VERSION_ARB, 0,
-            GLX_CONTEXT_FLAGS_ARB,        theDebugCtx ? GLX_CONTEXT_DEBUG_BIT_ARB : 0,
             //GLX_CONTEXT_PROFILE_MASK_ARB, GLX_CONTEXT_COMPATIBILITY_PROFILE_BIT_ARB,
+            GLX_CONTEXT_FLAGS_ARB, theDebugCtx ? GLX_CONTEXT_DEBUG_BIT_ARB : 0,
+            khrFlushControl ? GLX_CONTEXT_RELEASE_BEHAVIOR_ARB : 0, khrFlushControl ? GLX_CONTEXT_RELEASE_BEHAVIOR_NONE_ARB : 0,
             None
         };
 
@@ -482,11 +505,12 @@
       if(aCtx.extAll->wglCreateContextAttribsARB != NULL) {
           // Beware! NVIDIA drivers reject context creation when WGL_CONTEXT_PROFILE_MASK_ARB are specified
           // but not WGL_CONTEXT_MAJOR_VERSION_ARB/WGL_CONTEXT_MINOR_VERSION_ARB
-          int aCtxAttribs[] = {
+          const int aCtxAttribs[] = {
               //WGL_CONTEXT_MAJOR_VERSION_ARB, 3,
               //WGL_CONTEXT_MINOR_VERSION_ARB, 2,
               //WGL_CONTEXT_PROFILE_MASK_ARB,  WGL_CONTEXT_COMPATIBILITY_PROFILE_BIT_ARB, //WGL_CONTEXT_CORE_PROFILE_BIT_ARB,
-              WGL_CONTEXT_FLAGS_ARB,         theDebugCtx ? WGL_CONTEXT_DEBUG_BIT_ARB : 0,
+              WGL_CONTEXT_FLAGS_ARB, theDebugCtx ? WGL_CONTEXT_DEBUG_BIT_ARB : 0,
+              aCtx.khrFlushControl ? WGL_CONTEXT_RELEASE_BEHAVIOR_ARB : 0, aCtx.khrFlushControl ? WGL_CONTEXT_RELEASE_BEHAVIOR_NONE_ARB : 0,
               0, 0
           };

sview-17_04.tar.gz/StCore/StWinHandles.h -> sview-20_08.tar.gz/StCore/StWinHandles.h Changed

sview-17_04.tar.gz/StCore/StWindow.cpp -> sview-20_08.tar.gz/StCore/StWindow.cpp Changed

sview-17_04.tar.gz/StCore/StWindowImpl.cpp -> sview-20_08.tar.gz/StCore/StWindowImpl.cpp Changed

@@ -97,6 +97,10 @@
   myIsMouseMoved(false) {
     stMemZero(&attribs, sizeof(attribs));
     stMemZero(&signals, sizeof(signals));
+    myStEvent   .Type = stEvent_None;
+    myStEvent2  .Type = stEvent_None;
+    myStEventAux.Type = stEvent_None;
+    myScrollAcc.reset();
     attribs.IsNoDecor      = false;
     attribs.IsStereoOutput = false;
     attribs.IsGlStereo     = false;
@@ -123,6 +127,7 @@
     myTouches.Time = 0.0;
     myTouches.clearTouches();
 
+    myTap0Touch = StTouch::Empty();
     myTap1Touch.Type = stEvent_TouchCancel;
     myTap1Touch.Time = 0.0;
     myTap1Touch.clearTouches();
@@ -381,6 +386,9 @@
             case StWinAttr_ToAlignEven:
                 anIter[1] = (StWinAttr )attribs.ToAlignEven;
                 break;
+            case StWinAttr_ExclusiveFullScreen:
+                anIter[1] = (StWinAttr)attribs.IsExclusiveFullScr;
+                break;
             default:
                 ST_DEBUG_LOG("UNKNOWN window attribute #" + anIter[0] + " requested");
                 break;
@@ -492,6 +500,9 @@
             case StWinAttr_ToAlignEven:
                 attribs.ToAlignEven = (anIter[1] == 1);
                 break;
+            case StWinAttr_ExclusiveFullScreen:
+                attribs.IsExclusiveFullScr = (anIter[1] == 1);
+                break;
             default:
                 ST_DEBUG_LOG("UNKNOWN window attribute #" + anIter[0] + " requested");
                 break;
@@ -600,14 +611,19 @@
     }
 #elif defined(__ANDROID__)
     int aFlags = 0;
+    bool toWakeLock = false;
     if(attribs.ToBlockSleepDisplay) {
         aFlags |= AWINDOW_FLAG_KEEP_SCREEN_ON;
         myBlockSleep = BlockSleep_DISPLAY;
+    } else if(attribs.ToBlockSleepSystem) {
+        myBlockSleep = BlockSleep_SYSTEM;
+        toWakeLock = true;
     } else {
         myBlockSleep = BlockSleep_OFF;
     }
     if(myParentWin != NULL) {
         myParentWin->setWindowFlags(aFlags);
+        myParentWin->setWakeLock(myWindowTitle, toWakeLock);
     }
 #elif defined(__linux__)
     if(attribs.ToBlockSleepDisplay) { // || attribs.ToBlockSleepSystem
@@ -976,6 +992,14 @@
         CURSORINFO aCursor;
         aCursor.cbSize = sizeof(aCursor);
         if(GetCursorInfo(&aCursor) != FALSE) {
+            if (attribs.IsFullScreen
+            && !attribs.IsExclusiveFullScr
+            &&  myTiledCfg == TiledCfg_Separate
+            &&  myParentWin == NULL) {
+                // workaround for non-exclusive fullscreen mode
+                aCursor.ptScreenPos.y += 2;
+            }
+
             return StPointD_t((double(aCursor.ptScreenPos.x) - double(aWinRect.left())) / double(aWinRect.width()),
                               (double(aCursor.ptScreenPos.y) - double(aWinRect.top()))  / double(aWinRect.height()));
         }
@@ -1135,6 +1159,7 @@
             }
             if(myNbTouchesMax == 0) {
                 myTouches.Time = aTime;
+                myTap0Touch = theTouches.Touches[0];
             }
             myNbTouchesMax = stMax(myNbTouchesMax, theTouches.NbTouches);
 
@@ -1179,6 +1204,19 @@
                         myTap1Touch = aCopy;
                         myTap1Touch.Type = stEvent_TouchUp;
                         myTap1Touch.Time = aTime;
+                        StGLVec2 aDelta(myTap0Touch.PointX - aCopy.Touches[0].PointX,
+                                        myTap0Touch.PointY - aCopy.Touches[0].PointY);
+                        aDelta *= aScale;
+                        if(aDelta.modulus() <= THE_THRESHOLD_TAP.FromIdle) {
+                            myStEvent2.Type = stEvent_Gesture1Tap;
+                            myStEvent2.Gesture.clearGesture();
+                            myStEvent2.Gesture.Time = aTime;
+                            myStEvent2.Gesture.Point1X = aCopy.Touches[0].PointX;
+                            myStEvent2.Gesture.Point1Y = aCopy.Touches[0].PointY;
+                            signals.onGesture->emit(myStEvent2.Gesture);
+                        }
+                    }  else {
+                        myTap1Touch.Type = stEvent_TouchCancel;
                     }
                 } else {
                     myTap1Touch.Type = stEvent_TouchCancel;
@@ -1210,8 +1248,16 @@
     }
 
     bool toUpdate = false;
-    if(myTouches .NbTouches == 2
-    && theTouches.NbTouches == 2) {
+    if(myTouches .NbTouches == 1
+    && theTouches.NbTouches == 1) {
+        StTouch aTFrom = myTouches.Touches[0];
+        StTouch aTTo = theTouches.findTouchById(aTFrom.Id);
+        if(!aTTo.isDefined()) {
+            return;
+        }
+        myTouches.Touches[0] = aTTo;
+    } else if(myTouches .NbTouches == 2
+           && theTouches.NbTouches == 2) {
         StTouch aTFrom[2] = {
             myTouches.Touches[0],
             myTouches.Touches[1]
@@ -1422,9 +1468,33 @@
             case stEvent_MouseDown:
                 signals.onMouseDown->emit(anEvent.Button);
                 break;
-            case stEvent_MouseUp:
+            case stEvent_MouseUp: {
                 signals.onMouseUp->emit(anEvent.Button);
+                if(anEvent.Button.Button != ST_MOUSE_LEFT) {
+                    myDoubleClickTimer.stop();
+                    break;
+                }
+
+                // check double click
+                const StRectI_t& aWinRect = attribs.IsFullScreen ? myRectFull : myRectNorm;
+                const StPointD_t aNewPnt(anEvent.Button.PointX, anEvent.Button.PointY);
+                const StPointD_t aDeltaPx = (myDoubleClickPnt - aNewPnt) * StPointD_t(aWinRect.width(), aWinRect.height());
+                if(myDoubleClickTimer.isOn()
+                && myDoubleClickTimer.getElapsedTime() < 0.4
+                && aDeltaPx.cwiseAbs().maxComp() < 3) {
+                    myStEvent2.Type = stEvent_Gesture1DoubleTap;
+                    myStEvent2.Gesture.clearGesture();
+                    myStEvent2.Gesture.Time = anEvent.Button.Time;
+                    myStEvent2.Gesture.Point1X = (float )anEvent.Button.PointX;
+                    myStEvent2.Gesture.Point1Y = (float )anEvent.Button.PointY;
+                    myDoubleClickTimer.stop();
+                    signals.onGesture->emit(myStEvent2.Gesture);
+                } else {
+                    myDoubleClickTimer.restart();
+                }
+                myDoubleClickPnt = aNewPnt;
                 break;
+            }
             case stEvent_TouchDown:
             case stEvent_TouchUp:
             case stEvent_TouchMove:

sview-17_04.tar.gz/StCore/StWindowImpl.h -> sview-20_08.tar.gz/StCore/StWindowImpl.h Changed

@@ -99,8 +99,10 @@
     ST_LOCAL bool wndCreateWindows(); // called from non-main thread
     ST_LOCAL LRESULT stWndProc(HWND , UINT , WPARAM , LPARAM );
 #elif defined(__APPLE__)
+    ST_DISABLE_DEPRECATION_WARNINGS
     ST_LOCAL void doCreateWindows(NSOpenGLContext* theGLContextMaster,
                                   NSOpenGLContext* theGLContextSlave);
+    ST_ENABLE_DEPRECATION_WARNINGS
 #endif
 
         public:
@@ -286,6 +288,7 @@
     bool               myIsPreciseCursor; //!< flag indicating that last mouse cursor position was updated by precise input device
     StTouchEvent       myTouches;         //!< current state of touch screen
     StTouchEvent       myTap1Touch;       //!< previous tap touch
+    StTouch            myTap0Touch;       //!< started tap
     int                myNbTouchesMax;    //!< maximum touches within current sequence
     StRectI_t          myRectNorm;        //!< master window coordinates in normal     state
     StRectI_t          myRectFull;        //!< master window coordinates in fullscreen state
@@ -477,6 +480,9 @@
     StEvent        myStEvent;          //!< temporary event object (to be used in message loop thread)
     StEvent        myStEvent2;         //!< temporary event object (to be used in message loop thread)
     StEvent        myStEventAux;       //!< extra temporary event object (to be used in StWindow creation thread)
+    StScrollEvent  myScrollAcc;        //!< extra temporary event object accumulating mouse scroll events
+    StTimer        myDoubleClickTimer; //!< timer for detecting double click
+    StPointD_t     myDoubleClickPnt;   //!< double click point
     int            myAlignDL;          //!< extra window shift applied for alignment (left)
     int            myAlignDR;          //!< extra window shift applied for alignment (right)
     int            myAlignDT;          //!< extra window shift applied for alignment (top)

sview-17_04.tar.gz/StCore/StWindowImplAnd.cpp -> sview-20_08.tar.gz/StCore/StWindowImplAnd.cpp Changed

@@ -78,7 +78,7 @@
  * Update StWindow position according to native parent position.
  */
 void StWindowImpl::updateChildRect() {
-    if(!attribs.IsFullScreen && (ANativeWindow* )myParentWin != NULL) {
+    if(!attribs.IsFullScreen && myParentWin != NULL) {
         //myRectNorm.right()  = myRectNorm.left() + widthReturn;
         //myRectNorm.bottom() = myRectNorm.top() + heightReturn;
 
@@ -169,8 +169,9 @@
             const float      aWinSizeY = aWinRect.height();
 
             // at least single point is defined
-            StPointD_t aPos0(double(AMotionEvent_getX(theEvent, 0)) / double(aWinSizeX),
-                             double(AMotionEvent_getY(theEvent, 0)) / double(aWinSizeY));
+            StPointD_t aPos0Px(AMotionEvent_getX(theEvent, 0), AMotionEvent_getY(theEvent, 0));
+            StPointD_t aPos0(double(aPos0Px.x()) / double(aWinSizeX),
+                             double(aPos0Px.y()) / double(aWinSizeY));
 
             myStEvent.Type      = stEvent_None;
             myStEvent.Base.Time = getEventTime(); /// int64_t AMotionEvent_getEventTime(theEvent);
@@ -283,6 +284,23 @@
             } else if(anAction == AMOTION_EVENT_ACTION_UP) {
                 myStEvent.Type = stEvent_MouseUp;
                 signals.onMouseUp->emit(myStEvent.Button);
+            } else if(anAction == AMOTION_EVENT_ACTION_SCROLL) {
+                float aScrollX = AMotionEvent_getAxisValue(theEvent, AMOTION_EVENT_AXIS_HSCROLL, 0);
+                float aScrollY = AMotionEvent_getAxisValue(theEvent, AMOTION_EVENT_AXIS_VSCROLL, 0);
+                myStEvent.Type = stEvent_Scroll;
+                myStEvent.Scroll.init(myStEvent.Base.Time, myMousePt.x(), myMousePt.y(),
+                                      aScrollX, aScrollY, false);
+                if((myStEvent.Scroll.Time - myScrollAcc.Time) > 0.1
+                 || std::abs(aPos0Px.x() - myScrollAcc.PointX) > 10
+                 || std::abs(aPos0Px.y() - myScrollAcc.PointY) > 10) {
+                    myScrollAcc.reset();
+                }
+                myScrollAcc.Time = myStEvent.Scroll.Time;
+                myScrollAcc.PointX = aPos0Px.x();
+                myScrollAcc.PointY = aPos0Px.y();
+                myStEvent.Scroll.StepsX = myScrollAcc.accumulateStepsX(int(aScrollX * 1000.0), 1000);
+                myStEvent.Scroll.StepsY = myScrollAcc.accumulateStepsY(int(aScrollY * 1000.0), 1000);
+                signals.onScroll->emit(myStEvent.Scroll);
             }
             return;
         }
@@ -475,18 +493,34 @@
 
     // check onNewIntent event
     StString aDndFile;
+    myParentWin->setWindowTitle(myWindowTitle);
     myParentWin->setHardwareStereoOn(myToEnableStereoHW);
     myParentWin->setTrackOrientation(myToTrackOrient);
     myParentWin->setHideSystemBars(myToHideStatusBar, myToHideNavBar);
-    myParentWin->fetchState(aDndFile, myQuaternion, myToSwapEyesHW);
+    myParentWin->fetchState(aDndFile, myQuaternion, myToSwapEyesHW, myKeysState);
     if(!aDndFile.isEmpty()) {
-        std::vector<const char*> aDndList;
-        aDndList.push_back(aDndFile.toCString());
-        myStEvent.Type = stEvent_FileDrop;
-        myStEvent.DNDrop.Time = getEventTime();
-        myStEvent.DNDrop.NbFiles = aDndList.size();
-        myStEvent.DNDrop.Files   = &aDndList[0];
-        myEventsBuffer.append(myStEvent);
+        // notice - unpress event will NOT be generated!
+        myStEvent.Type      = stEvent_KeyDown;
+        myStEvent.Key.Time  = getEventTime();
+        myStEvent.Key.Flags = ST_VF_NONE;
+        if(aDndFile == "ACTION_PLAY_PREV") {
+            myStEvent.Key.VKey  = ST_VK_MEDIA_PREV_TRACK;
+            myEventsBuffer.append(myStEvent);
+        } else if(aDndFile == "ACTION_PLAY_NEXT") {
+            myStEvent.Key.VKey  = ST_VK_MEDIA_NEXT_TRACK;
+            myEventsBuffer.append(myStEvent);
+        } else if(aDndFile == "ACTION_PLAY_PAUSE") {
+            myStEvent.Key.VKey  = ST_VK_MEDIA_PLAY_PAUSE;
+            myEventsBuffer.append(myStEvent);
+        } else {
+            std::vector<const char*> aDndList;
+            aDndList.push_back(aDndFile.toCString());
+            myStEvent.Type = stEvent_FileDrop;
+            myStEvent.DNDrop.Time = getEventTime();
+            myStEvent.DNDrop.NbFiles = aDndList.size();
+            myStEvent.DNDrop.Files   = &aDndList[0];
+            myEventsBuffer.append(myStEvent);
+        }
     }
 
     updateActiveState();
@@ -519,7 +553,8 @@
     }
 
     myIsMouseMoved = false;
-    if(myMousePt.x() >= 0.0 && myMousePt.x() <= 1.0 && myMousePt.y() >= 0.0 && myMousePt.y() <= 1.0) {
+    if(myIsPreciseCursor
+    && myMousePt.x() >= 0.0 && myMousePt.x() <= 1.0 && myMousePt.y() >= 0.0 && myMousePt.y() <= 1.0) {
         StPointD_t aDspl = myMousePt - anOldMousePt;
         if(std::abs(aDspl.x()) >= 0.0008 || std::abs(aDspl.y()) >= 0.0008) {
             myIsMouseMoved = true;

sview-17_04.tar.gz/StCore/StWindowImplLin.cpp -> sview-20_08.tar.gz/StCore/StWindowImplLin.cpp Changed

sview-17_04.tar.gz/StCore/StWindowImplMac.mm -> sview-20_08.tar.gz/StCore/StWindowImplMac.mm Changed

sview-17_04.tar.gz/StCore/StWindowImplWin.cpp -> sview-20_08.tar.gz/StCore/StWindowImplWin.cpp Changed

@@ -875,25 +875,32 @@
             return 0;
         }
         case WM_MOUSEWHEEL:    // vertical wheel
-        //case WM_MOUSEHWHEEL:   // horizontal wheel (only Vista+)
+        case WM_MOUSEHWHEEL:   // horizontal wheel (only Vista+)
         {
             const StRectI_t aWinRect = getPlacement();
             int aMouseXPx = int(short(LOWORD(lParam))) - aWinRect.left();
             int aMouseYPx = int(short(HIWORD(lParam))) - aWinRect.top();
 
-            int aZDelta = GET_WHEEL_DELTA_WPARAM(wParam); // / WHEEL_DELTA;
-            //if(GET_X_LPARAM(lParam) != 0)
-
-            myStEvent.Type = stEvent_Scroll;
-            myStEvent.Scroll.Time   = getEventTime(myEvent.time);
-            myStEvent.Scroll.PointX = double(aMouseXPx) / double(aWinRect.width());
-            myStEvent.Scroll.PointY = double(aMouseYPx) / double(aWinRect.height());
-            myStEvent.Scroll.StepsX = 0;
-            myStEvent.Scroll.StepsY = (aZDelta > 0) ? 1 : -1;
-            myStEvent.Scroll.DeltaX = 0.0;
-            myStEvent.Scroll.DeltaY = 10.0f * myStEvent.Scroll.StepsY;
-            myStEvent.Scroll.IsFromMultiTouch = false;
-
+            const bool  isVert   = (uMsg == WM_MOUSEWHEEL);
+            const int   aZDelta  = GET_WHEEL_DELTA_WPARAM(wParam);
+            const float aDeltaSt = float(aZDelta) / float(WHEEL_DELTA);
+
+            myStEvent.Scroll.init(getEventTime(myEvent.time),
+                                  double(aMouseXPx) / double(aWinRect.width()),
+                                  double(aMouseYPx) / double(aWinRect.height()),
+                                  !isVert ? aDeltaSt : 0.0f,
+                                   isVert ? aDeltaSt : 0.0f,
+                                  false);
+            if((myStEvent.Scroll.Time - myScrollAcc.Time) > 0.1
+             || std::abs(aMouseXPx - (int)myScrollAcc.PointX) > 10
+             || std::abs(aMouseYPx - (int)myScrollAcc.PointY) > 10) {
+                myScrollAcc.reset();
+            }
+            myScrollAcc.Time = myStEvent.Scroll.Time;
+            myScrollAcc.PointX = aMouseXPx;
+            myScrollAcc.PointY = aMouseYPx;
+            myStEvent.Scroll.StepsX = myScrollAcc.accumulateStepsX(!isVert ? aZDelta : 0, WHEEL_DELTA);
+            myStEvent.Scroll.StepsY = myScrollAcc.accumulateStepsY( isVert ? aZDelta : 0, WHEEL_DELTA);
             myEventsBuffer.append(myStEvent);
             return 0;
         }
@@ -1139,10 +1146,19 @@
         } else {
             // resize Master GL-subwindow
             myTiledCfg = TiledCfg_Separate;
-            const GLsizei aSizeX = (attribs.IsFullScreen) ? myRectFull.width()  : myRectNorm.width();
-            const GLsizei aSizeY = (attribs.IsFullScreen) ? myRectFull.height() : myRectNorm.height();
+            int aTop   = 0;
+            int aSizeX = (attribs.IsFullScreen) ? myRectFull.width()  : myRectNorm.width();
+            int aSizeY = (attribs.IsFullScreen) ? myRectFull.height() : myRectNorm.height();
+            if (attribs.IsFullScreen
+            && !attribs.IsExclusiveFullScr)
+            {
+              // workaround slow switching into fullscreen mode and back on Windows 10
+              // due to OpenGL driver implicitly activating an exclusive GPU usage mode
+              aTop   -= 2;
+              aSizeY += 2;
+            }
             SetWindowPos(myMaster.hWindowGl, HWND_TOP,
-                         0, 0, aSizeX, aSizeY,
+                         0, aTop, aSizeX, aSizeY,
                          SWP_NOACTIVATE);
         }
     }

sview-17_04.tar.gz/StCore/StXDisplay.h -> sview-20_08.tar.gz/StCore/StXDisplay.h Changed

sview-17_04.tar.gz/StCore/stvkeysxarray.h -> sview-20_08.tar.gz/StCore/stvkeysxarray.h Changed

sview-17_04.tar.gz/StDiagnostics/StDiagnostics.cpp -> sview-20_08.tar.gz/StDiagnostics/StDiagnostics.cpp Changed

sview-17_04.tar.gz/StDiagnostics/StDiagnostics.rc -> sview-20_08.tar.gz/StDiagnostics/StDiagnostics.rc Changed

sview-20_08.tar.gz/StDiagnostics/lang/spanish Added

sview-20_08.tar.gz/StDiagnostics/lang/spanish/StDiagnostics.lng Added

sview-17_04.tar.gz/StGLWidgets/StGLCombobox.cpp -> sview-20_08.tar.gz/StGLWidgets/StGLCombobox.cpp Changed

@@ -1,6 +1,6 @@
 /**
  * StGLWidgets, small C++ toolkit for writing GUI using OpenGL.
- * Copyright © 2015 Kirill Gavrilov <kirill@sview.ru
+ * Copyright © 2015-2020 Kirill Gavrilov <kirill@sview.ru
  *
  * Distributed under the Boost Software License, Version 1.0.
  * See accompanying file license-boost.txt or copy at
@@ -11,6 +11,7 @@
 
 #include <StGLWidgets/StGLMenuItem.h>
 #include <StGLWidgets/StGLMessageBox.h>
+#include <StGLWidgets/StGLScrollArea.h>
 #include <StGLWidgets/StGLRootWidget.h>
 
 /**
@@ -27,7 +28,7 @@
         const int aHeight = myRoot->getRootFullSizeY();
         changeRectPx().right()  = aWidth;
         changeRectPx().bottom() = aHeight;
-        create(StString(), StString(), aWidth, aHeight);
+        create(StString(), StString(), aWidth, aHeight, false);
     }
 
 };
@@ -59,7 +60,7 @@
     StGLWidget*     aMenuParent = aRoot;
     if(aRoot->isMobile()) {
         myBack = new StGLContextBackground(aRoot);
-        aMenuParent = myBack;
+        aMenuParent = myBack->getContent();
     }
 
     int aLeft = 0;
@@ -78,14 +79,18 @@
 }
 
 void StGLCombobox::ListBuilder::display() {
+    StGLRootWidget* aRoot = myMenu->getRoot();
+    const int aRootX = aRoot->getRectPx().width();
+    const int aRootY = aRoot->getRectPx().height();
     if(myBack != NULL) {
         myBack->stglInit();
+        if(myBack->getContent()->isScrollable()) {
+            myMenu->setCorner(StGLCorner(ST_VCORNER_TOP, ST_HCORNER_CENTER));
+            myMenu->stglResize();
+        }
     } else {
-        StGLRootWidget* aRoot = myMenu->getRoot();
         myMenu->stglUpdateSubmenuLayout();
-        StRectI_t aRect  = myMenu->getRectPxAbsolute();
-        const int aRootX = aRoot->getRectPx().width();
-        const int aRootY = aRoot->getRectPx().height();
+        StRectI_t aRect = myMenu->getRectPxAbsolute();
         if(aRect.width()  >= aRootX) {
             myMenu->changeRectPx().moveLeftTo(0);
         } else if(aRect.right() > aRoot->getRectPx().right()) {

sview-17_04.tar.gz/StGLWidgets/StGLImageProgram.cpp -> sview-20_08.tar.gz/StGLWidgets/StGLImageProgram.cpp Changed

@@ -1,6 +1,6 @@
 /**
  * StGLWidgets, small C++ toolkit for writing GUI using OpenGL.
- * Copyright © 2010-2017 Kirill Gavrilov <kirill@sview.ru>
+ * Copyright © 2010-2019 Kirill Gavrilov <kirill@sview.ru>
  *
  * Distributed under the Boost Software License, Version 1.0.
  * See accompanying file license-boost.txt or copy at
@@ -14,26 +14,66 @@
 #include <StFile/StRawFile.h>
 
 namespace {
-    const char F_DEF_2D[] =
+    const char F_DEF_2D_ALPHA[] =
         "#define stSampler sampler2D\n"
-        "#define stTexture(theSampler, theCoords) texture2D(theSampler, theCoords.xy)\n";
-    const char F_DEF_CUBEMAP[] =
+        "#define stTexture(theSampler, theCoords) texture2D(theSampler, theCoords.xy)\n"
+        "#define stAlpha a\n";
+    const char F_DEF_2D_RED[] =
+        "#define stSampler sampler2D\n"
+        "#define stTexture(theSampler, theCoords) texture2D(theSampler, theCoords.xy)\n"
+        "#define stAlpha r\n";
+    const char F_DEF_CUBEMAP_ALPHA[] =
+        "#define stSampler samplerCube\n"
+        "#define stTexture(theSampler, theCoords) textureCube(theSampler, theCoords)\n"
+        "#define stAlpha a\n";
+    const char F_DEF_CUBEMAP_RED[] =
         "#define stSampler samplerCube\n"
-        "#define stTexture(theSampler, theCoords) textureCube(theSampler, theCoords)\n";
+        "#define stTexture(theSampler, theCoords) textureCube(theSampler, theCoords)\n"
+        "#define stAlpha r\n";
 }
 
-void StGLImageProgram::regToRgb(const int       thePartIndex,
+void StGLImageProgram::regToRgb(const StGLContext& theCtx,
+                                const int       thePartIndex,
                                 const StString& theText) {
   registerFragmentShaderPart(FragSection_ToRgb, thePartIndex,
-                             StString(F_DEF_2D)      + theText);
+                             StString(theCtx.arbTexRG ? F_DEF_2D_RED : F_DEF_2D_ALPHA) + theText);
   registerFragmentShaderPart(FragSection_ToRgb, FragToRgb_CUBEMAP + thePartIndex,
-                             StString(F_DEF_CUBEMAP) + theText);
+                             StString(theCtx.arbTexRG ? F_DEF_CUBEMAP_RED : F_DEF_CUBEMAP_ALPHA) + theText);
 }
 
 StGLImageProgram::StGLImageProgram()
-: myColorScale(1.0f, 1.0f, 1.0f) {
+: myColorScale(1.0f, 1.0f, 1.0f),
+  myIsRegistered(false) {
     myTitle = "StGLImageProgram";
 
+    params.gamma = new StFloat32Param(1.0f);
+    params.gamma->setMinMaxValues(0.05f, 99.0f);
+    params.gamma->setEffectiveMinMaxValues(0.05f, 2.0f);
+    params.gamma->setDefValue(1.0f);
+    params.gamma->setStep(0.05f);
+    params.gamma->setTolerance(0.0001f);
+
+    params.brightness = new StFloat32Param(1.0f);
+    params.brightness->setMinMaxValues(0.0f, 99.0f);
+    params.brightness->setDefValue(1.0f);
+    params.brightness->setEffectiveMinMaxValues(0.0f, 5.0f);
+    params.brightness->setStep(0.05f);
+    params.brightness->setTolerance(0.0001f);
+
+    params.saturation = new StFloat32Param(1.0f);
+    params.saturation->setMinMaxValues(-10.0f, 99.0f);
+    params.saturation->setEffectiveMinMaxValues(0.0f, 2.0f);
+    params.saturation->setDefValue(1.0f);
+    params.saturation->setStep(0.05f);
+    params.saturation->setTolerance(0.0001f);
+}
+
+void StGLImageProgram::registerFragments(const StGLContext& theCtx) {
+    if(myIsRegistered) {
+        return;
+    }
+    myIsRegistered = true;
+
     const char F_SHADER_GET_COLOR_BLEND[] =
        "uniform sampler2D uTexture;\n"
        "uniform vec4 uTexData;\n"
@@ -79,26 +119,71 @@
         "    color = pow(color, uGamma);\n"
         "}\n\n");
 
+    // equiangular cubemap texture coordinates correction
+    registerFragmentShaderPart(FragSection_GetTexCoords, FragTexEAC_Off,
+                               "vec3 getTexCoords(in vec3 theCoords, in vec4 theClamp) { return theCoords; }\n\n");
+    registerFragmentShaderPart(FragSection_GetTexCoords, FragTexEAC_On,
+                               "#define ST_PI 3.1415926535897932384626433832795\n"
+                               "vec3 getTexCoords(in vec3 theCoords, in vec4 theClamp) {\n"
+                               "    vec3 aCoords = theCoords;\n"
+                               "    aCoords.x = 4.0 / ST_PI * atan(theCoords.x);\n"
+                               "    aCoords.y = 4.0 / ST_PI * atan(theCoords.y);\n"
+                               "    aCoords.z = 4.0 / ST_PI * atan(theCoords.z);\n"
+                               "\n"
+                               "    float aClampX = abs(theClamp.x) < 1.0 ? theClamp.w * 2.0 : 0.0;\n"
+                               "    if(theClamp.x >= 0.0) {\n"
+                               "        aCoords.x = -1.0 + theClamp.x * (aCoords.x + 1.0);\n"
+                               "        aCoords.x = clamp(aCoords.x, -1.0 + aClampX, 1.0 * theClamp.x);\n"
+                               "    } else {\n"
+                               "        aCoords.x =  1.0 + theClamp.x * (1.0 - aCoords.x);\n"
+                               "        aCoords.x = clamp(aCoords.x, 1.0 * theClamp.x, 1.0 - aClampX);\n"
+                               "    }\n"
+                               "\n"
+                               "    float aClampY = abs(theClamp.y) < 1.0 ? theClamp.w * 2.0 : 0.0;\n"
+                               "    if(theClamp.y >= 0.0) {\n"
+                               "        aCoords.y = -1.0 + theClamp.y * (aCoords.y + 1.0);\n"
+                               "        aCoords.y = clamp(aCoords.y, -1.0 + aClampY, 1.0 * theClamp.y);\n"
+                               "    } else {\n"
+                               "        aCoords.y =  1.0 + theClamp.y * (1.0 - aCoords.y);\n"
+                               "        aCoords.y = clamp(aCoords.y, 1.0 * theClamp.y, 1.0 - aClampY);\n"
+                               "    }\n"
+                               "\n"
+                               "    float aClampZ = abs(theClamp.z) < 1.0 ? theClamp.w * 2.0 : 0.0;\n"
+                               "    if(theClamp.z >= 0.0) {\n"
+                               "        aCoords.z = -1.0 + theClamp.z * (aCoords.z + 1.0);\n"
+                               "        aCoords.z = clamp(aCoords.z, -1.0 + aClampZ, 1.0 * theClamp.z);\n"
+                               "    } else {\n"
+                               "        aCoords.z =  1.0 + theClamp.z * (1.0 - aCoords.z);\n"
+                               "        aCoords.z = clamp(aCoords.z, 1.0 * theClamp.z, 1.0 - aClampZ);\n"
+                               "    }\n"
+                               "    return aCoords;\n"
+                               "}\n\n");
+
     registerFragmentShaderPart(FragSection_ToRgb, FragToRgb_FromRgb,
-        "void convertToRGB(inout vec4 color, in vec3 texCoord) {}\n\n");
-
-    registerFragmentShaderPart(FragSection_ToRgb, FragToRgb_FromRgba,
-        "void convertToRGB(inout vec4 color, in vec3 texCoord) {\n"
-        "    vec4 backColor;\n"
-        "    bool evenX = int(mod(floor(gl_FragCoord.x + 1.5), 16.0)) >= 8;\n" // just simple 8 pixels check-board
-        "    bool evenY = int(mod(floor(gl_FragCoord.y + 1.5), 16.0)) >= 8;\n"
-        "    if((evenX && evenY) || (!evenX && !evenY)) {\n"
-        "        backColor = vec4(0.4, 0.4, 0.4, 1.0);\n"
-        "    } else {\n"
-        "        backColor = vec4(0.6, 0.6, 0.6, 1.0);\n"
-        "    }\n"
-        "    color = mix(backColor, color, color.a);\n"
+        "void convertToRGB(inout vec4 color, in vec3 texCoord, in vec3 texCoordA) {}\n\n");
+
+    const char F_ALPHA_BACKGROUND[] =
+        "void drawAlphaBackground(inout vec4 theColor) {\n"
+        "    bool anEvenX = int(mod(floor(gl_FragCoord.x + 1.5), 16.0)) >= 8;\n" // just simple 8 pixels check-board
+        "    bool anEvenY = int(mod(floor(gl_FragCoord.y + 1.5), 16.0)) >= 8;\n"
+        "    vec4 aBackColor = vec4(0.6, 0.6, 0.6, 1.0);\n"
+        "    if((anEvenX && anEvenY) || (!anEvenX && !anEvenY)) {\n"
+        "        aBackColor = vec4(0.4, 0.4, 0.4, 1.0);\n"
+        "    };\n"
+        "    theColor = mix(aBackColor, theColor, theColor.a);\n"
+        "}\n\n";
+
+    registerFragmentShaderPart(FragSection_ToRgb, FragToRgb_FromRgba, StString()
+      + F_ALPHA_BACKGROUND
+      + "void convertToRGB(inout vec4 color, in vec3 texCoord, in vec3 texCoordA) {\n"
+        "    drawAlphaBackground(color);\n"
         "}\n\n");
-    registerFragmentShaderPart(FragSection_ToRgb, FragToRgb_FromGray,
-        "void convertToRGB(inout vec4 color, in vec3 texCoord) {\n"
-        "    color.r = color.a;\n" // gray scale stored in alpha
-        "    color.g = color.a;\n"
-        "    color.b = color.a;\n"
+
+    regToRgb(theCtx, FragToRgb_FromGray,
+        "void convertToRGB(inout vec4 color, in vec3 texCoord, in vec3 texCoordA) {\n"
+        "    color.r = color.stAlpha;\n" // gray scale stored in alpha
+        "    color.g = color.stAlpha;\n"
+        "    color.b = color.stAlpha;\n"
         "}\n\n");
 
     // color conversion shaders
@@ -110,7 +195,7 @@
        "                                        0.0,        0.0,        0.0, 1.0);"
        "const vec4 THE_GAMMA_XYZ =       vec4(2.6, 2.6, 2.6, 1.0);"
        "const vec4 THE_GAMMA_RGB = 1.0 / vec4(2.2, 2.2, 2.2, 1.0);"
-       "void convertToRGB(inout vec4 theColor, in vec3 texCoord) {\n"
+       "void convertToRGB(inout vec4 theColor, in vec3 texCoord, in vec3 texCoordA) {\n"
        "    vec4 aColor = pow(theColor, THE_GAMMA_XYZ);"
        "    aColor = THE_XYZ2RGB_MAT * aColor;\n"
        "    aColor = pow(aColor, THE_GAMMA_RGB);"
@@ -120,8 +205,23 @@
     const char F_SHADER_YUV2RGB_MPEG[] =
        "uniform stSampler uTextureU;\n"
        "uniform stSampler uTextureV;\n"
-       "void convertToRGB(inout vec4 color, in vec3 texCoordUV) {\n"
-       "    vec3 colorYUV = vec3(color.a, stTexture(uTextureU, texCoordUV).a, stTexture(uTextureV, texCoordUV).a);\n"
+       "void convertToRGB(inout vec4 color, in vec3 texCoordUV, in vec3 texCoordA) {\n"
+       "    vec3 colorYUV = vec3(color.stAlpha, stTexture(uTextureU, texCoordUV).stAlpha, stTexture(uTextureV, texCoordUV).stAlpha);\n"
+       "    colorYUV   *= TheRangeBits;\n"
+       "    colorYUV.x  = 1.1643 * (colorYUV.x - 0.0625);\n"
+       "    colorYUV.y -= 0.5;\n"
+       "    colorYUV.z -= 0.5;\n"
+       "    color.r = colorYUV.x +  1.5958 * colorYUV.z;\n"
+       "    color.g = colorYUV.x - 0.39173 * colorYUV.y - 0.81290 * colorYUV.z;\n"
+       "    color.b = colorYUV.x +   2.017 * colorYUV.y;\n"
+       "}\n\n";
+
+    const char F_SHADER_YUVA2RGB_MPEG[] =
+       "uniform stSampler uTextureU;\n"
+       "uniform stSampler uTextureV;\n"
+       "uniform stSampler uTextureA;\n"
+       "void convertToRGB(inout vec4 color, in vec3 texCoordUV, in vec3 texCoordA) {\n"
+       "    vec3 colorYUV = vec3(color.stAlpha, stTexture(uTextureU, texCoordUV).stAlpha, stTexture(uTextureV, texCoordUV).stAlpha);\n"
        "    colorYUV   *= TheRangeBits;\n"
        "    colorYUV.x  = 1.1643 * (colorYUV.x - 0.0625);\n"
        "    colorYUV.y -= 0.5;\n"
@@ -129,13 +229,15 @@
        "    color.r = colorYUV.x +  1.5958 * colorYUV.z;\n"
        "    color.g = colorYUV.x - 0.39173 * colorYUV.y - 0.81290 * colorYUV.z;\n"
        "    color.b = colorYUV.x +   2.017 * colorYUV.y;\n"
+       "    color.a = stTexture(uTextureA, texCoordA).stAlpha;\n" // TODO how to handle TheRangeBits?
+       "    drawAlphaBackground(color);\n"
        "}\n\n";
 
     const char F_SHADER_YUV2RGB_FULL[] =
        "uniform stSampler uTextureU;\n"
        "uniform stSampler uTextureV;\n"
-       "void convertToRGB(inout vec4 color, in vec3 texCoordUV) {\n"
-       "    vec3 colorYUV = vec3(color.a, stTexture(uTextureU, texCoordUV).a, stTexture(uTextureV, texCoordUV).a);\n"
+       "void convertToRGB(inout vec4 color, in vec3 texCoordUV, in vec3 texCoordA) {\n"
+       "    vec3 colorYUV = vec3(color.stAlpha, stTexture(uTextureU, texCoordUV).stAlpha, stTexture(uTextureV, texCoordUV).stAlpha);\n"
        "    colorYUV   *= TheRangeBits;\n"
        "    colorYUV.x  = colorYUV.x;\n"
        "    colorYUV.y -= 0.5;\n"
@@ -145,10 +247,27 @@
        "    color.b = colorYUV.x + 1.772 * colorYUV.y;\n"
        "}\n\n";
 
+    const char F_SHADER_YUVA2RGB_FULL[] =
+       "uniform stSampler uTextureU;\n"
+       "uniform stSampler uTextureV;\n"
+       "uniform stSampler uTextureA;\n"
+       "void convertToRGB(inout vec4 color, in vec3 texCoordUV, in vec3 texCoordA) {\n"
+       "    vec3 colorYUV = vec3(color.stAlpha, stTexture(uTextureU, texCoordUV).stAlpha, stTexture(uTextureV, texCoordUV).stAlpha);\n"
+       "    colorYUV   *= TheRangeBits;\n"
+       "    colorYUV.x  = colorYUV.x;\n"
+       "    colorYUV.y -= 0.5;\n"
+       "    colorYUV.z -= 0.5;\n"
+       "    color.r = colorYUV.x + 1.402 * colorYUV.z;\n"
+       "    color.g = colorYUV.x - 0.344 * colorYUV.y - 0.714 * colorYUV.z;\n"
+       "    color.b = colorYUV.x + 1.772 * colorYUV.y;\n"
+       "    color.a = stTexture(uTextureA, texCoordA).stAlpha;\n" // TODO how to handle TheRangeBits?
+       "    drawAlphaBackground(color);\n"
+       "}\n\n";
+
     const char F_SHADER_YUVNV2RGB_MPEG[] =
        "uniform stSampler uTextureU;\n"
-       "void convertToRGB(inout vec4 color, in vec3 texCoordUV) {\n"
-       "    vec3 colorYUV = vec3(color.a, stTexture(uTextureU, texCoordUV).r, stTexture(uTextureU, texCoordUV).a);\n"
+       "void convertToRGB(inout vec4 color, in vec3 texCoordUV, in vec3 texCoordA) {\n"
+       "    vec3 colorYUV = vec3(color.stAlpha, stTexture(uTextureU, texCoordUV).r, stTexture(uTextureU, texCoordUV).a);\n"
        "    colorYUV   *= TheRangeBits;\n"
        "    colorYUV.x  = 1.1643 * (colorYUV.x - 0.0625);\n"
        "    colorYUV.y -= 0.5;\n"
@@ -160,8 +279,8 @@
 
     const char F_SHADER_YUVNV2RGB_FULL[] =
        "uniform stSampler uTextureU;\n"
-       "void convertToRGB(inout vec4 color, in vec3 texCoordUV) {\n"
-       "    vec3 colorYUV = vec3(color.a, stTexture(uTextureU, texCoordUV).r, stTexture(uTextureU, texCoordUV).a);\n"
+       "void convertToRGB(inout vec4 color, in vec3 texCoordUV, in vec3 texCoordA) {\n"
+       "    vec3 colorYUV = vec3(color.stAlpha, stTexture(uTextureU, texCoordUV).r, stTexture(uTextureU, texCoordUV).a);\n"
        "    colorYUV   *= TheRangeBits;\n"
        "    colorYUV.x  = colorYUV.x;\n"
        "    colorYUV.y -= 0.5;\n"
@@ -171,75 +290,91 @@
        "    color.b = colorYUV.x + 1.772 * colorYUV.y;\n"
        "}\n\n";
 
-    regToRgb(FragToRgb_FromYuvFull, StString()
+    regToRgb(theCtx, FragToRgb_FromYuvFull, StString()
         + "const float TheRangeBits = 1.0;\n"
         + F_SHADER_YUV2RGB_FULL);
 
-    regToRgb(FragToRgb_FromYuvMpeg, StString()
+    regToRgb(theCtx, FragToRgb_FromYuvaFull, StString()
+        + "const float TheRangeBits = 1.0;\n"
+        + F_ALPHA_BACKGROUND
+        + F_SHADER_YUVA2RGB_FULL);
+
+    regToRgb(theCtx, FragToRgb_FromYuvMpeg, StString()
         + "const float TheRangeBits = 1.0;\n"
         + F_SHADER_YUV2RGB_MPEG);
 
-    regToRgb(FragToRgb_FromYuv9Full, StString()
+    regToRgb(theCtx, FragToRgb_FromYuvaMpeg, StString()
+        + "const float TheRangeBits = 1.0;\n"
+        + F_ALPHA_BACKGROUND
+        + F_SHADER_YUVA2RGB_MPEG);
+
+    regToRgb(theCtx, FragToRgb_FromYuv9Full, StString()
         + "const float TheRangeBits = 65535.0 / 511.0;\n"
         + F_SHADER_YUV2RGB_FULL);
 
-    regToRgb(FragToRgb_FromYuv9Mpeg, StString()
+    regToRgb(theCtx, FragToRgb_FromYuva9Full, StString()
+        + "const float TheRangeBits = 65535.0 / 511.0;\n"
+        + F_ALPHA_BACKGROUND
+        + F_SHADER_YUVA2RGB_FULL);
+
+    regToRgb(theCtx, FragToRgb_FromYuv9Mpeg, StString()
         + "const float TheRangeBits = 65535.0 / 511.0;\n"
         + F_SHADER_YUV2RGB_MPEG);
 
-    regToRgb(FragToRgb_FromYuv10Full, StString()
+    regToRgb(theCtx, FragToRgb_FromYuva9Mpeg, StString()
+        + "const float TheRangeBits = 65535.0 / 511.0;\n"
+        + F_ALPHA_BACKGROUND
+        + F_SHADER_YUVA2RGB_MPEG);
+
+    regToRgb(theCtx, FragToRgb_FromYuv10Full, StString()
         + "const float TheRangeBits = 65535.0 / 1023.0;\n"
         + F_SHADER_YUV2RGB_FULL);
 
-    regToRgb(FragToRgb_FromYuv10Mpeg, StString()
+    regToRgb(theCtx, FragToRgb_FromYuva10Full, StString()
+        + "const float TheRangeBits = 65535.0 / 1023.0;\n"
+        + F_ALPHA_BACKGROUND
+        + F_SHADER_YUVA2RGB_FULL);
+
+    regToRgb(theCtx, FragToRgb_FromYuv10Mpeg, StString()
         + "const float TheRangeBits = 65535.0 / 1023.0;\n"
         + F_SHADER_YUV2RGB_MPEG);
 
-    regToRgb(FragToRgb_FromYuvNvFull, StString()
+    regToRgb(theCtx, FragToRgb_FromYuva10Mpeg, StString()
+        + "const float TheRangeBits = 65535.0 / 1023.0;\n"
+        + F_ALPHA_BACKGROUND
+        + F_SHADER_YUVA2RGB_MPEG);
+
+    regToRgb(theCtx, FragToRgb_FromYuvNvFull, StString()
         + "const float TheRangeBits = 1.0;\n"
         + F_SHADER_YUVNV2RGB_FULL);
 
-    regToRgb(FragToRgb_FromYuvNvMpeg, StString()
+    regToRgb(theCtx, FragToRgb_FromYuvNvMpeg, StString()
         + "const float TheRangeBits = 1.0;\n"
         + F_SHADER_YUVNV2RGB_MPEG);
 
-    params.gamma = new StFloat32Param(1.0f);
-    params.gamma->setMinMaxValues(0.05f, 99.0f);
-    params.gamma->setEffectiveMinMaxValues(0.05f, 2.0f);
-    params.gamma->setDefValue(1.0f);
-    params.gamma->setStep(0.05f);
-    params.gamma->setTolerance(0.0001f);
-
-    params.brightness = new StFloat32Param(1.0f);
-    params.brightness->setMinMaxValues(0.0f, 99.0f);
-    params.brightness->setDefValue(1.0f);
-    params.brightness->setEffectiveMinMaxValues(0.0f, 5.0f);
-    params.brightness->setStep(0.05f);
-    params.brightness->setTolerance(0.0001f);
-
-    params.saturation = new StFloat32Param(1.0f);
-    params.saturation->setMinMaxValues(-10.0f, 99.0f);
-    params.saturation->setEffectiveMinMaxValues(0.0f, 2.0f);
-    params.saturation->setDefValue(1.0f);
-    params.saturation->setStep(0.05f);
-    params.saturation->setTolerance(0.0001f);
-
     // main shader parts
     const char V_SHADER_FLAT[] =
        "uniform mat4 uProjMat;\n"
        "uniform mat4 uModelMat;\n"
        "uniform vec4 uTexData;\n"
        "uniform vec4 uTexUVData;\n"
+       "uniform vec4 uTexAData;\n"
 
        "attribute vec4 vVertex;\n"
        "attribute vec2 vTexCoord;\n"
 
        "varying vec3 fTexCoord;\n"
        "varying vec3 fTexUVCoord;\n"
+       "varying vec3 fTexACoord;\n"
+       "varying vec3 fTexClamp;\n"
+       "varying float fTexClampW;\n"
 
        "void main(void) {\n"
        "    fTexCoord   = vec3(uTexData.xy   + vTexCoord * uTexData.zw,   0.0);\n"
        "    fTexUVCoord = vec3(uTexUVData.xy + vTexCoord * uTexUVData.zw, 0.0);\n"
+       "    fTexACoord  = vec3(uTexAData.xy  + vTexCoord * uTexAData.zw,  0.0);\n"
+       "    fTexClamp   = vec3(0.0, 0.0, 0.0);\n"
+       "    fTexClampW  = 0.0;\n"
        "    gl_Position = uProjMat * uModelMat * vVertex;\n"
        "}\n";
 
@@ -248,38 +383,55 @@
        "uniform mat4 uModelMat;\n"
        "uniform vec4 uTexData;\n"
        "uniform vec4 uTexUVData;\n"
+       "uniform vec4 uTexAData;\n"
        "uniform float uTexCubeFlipZ;\n"
 
        "attribute vec4 vVertex;\n"
-       "attribute vec2 vTexCoord;\n"
+       "attribute vec3 vNormal;\n"
+       "attribute vec4 vColor;\n"
 
        "varying vec3 fTexCoord;\n"
        "varying vec3 fTexUVCoord;\n"
+       "varying vec3 fTexACoord;\n"
+       "varying vec3 fTexClamp;\n"
+       "varying float fTexClampW;\n"
 
        "void main(void) {\n"
-       "    gl_Position = vec4(vVertex.x, vVertex.y, 0.0, 1.0);\n"
-       "    vec3 aTCoord = (uProjMat * gl_Position).xyz;"
-       "    aTCoord.z  *= uTexCubeFlipZ;"
-       "    fTexCoord   = aTCoord;"
-       "    fTexUVCoord = aTCoord;"
+       "    vec4 aPos = uProjMat * uModelMat * vec4(vVertex.xyz, 1.0);\n"
+       "    gl_Position = aPos.xyww;\n"
+       "    vec3 aTCoord = vNormal;\n" // fake normal attribute
+       "    aTCoord.z  *= uTexCubeFlipZ;\n"
+       "    fTexCoord   = aTCoord;\n"
+       "    fTexUVCoord = aTCoord;\n"
+       "    fTexACoord  = aTCoord;\n"
+       "    fTexClamp   = vColor.xyz;\n" // fake color attribute
+       "    fTexClampW  = vColor.w;\n"
        "}\n";
 
     const char F_SHADER_FLAT[] =
        "varying vec3 fTexCoord;\n"
        "varying vec3 fTexUVCoord;\n"
+       "varying vec3 fTexACoord;\n"
+       "varying vec3 fTexClamp;\n"
+       "varying float fTexClampW;\n"
         // we split these functions for two reasons:
         // - to change function code (like color conversion);
         // - to optimize rendering on old hardware not supported conditions (GeForce FX for example).
+       "vec3 getTexCoords(in vec3 theCoords, in vec4 theClamp);\n"
        "vec4 getColor(in vec3 texCoord);\n"
-       "void convertToRGB(inout vec4 theColor, in vec3 theTexUVCoord);\n"
+       "void convertToRGB(inout vec4 theColor, in vec3 theTexUVCoord, in vec3 texCoordA);\n"
        "void applyCorrection(inout vec4 theColor);\n"
        "void applyGamma(inout vec4 theColor);\n"
 
        "void main(void) {\n"
+       "    vec4 aTexClamp   = vec4(fTexClamp, fTexClampW);\n"
+       "    vec3 aTexCoord   = getTexCoords(fTexCoord,   aTexClamp);\n"
+       "    vec3 aTexCoordUV = getTexCoords(fTexUVCoord, aTexClamp);\n"
+       "    vec3 aTexCoordA  = getTexCoords(fTexACoord,  aTexClamp);\n"
             // extract color from main texture
-       "    vec4 aColor = getColor(fTexCoord);\n"
+       "    vec4 aColor = getColor(aTexCoord);\n"
             // convert from alien color model (like YUV) to RGB
-       "    convertToRGB(aColor, fTexUVCoord);\n"
+       "    convertToRGB(aColor, aTexCoordUV, aTexCoordA);\n"
             // color processing (saturation, brightness, etc)
        "    applyCorrection(aColor);\n"
             // gamma correction
@@ -312,6 +464,11 @@
     theCtx.core20fwd->glUniform4fv(uniTexUVDataLoc, 1, theTexDataVec4);
 }
 
+void StGLImageProgram::setTextureADataSize(StGLContext&    theCtx,
+                                           const StGLVec4& theTexDataVec4) {
+  theCtx.core20fwd->glUniform4fv(uniTexADataLoc, 1, theTexDataVec4);
+}
+
 void StGLImageProgram::setCubeTextureFlipZ(StGLContext& theCtx,
                                            bool theToFlip) {
     theCtx.core20fwd->glUniform1f(uniTexCubeFlipZLoc, theToFlip ? 1.0f : -1.0f);
@@ -341,18 +498,20 @@
         case StImage::ImgColor_RGBA: return StGLImageProgram::FragToRgb_FromRgba;
         case StImage::ImgColor_GRAY: return StGLImageProgram::FragToRgb_FromGray;
         case StImage::ImgColor_XYZ:  return StGLImageProgram::FragToRgb_FromXyz;
-        case StImage::ImgColor_YUV: {
+        case StImage::ImgColor_YUV:
+        case StImage::ImgColor_YUVA: {
+            const bool hasAlpha = theColorModel == StImage::ImgColor_YUVA;
             switch(theColorScale) {
-                case StImage::ImgScale_Mpeg9:  return StGLImageProgram::FragToRgb_FromYuv9Mpeg;
-                case StImage::ImgScale_Mpeg10: return StGLImageProgram::FragToRgb_FromYuv10Mpeg;
-                case StImage::ImgScale_Jpeg9:  return StGLImageProgram::FragToRgb_FromYuv9Full;
-                case StImage::ImgScale_Jpeg10: return StGLImageProgram::FragToRgb_FromYuv10Full;
-                case StImage::ImgScale_Mpeg:   return StGLImageProgram::FragToRgb_FromYuvMpeg;
-                case StImage::ImgScale_Full:   return StGLImageProgram::FragToRgb_FromYuvFull;
+                case StImage::ImgScale_Mpeg9:  return hasAlpha ? StGLImageProgram::FragToRgb_FromYuva9Mpeg  : StGLImageProgram::FragToRgb_FromYuv9Mpeg;
+                case StImage::ImgScale_Mpeg10: return hasAlpha ? StGLImageProgram::FragToRgb_FromYuva10Mpeg : StGLImageProgram::FragToRgb_FromYuv10Mpeg;
+                case StImage::ImgScale_Jpeg9:  return hasAlpha ? StGLImageProgram::FragToRgb_FromYuva9Full  : StGLImageProgram::FragToRgb_FromYuv9Full;
+                case StImage::ImgScale_Jpeg10: return hasAlpha ? StGLImageProgram::FragToRgb_FromYuva10Full : StGLImageProgram::FragToRgb_FromYuv10Full;
+                case StImage::ImgScale_Mpeg:   return hasAlpha ? StGLImageProgram::FragToRgb_FromYuvaMpeg   : StGLImageProgram::FragToRgb_FromYuvMpeg;
+                case StImage::ImgScale_Full:   return hasAlpha ? StGLImageProgram::FragToRgb_FromYuvaFull   : StGLImageProgram::FragToRgb_FromYuvFull;
                 case StImage::ImgScale_NvMpeg: return StGLImageProgram::FragToRgb_FromYuvNvMpeg;
                 case StImage::ImgScale_NvFull: return StGLImageProgram::FragToRgb_FromYuvNvFull;
             }
-            return StGLImageProgram::FragToRgb_FromYuvFull;
+            return hasAlpha ? StGLImageProgram::FragToRgb_FromYuvaFull : StGLImageProgram::FragToRgb_FromYuvFull;
         }
         default: {
             ST_DEBUG_LOG("No GLSL shader for this color model = " + theColorModel);
@@ -365,7 +524,9 @@
 bool StGLImageProgram::init(StGLContext&                 theCtx,
                             const StImage::ImgColorModel theColorModel,
                             const StImage::ImgColorScale theColorScale,
-                            const FragGetColor           theFilter) {
+                            const FragGetColor           theFilter,
+                            const FragTexEAC theTexCoord) {
+    registerFragments(theCtx);
 
     // re-configure shader parts when required
     bool isChanged = myActiveProgram.isNull();
@@ -383,6 +544,7 @@
     }
 
     isChanged = setFragmentShaderPart(theCtx, FragSection_ToRgb,    aToRgb) || isChanged;
+    isChanged = setFragmentShaderPart(theCtx, FragSection_GetTexCoords, theTexCoord) || isChanged;
     isChanged = setFragmentShaderPart(theCtx, FragSection_GetColor, theFilter) || isChanged;
     isChanged = setVertexShaderPart  (theCtx, 0, theFilter == FragGetColor_Cubemap ? VertMain_Cubemap : VertMain_Normal) || isChanged;
     if(isChanged) {
@@ -394,6 +556,7 @@
         myActiveProgram->uniModelMatLoc = myActiveProgram->getUniformLocation(theCtx, "uModelMat");
         uniTexMainDataLoc     = myActiveProgram->getUniformLocation(theCtx, "uTexData");
         uniTexUVDataLoc       = myActiveProgram->getUniformLocation(theCtx, "uTexUVData");
+        uniTexADataLoc        = myActiveProgram->getUniformLocation(theCtx, "uTexAData");
         uniTexSizePxLoc       = myActiveProgram->getUniformLocation(theCtx, "uTexSizePx");
         uniTexelSizePxLoc     = myActiveProgram->getUniformLocation(theCtx, "uTexelSize");
         uniTexCubeFlipZLoc    = myActiveProgram->getUniformLocation(theCtx, "uTexCubeFlipZ");
@@ -401,14 +564,18 @@
         uniGammaLoc           = myActiveProgram->getUniformLocation(theCtx, "uGamma");
         myActiveProgram->atrVVertexLoc  = myActiveProgram->getAttribLocation(theCtx, "vVertex");
         myActiveProgram->atrVTCoordLoc  = myActiveProgram->getAttribLocation(theCtx, "vTexCoord");
+        myActiveProgram->atrVNormalLoc  = myActiveProgram->getAttribLocation(theCtx, "vNormal");
+        myActiveProgram->atrVColorsLoc  = myActiveProgram->getAttribLocation(theCtx, "vColor");
 
         StGLVarLocation uniTextureLoc  = myActiveProgram->getUniformLocation(theCtx, "uTexture");
         StGLVarLocation uniTextureULoc = myActiveProgram->getUniformLocation(theCtx, "uTextureU");
         StGLVarLocation uniTextureVLoc = myActiveProgram->getUniformLocation(theCtx, "uTextureV");
+        StGLVarLocation uniTextureALoc = myActiveProgram->getUniformLocation(theCtx, "uTextureA");
         myActiveProgram->use(theCtx);
         theCtx.core20fwd->glUniform1i(uniTextureLoc,  StGLProgram::TEXTURE_SAMPLE_0);
         theCtx.core20fwd->glUniform1i(uniTextureULoc, StGLProgram::TEXTURE_SAMPLE_1);
         theCtx.core20fwd->glUniform1i(uniTextureVLoc, StGLProgram::TEXTURE_SAMPLE_2);
+        theCtx.core20fwd->glUniform1i(uniTextureALoc, StGLProgram::TEXTURE_SAMPLE_3);
         myActiveProgram->unuse(theCtx);
 
         /*if (!uniModelMatLoc.isValid()

sview-17_04.tar.gz/StGLWidgets/StGLImageRegion.cpp -> sview-20_08.tar.gz/StGLWidgets/StGLImageRegion.cpp Changed

@@ -1,6 +1,6 @@
 /**
  * StGLWidgets, small C++ toolkit for writing GUI using OpenGL.
- * Copyright © 2010-2016 Kirill Gavrilov <kirill@sview.ru>
+ * Copyright © 2010-2020 Kirill Gavrilov <kirill@sview.ru>
  *
  * Distributed under the Boost Software License, Version 1.0.
  * See accompanying file license-boost.txt or copy at
@@ -9,6 +9,7 @@
 
 #include <StGLWidgets/StGLImageRegion.h>
 #include <StGLWidgets/StGLRootWidget.h>
+#include <StGLWidgets/StGLTextureButton.h>
 #include <StGL/StPlayList.h>
 #include <StGLStereo/StGLQuadTexture.h>
 
@@ -202,20 +203,30 @@
 
     // we use negative scale factor to show sphere inside out!
     static const float THE_SPHERE_RADIUS     = -10.0f;
-    static const float THE_PANORAMA_DEF_ZOOM = 0.45f;
+    static const float THE_PANORAMA_DEF_ZOOM = 0.45f; // circa 85 degrees FOV
 
+    static const float THE_THEATER_ANGLE = float(M_PI * 0.5);
+    static const float THE_THEATER_FROM  = float(M_PI) - THE_THEATER_ANGLE * 0.5f;
 }
 
 StGLImageRegion::StGLImageRegion(StGLWidget* theParent,
                                  const StHandle<StGLTextureQueue>& theTextureQueue,
                                  bool theUsePanningKeys)
 : StGLWidget(theParent, 0, 0, StGLCorner(ST_VCORNER_TOP, ST_HCORNER_LEFT)),
-  myQuad(),
-  myUVSphere(StGLVec3(0.0f, 0.0f, 0.0f), 1.0f, 64),
+  myIconPrev(NULL),
+  myIconNext(NULL),
+  myCube(GL_TRIANGLES),
+  myCubePano(StPanorama_OFF),
+  myUVSphere  (StGLVec3(0.0f, 0.0f, 0.0f), 1.0f, 64, false),
+  myHemisphere(StGLVec3(0.0f, 0.0f, 0.0f), 1.0f, 64, true),
+  myCylinder  (StGLVec3(0.0f, 0.0f, 0.0f), 1.0f, 1.0f, 64),
+  myTheater   (StGLVec3(0.0f, 0.0f, 0.0f), 1.0f, 1.0f, THE_THEATER_FROM, THE_THEATER_FROM + THE_THEATER_ANGLE, 64),
   myTextureQueue(theTextureQueue),
   myClickPntZo(0.0, 0.0),
   myKeyFlags(ST_VF_NONE),
   myDragDelayMs(0.0),
+  myDragDelayTmpMs(0.0),
+  mySampleRatio(1.0f),
   myRotAngle(0.0f),
   myIsClickAborted(false),
 #ifdef ST_EXTRA_CONTROLS
@@ -225,6 +236,11 @@
 #endif
   myIsInitialized(false),
   myHasVideoStream(false) {
+    myIconPrev = new StGLIcon(this,  getRoot()->scale(48), 0, StGLCorner(ST_VCORNER_CENTER, ST_HCORNER_LEFT),  1);
+    myIconPrev->setOpacity(0.0f, false);
+    myIconNext = new StGLIcon(this, -getRoot()->scale(48), 0, StGLCorner(ST_VCORNER_CENTER, ST_HCORNER_RIGHT), 1);
+    myIconNext->setOpacity(0.0f, false);
+
     params.DisplayMode = new StEnumParam(MODE_STEREO, stCString("viewStereoMode"), stCString("Stereo Output"));
     params.DisplayMode->defineOption(MODE_STEREO,     stCString("Stereo"));
     params.DisplayMode->defineOption(MODE_ONLY_LEFT,  stCString("Left View"));
@@ -243,9 +259,10 @@
 
     params.ToHealAnamorphicRatio = new StBoolParamNamed(false, stCString("toHealAnamorphic"), stCString("Heal Anamorphic Ratio"));
     params.TextureFilter = new StEnumParam(StGLImageProgram::FILTER_LINEAR, stCString("viewTexFilter"), stCString("Texture Filter"));
-    params.TextureFilter->defineOption(StGLImageProgram::FILTER_NEAREST, stCString("Nearest"));
-    params.TextureFilter->defineOption(StGLImageProgram::FILTER_LINEAR,  stCString("Linear"));
-    params.TextureFilter->defineOption(StGLImageProgram::FILTER_BLEND,   stCString("Blend"));
+    params.TextureFilter->defineOption(StGLImageProgram::FILTER_NEAREST,   stCString("Nearest"));
+    params.TextureFilter->defineOption(StGLImageProgram::FILTER_LINEAR,    stCString("Linear"));
+    params.TextureFilter->defineOption(StGLImageProgram::FILTER_TRILINEAR, stCString("Trilinear"));
+    params.TextureFilter->defineOption(StGLImageProgram::FILTER_BLEND,     stCString("Blend"));
 
     params.Gamma         = myProgram.params.gamma;
     params.Brightness    = myProgram.params.brightness;
@@ -393,7 +410,11 @@
     StGLContext& aCtx = getContext();
     myTextureQueue->getQTexture().release(aCtx);
     myQuad.release(aCtx);
+    myCube.release(aCtx);
     myUVSphere.release(aCtx);
+    myHemisphere.release(aCtx);
+    myCylinder.release(aCtx);
+    myTheater.release(aCtx);
     myProgram.release(aCtx);
 
     // simplify debugging - nullify pointer to this widget
@@ -420,7 +441,10 @@
         StHandle<StStereoParams> aFileParams = myTextureQueue->getQTexture().getFront(StGLQuadTexture::LEFT_TEXTURE).getSource();
         if(params.stereoFile != aFileParams) {
             params.stereoFile = aFileParams;
+            myFadeTimer.stop();
             onParamsChanged();
+        } else if(!myHasVideoStream) {
+            myFadeTimer.stop();
         }
     }
 }
@@ -438,17 +462,182 @@
         aCtx.pushError(StString("Fail to init StGLQuad"));
         ST_ERROR_LOG("Fail to init StGLQuad");
         return false;
-    } else if(!myUVSphere.initVBOs(aCtx)) {
+    }/* else if(!myUVSphere.initVBOs(aCtx)) {
         ST_ERROR_LOG("Fail to init StGLUVSphere");
+    }*/
+
+    // a unit cube for cubemap rendering
+    if(!stglInitCube()) {
+        return false;
     }
 
     // setup texture filter
-    myTextureQueue->getQTexture().setMinMagFilter(aCtx, params.TextureFilter->getValue() == StGLImageProgram::FILTER_NEAREST ? GL_NEAREST : GL_LINEAR);
+    myTextureQueue->getQTexture().setMinMagFilter(aCtx,
+                                                  params.TextureFilter->getValue() == StGLImageProgram::FILTER_NEAREST
+                                                ? GL_NEAREST : GL_LINEAR);
 
     myIsInitialized = true;
     return myIsInitialized && isInit;
 }
 
+/**
+ * Cubemap sides.
+ */
+enum StCubeSide {
+    StCubeSide_PX = 0,
+    StCubeSide_NX,
+    StCubeSide_PY,
+    StCubeSide_NY,
+    StCubeSide_PZ,
+    StCubeSide_NZ,
+};
+typedef StVec4<int> StIVec4;
+
+bool StGLImageRegion::stglInitCube(const StGLVec4& theClamp,
+                                   const StPanorama thePano) {
+    myCubeClamp = theClamp;
+    myCubePano = thePano;
+
+    // a unit cube for cubemap rendering
+    const StGLVec3 THE_VERTS[8] = {
+        StGLVec3(-1.0f,-1.0f, 1.0f),
+        StGLVec3( 1.0f,-1.0f, 1.0f),
+        StGLVec3(-1.0f, 1.0f, 1.0f),
+        StGLVec3( 1.0f, 1.0f, 1.0f),
+        StGLVec3(-1.0f,-1.0f,-1.0f),
+        StGLVec3( 1.0f,-1.0f,-1.0f),
+        StGLVec3(-1.0f, 1.0f,-1.0f),
+        StGLVec3( 1.0f, 1.0f,-1.0f)
+    };
+
+    const StIVec4 THE_SIDES[6] = {
+        StIVec4(3, 7, 5, 1), // px
+        StIVec4(6, 2, 0, 4), // nx
+        StIVec4(2, 3, 7, 6), // py
+        StIVec4(0, 1, 5, 4), // ny
+        StIVec4(0, 1, 3, 2), // pz
+        StIVec4(5, 4, 6, 7), // nz
+    };
+
+    StArrayList<StGLVec3>& aVertArr  = myCube.changeVertices();
+    StArrayList<StGLVec3>& aCoordArr = myCube.changeNormals();
+    StArrayList<StGLVec4>& aClampArr = myCube.changeColors();
+    aVertArr.initArray(6 * 6);
+    aCoordArr.initArray(aVertArr.size());
+    aClampArr.initArray(aVertArr.size());
+    int aVert = 0;
+    for(int aSideIter = 0; aSideIter < 6; ++aSideIter, aVert += 6) {
+        StIVec4 aSide = THE_SIDES[aSideIter];
+        aVertArr[aVert + 0] = THE_VERTS[aSide[0]];
+        aVertArr[aVert + 1] = THE_VERTS[aSide[1]];
+        aVertArr[aVert + 2] = THE_VERTS[aSide[2]];
+
+        aVertArr[aVert + 3] = THE_VERTS[aSide[0]];
+        aVertArr[aVert + 4] = THE_VERTS[aSide[2]];
+        aVertArr[aVert + 5] = THE_VERTS[aSide[3]];
+
+        // rotate EAC cube sides
+        if(thePano == StPanorama_Cubemap3_2ytb) {
+            if(aSideIter == StCubeSide_NY) {
+                const StIVec4 aCopy = aSide;
+                for(int aSubIter = 0; aSubIter < 4; ++aSubIter) {
+                    aSide[aSubIter] = aCopy[aSubIter > 0 ? aSubIter - 1 : 3];
+                }
+            }
+            if(aSideIter == StCubeSide_NZ || aSideIter == StCubeSide_PY) {
+                const StIVec4 aCopy = aSide;
+                for(int aSubIter = 0; aSubIter < 4; ++aSubIter) {
+                    aSide[aSubIter] = aCopy[aSubIter < 3 ? aSubIter + 1 : 0];
+                }
+            }
+        } else if(thePano == StPanorama_Cubemap2_3ytb) {
+            if(aSideIter == StCubeSide_PX
+            || aSideIter == StCubeSide_NX) {
+                const StIVec4 aCopy = aSide;
+                for(int aSubIter = 0; aSubIter < 4; ++aSubIter) {
+                    aSide[aSubIter] = aCopy[aSubIter < 3 ? aSubIter + 1 : 0];
+                }
+            }
+            if(aSideIter == StCubeSide_PZ) {
+                const StIVec4 aCopy = aSide;
+                for(int aSubIter = 0; aSubIter < 4; ++aSubIter) {
+                    aSide[aSubIter] = aCopy[aSubIter > 0 ? aSubIter - 1 : 3];
+                }
+            }
+        }
+
+        aCoordArr[aVert + 0] = THE_VERTS[aSide[0]];
+        aCoordArr[aVert + 1] = THE_VERTS[aSide[1]];
+        aCoordArr[aVert + 2] = THE_VERTS[aSide[2]];
+
+        aCoordArr[aVert + 3] = THE_VERTS[aSide[0]];
+        aCoordArr[aVert + 4] = THE_VERTS[aSide[2]];
+        aCoordArr[aVert + 5] = THE_VERTS[aSide[3]];
+        for(int aSubIter = 0; aSubIter < 6; ++aSubIter) {
+            StGLVec4& aClamp = aClampArr[aVert + aSubIter];
+            aClamp = StGLVec4(0.0f, 0.0f, 0.0f, theClamp.x());
+            switch(aSideIter) {
+                case StCubeSide_PX: {
+                    aClamp.x() = 1.0f;
+                    aClamp.y() = -theClamp.w();
+                    aClamp.z() = -theClamp.z();
+                    break;
+                }
+                case StCubeSide_NX: {
+                    aClamp.x() = -1.0f;
+                    aClamp.y() = -theClamp.w();
+                    aClamp.z() = theClamp.z();
+                    break;
+                }
+                case StCubeSide_PZ: {
+                    aClamp.x() = -theClamp.z();
+                    aClamp.y() = -theClamp.w();
+                    aClamp.z() = 1.0f;
+                    break;
+                }
+                case StCubeSide_NZ: {
+                    aClamp.x() = theClamp.z();
+                    aClamp.y() = -theClamp.w();
+                    aClamp.z() = -1.0f;
+                    break;
+                }
+                case StCubeSide_PY: {
+                    aClamp.x() = theClamp.z();
+                    aClamp.y() = 1.0f;
+                    aClamp.z() = theClamp.w();
+                    break;
+                }
+                case StCubeSide_NY: {
+                    aClamp.x() = theClamp.z();
+                    aClamp.y() = -1.0f;
+                    aClamp.z() = -theClamp.w();
+                    break;
+                }
+            }
+        }
+    }
+
+    // triangle strip initialization
+    /*aCubeVerts.initArray(8);
+    for(int aVertIter = 0; aVertIter < 8; ++aVertIter) {
+      aCubeVerts[aVertIter] = THE_VERTS[aVertIter];
+    }
+    const GLuint THE_BOX_TRISTRIP[14] = { 0, 1, 2, 3, 7, 1, 5, 4, 7, 6, 2, 4, 0, 1 };
+    StArrayList<GLuint>& aCubeInd = myCube.changeIndices();
+    aCubeInd.initArray(14);
+    for(unsigned int aVertIter = 0; aVertIter < 14; ++aVertIter) {
+        aCubeInd[aVertIter] = THE_BOX_TRISTRIP[aVertIter];
+    }*/
+
+    StGLContext& aCtx = getContext();
+    if(!myCube.initVBOs(aCtx)) {
+        aCtx.pushError(StString("Fail to init Cube Mesh"));
+        ST_ERROR_LOG("Fail to init Cube Mesh");
+        return false;
+    }
+    return true;
+}
+
 StGLVec2 StGLImageRegion::getMouseMoveFlat(const StPointD_t& theCursorZoFrom,
                                            const StPointD_t& theCursorZoTo) const {
     // apply scale factor in case of working area margins
@@ -491,6 +680,9 @@
     float aYaw   = -stToRadians(aParams->getPanYaw() + aMouseMove.x()) + aYawShift;
     float aPitch =  stToRadians(StStereoParams::clipPitch(aParams->getPanPitch() + aMouseMove.y()));
     float aRoll  =  stToRadians(aParams->getZRotate());
+    if(myProjCam.isCustomProjection()) {
+        aPitch = 0.0f; // ignore pitch for HMD
+    }
 
     // apply separation
     const float aSepDeltaX = GLfloat(aParams->getSeparationDx()) * 0.05f;
@@ -516,6 +708,8 @@
 }
 
 void StGLImageRegion::stglDraw(unsigned int theView) {
+    myIconPrev->setOpacity(0.0f, false);
+    myIconNext->setOpacity(0.0f, false);
     StHandle<StStereoParams> aParams = getSource();
     if(!myIsInitialized || !isVisible() || aParams.isNull()
     || !myTextureQueue->getQTexture().getFront(StGLQuadTexture::LEFT_TEXTURE).isValid()
@@ -551,6 +745,8 @@
 void StGLImageRegion::stglDrawView(unsigned int theView) {
     StGLQuadTexture::LeftOrRight aLeftOrRight = StGLQuadTexture::LEFT_TEXTURE;
     StHandle<StStereoParams> aParams = getSource();
+    mySampleRatio = 1.0f;
+    myFrameSize = StVec2<int>(0, 0);
     if(!myIsInitialized || aParams.isNull()) {
         return;
     }
@@ -594,26 +790,24 @@
         }
     }
 
-    // setup scissor box
-    StGLBoxPx aScissorBox;
-    const StRectI_t aFrameRectAbs = getAbsolute(aFrameRectPx);
-    getRoot()->stglScissorRect(aFrameRectAbs, aScissorBox);
-    aCtx.stglSetScissorRect(aScissorBox, true);
-    aCtx.stglResizeViewport(aScissorBox);
+    // set 85 degrees FOV as 1.0x zoom for panorama rendering
+    myProjCam = *getCamera();
     myProjCam.resize(aCameraAspect);
+    myProjCam.setFOVy(85.0f);
 
     aCtx.core20fwd->glDisable(GL_BLEND);
 
     StGLFrameTextures& aTextures = myTextureQueue->getQTexture().getFront(aLeftOrRight);
-    aTextures.bind(aCtx);
 
     StGLVec2 aTextureSize  (GLfloat(aTextures.getPlane(0).getSizeX()),
                             GLfloat(aTextures.getPlane(0).getSizeY()));
     StGLVec2 aTextureUVSize(GLfloat(aTextures.getPlane(1).getSizeX()),
                             GLfloat(aTextures.getPlane(1).getSizeY()));
+    StGLVec2 aTextureASize (GLfloat(aTextures.getPlane(3).getSizeX()),
+                            GLfloat(aTextures.getPlane(3).getSizeY()));
     StGLMatrix aModelMat;
     // data rectangle in the texture
-    StGLVec4 aClampVec, aClampUV;
+    StGLVec4 aClampVec(0.0f, 0.0f, 1.0f, 1.0f), aClampUV(0.0f, 0.0f, 1.0f, 1.0f), aClampA(0.0f, 0.0f, 1.0f, 1.0f);
     if(params.TextureFilter->getValue() == StGLImageProgram::FILTER_NEAREST) {
         myTextureQueue->getQTexture().setMinMagFilter(aCtx, GL_NEAREST);
         //
@@ -626,22 +820,57 @@
         aClampUV.y() = 0.0f;
         aClampUV.z() = aTextures.getPlane(1).getDataSize().x();
         aClampUV.w() = aTextures.getPlane(1).getDataSize().y();
+        // Alpha
+        aClampA.x() = 0.0f;
+        aClampA.y() = 0.0f;
+        aClampA.z() = aTextures.getPlane(3).getDataSize().x();
+        aClampA.w() = aTextures.getPlane(3).getDataSize().y();
     } else {
-        myTextureQueue->getQTexture().setMinMagFilter(aCtx, GL_LINEAR);
-        //
-        aClampVec.x() = 0.5f / aTextureSize.x();
-        aClampVec.y() = 0.5f / aTextureSize.y();
-        aClampVec.z() = aTextures.getPlane(0).getDataSize().x() - 2.0f * aClampVec.x();
-        aClampVec.w() = aTextures.getPlane(0).getDataSize().y() - 2.0f * aClampVec.y();
+        if(params.TextureFilter->getValue() == StGLImageProgram::FILTER_TRILINEAR) {
+            myTextureQueue->getQTexture().setMinMagFilter(aCtx, GL_LINEAR_MIPMAP_LINEAR, GL_LINEAR);
+        } else {
+            myTextureQueue->getQTexture().setMinMagFilter(aCtx, GL_LINEAR);
+        }
+
+        // clamping is undesired for full-range cubemap to allow smooth seamless cube boundaries,
+        // but EAC video normally defines non-square cube sides requiring clamping
+        const bool isCubemapFull = aTextures.getPlane().getTarget() == GL_TEXTURE_CUBE_MAP
+                                && aTextures.getPlane().getPackedPanorama() != StPanorama_Cubemap3_2ytb
+                                && aTextures.getPlane().getPackedPanorama() != StPanorama_Cubemap2_3ytb;
+        if(!isCubemapFull
+         || aTextures.getPlane(0).getDataSize().x() != aTextures.getPlane(0).getDataSize().y()
+         || aTextures.getPlane(0).getDataSize().x() != 1.0f) {
+            aClampVec.x() = 0.5f / aTextureSize.x();
+            aClampVec.y() = 0.5f / aTextureSize.y();
+            aClampVec.z() = aTextures.getPlane(0).getDataSize().x() - 2.0f * aClampVec.x();
+            aClampVec.w() = aTextures.getPlane(0).getDataSize().y() - 2.0f * aClampVec.y();
+        }
         // UV
         if(aTextureUVSize.x() > 0.0f
         && aTextureUVSize.y() > 0.0f) {
-            aClampUV.x() = 0.5f / aTextureUVSize.x();
-            aClampUV.y() = 0.5f / aTextureUVSize.y(),
-            aClampUV.z() = aTextures.getPlane(1).getDataSize().x() - 2.0f * aClampUV.x();
-            aClampUV.w() = aTextures.getPlane(1).getDataSize().y() - 2.0f * aClampUV.y();
+            if(!isCubemapFull
+             || aTextures.getPlane(1).getDataSize().x() != aTextures.getPlane(1).getDataSize().y()
+             || aTextures.getPlane(1).getDataSize().x() != 1.0f) {
+                aClampUV.x() = 0.5f / aTextureUVSize.x();
+                aClampUV.y() = 0.5f / aTextureUVSize.y(),
+                aClampUV.z() = aTextures.getPlane(1).getDataSize().x() - 2.0f * aClampUV.x();
+                aClampUV.w() = aTextures.getPlane(1).getDataSize().y() - 2.0f * aClampUV.y();
+            }
+        }
+        // Alpha
+        if(aTextureASize.x() > 0.0f
+        && aTextureASize.y() > 0.0f) {
+            if(!isCubemapFull
+             || aTextures.getPlane(3).getDataSize().x() != aTextures.getPlane(3).getDataSize().y()
+             || aTextures.getPlane(3).getDataSize().x() != 1.0f) {
+                aClampA.x() = 0.5f / aTextureASize.x();
+                aClampA.y() = 0.5f / aTextureASize.y(),
+                aClampA.z() = aTextures.getPlane(3).getDataSize().x() - 2.0f * aClampA.x();
+                aClampA.w() = aTextures.getPlane(3).getDataSize().y() - 2.0f * aClampA.y();
+            }
         }
     }
+    aTextures.bind(aCtx);
 
     // select (de)anaglyph color filter
     StGLVec3 aColorScale(1.0f, 1.0f, 1.0f);
@@ -680,63 +909,129 @@
     const GLfloat  aScaleBack = aParams->ScaleFactor;
     const StGLVec2 aPanBack   = aParams->PanCenter;
 
-    const float aVrScale = float(myRoot->getVrZoomOut());
-
     StViewSurface aViewMode = aParams->ViewingMode;
     if(aTextures.getPlane(0).getTarget() == GL_TEXTURE_CUBE_MAP) {
-        aViewMode = StViewSurface_Cubemap;
-    } else if(aViewMode == StViewSurface_Cubemap) {
+        if(aViewMode != StViewSurface_Cubemap && aViewMode != StViewSurface_CubemapEAC) {
+            aViewMode = aTextures.getPlane().getPackedPanorama() == StPanorama_Cubemap3_2ytb
+                     || aTextures.getPlane().getPackedPanorama() == StPanorama_Cubemap2_3ytb
+                      ? StViewSurface_CubemapEAC
+                      : StViewSurface_Cubemap;
+        }
+    } else if(aViewMode == StViewSurface_Cubemap || aViewMode == StViewSurface_CubemapEAC) {
         aViewMode = StViewSurface_Plain;
     }
 
+    // setup scissor box
+    StGLBoxPx aScissorBox;
+    const StRectI_t aFrameRectAbs = getAbsolute(aFrameRectPx);
+    if(aViewMode == StViewSurface_Plain) {
+        getRoot()->stglScissorRect2d(aFrameRectAbs, aScissorBox);
+    } else {
+        getRoot()->stglScissorRect3d(aFrameRectAbs, aScissorBox);
+    }
+    aCtx.stglSetScissorRect(aScissorBox, true);
+    aCtx.stglResizeViewport(aScissorBox);
+
+    myFrameSize.x() = int(double(aTextures.getPlane().getDataSize().x()) * double(aTextures.getPlane().getSizeX()));
+    myFrameSize.y() = int(double(aTextures.getPlane().getDataSize().y()) * double(aTextures.getPlane().getSizeY()));
+    mySampleRatio = aTextures.getPlane().getPixelRatio();
+
     myProgram.setColorScale(aColorScale); // apply de-anaglyph color filter
     StGLImageProgram::FragGetColor aColorGetter = params.TextureFilter->getValue() == StGLImageProgram::FILTER_BLEND
                                                 ? StGLImageProgram::FragGetColor_Blend
                                                 : StGLImageProgram::FragGetColor_Normal;
+    const bool toDragImageInSwipe = getRectPx().ratio() < 0.75; // drag image only in portrait mode while swiping
     switch(aViewMode) {
         case StViewSurface_Plain: {
-            if(!myProgram.init(aCtx, aTextures.getColorModel(), aTextures.getColorScale(), aColorGetter)) {
-                break;
-            }
-
-            myProgram.getActiveProgram()->use(aCtx);
-
-            // setup data rectangle in the texture
-            myProgram.setTextureSizePx      (aCtx, aTextureSize);
-            myProgram.setTextureMainDataSize(aCtx, aClampVec);
-            myProgram.setTextureUVDataSize  (aCtx, aClampUV);
-
-            // handle dragging timer
-            if( isClicked(ST_MOUSE_LEFT)
-            && !myIsClickAborted
-            &&  myClickTimer.isOn()) {
-                if(myClickTimer.getElapsedTimeInMilliSec() < myDragDelayMs) {
-                    const StPointD_t aCurr = getRoot()->getCursorZo();
-                    const int aDx = int((aCurr.x() - myClickPntZo.x()) * double(getRectPx().width()));
-                    const int aDy = int((aCurr.y() - myClickPntZo.y()) * double(getRectPx().height()));
-                    if(std::abs(aDx) > myRoot->getClickThreshold()
-                    || std::abs(aDy) > myRoot->getClickThreshold()) {
-                        myIsClickAborted = true;
+            const float aBrightnessBack = params.Brightness->getValue();
+            const double aDragDelayMs = myDragDelayMs > 0.0 ? myDragDelayMs : myDragDelayTmpMs;
+            if(isClicked(ST_MOUSE_LEFT)) {
+                // handle dragging timer
+                if(!myIsClickAborted
+                &&  myClickTimer.isOn()) {
+                    if(myClickTimer.getElapsedTimeInMilliSec() < aDragDelayMs) {
+                        const StPointD_t aCurr = getRoot()->getCursorZo();
+                        const int aDx = int((aCurr.x() - myClickPntZo.x()) * double(getRectPx().width()));
+                        const int aDy = int((aCurr.y() - myClickPntZo.y()) * double(getRectPx().height()));
+                        if(std::abs(aDx) > myRoot->getClickThreshold()
+                        || std::abs(aDy) > myRoot->getClickThreshold()) {
+                            myIsClickAborted = true;
+                            myClickTimer.stop();
+                        }
+                    } else {
                         myClickTimer.stop();
                     }
-                } else {
-                    myClickTimer.stop();
                 }
-            }
 
-            // handle dragging
-            if( isClicked(ST_MOUSE_LEFT)
-            && !myIsClickAborted
-            && !myClickTimer.isOn()) {
-                const GLfloat aRectRatio = GLfloat(getRectPx().ratio());
-                aParams->moveFlat(getMouseMoveFlat(myClickPntZo, getRoot()->getCursorZo()), aRectRatio);
-                if(myDragDelayMs > 1.0) {
-                    const GLfloat    aScaleSteps = 0.1f;
-                    const StPointD_t aCenterCursor(0.5, 0.5);
-                    const StGLVec2   aVec = getMouseMoveFlat(aCenterCursor, getRoot()->getCursorZo()) * (-aScaleSteps);
-                    aParams->scaleIn(aScaleSteps);
-                    aParams->moveFlat(aVec, aRectRatio);
+                // handle dragging
+                if(!myIsClickAborted
+                && !myClickTimer.isOn()) {
+                    // panning
+                    const GLfloat aRectRatio = GLfloat(getRectPx().ratio());
+                    aParams->moveFlat(getMouseMoveFlat(myClickPntZo, getRoot()->getCursorZo()), aRectRatio);
+                    if(aDragDelayMs > 1.0) {
+                        const GLfloat    aScaleSteps = 0.1f;
+                        const StPointD_t aCenterCursor(0.5, 0.5);
+                        const StGLVec2   aVec = getMouseMoveFlat(aCenterCursor, getRoot()->getCursorZo()) * (-aScaleSteps);
+                        aParams->scaleIn(aScaleSteps);
+                        aParams->moveFlat(aVec, aRectRatio);
+                    }
+                } else if(!myList.isNull()) {
+                    // previous / next swipe gesture
+                    const double anIntensMult = toDragImageInSwipe ? 1.0 : 3.0;
+                    const StPlayList::CurrentPosition aPos = myList->getCurrentPosition();
+                    const double aMouseDX = myClickPntZo.x() - getRoot()->getCursorZo().x();
+                    const float aScaleSteps = (float )stMin(std::abs(aMouseDX) * anIntensMult, 1.0);
+                    if(aMouseDX < 0.0) {
+                        // previous
+                        if(aPos == StPlayList::CurrentPosition_Middle
+                        || aPos == StPlayList::CurrentPosition_Last) {
+                            //params.Brightness->setValue(aBrightnessBack - aScaleSteps);
+                            //aParams->scaleIn(-aScaleSteps);
+                            if(toDragImageInSwipe) {
+                                StGLVec2 aVec = getMouseMoveFlat(myClickPntZo, getRoot()->getCursorZo());
+                                aVec.y() = 0.0;
+                                aParams->moveFlat(aVec, float(getRectPx().ratio()));
+                            }
+                            myIconPrev->setOpacity(aScaleSteps, false);
+                        }
+                    } else {
+                        // next
+                        if(aPos == StPlayList::CurrentPosition_Middle
+                        || aPos == StPlayList::CurrentPosition_First) {
+                            if(toDragImageInSwipe) {
+                                StGLVec2 aVec = getMouseMoveFlat(myClickPntZo, getRoot()->getCursorZo());
+                                aVec.y() = 0.0;
+                                aParams->moveFlat(aVec, float(getRectPx().ratio()));
+                            }
+                            myIconNext->setOpacity(aScaleSteps, false);
+                        }
+                    }
+                }
+            } else if(myFadeTimer.isOn()) {
+                static const double THE_FADE_ANIM_MS = 1000.0;
+                const double aProgress  = myFadeTimer.getElapsedTimeInMilliSec() / THE_FADE_ANIM_MS;
+                const double aFadeClamp = stMin(1.0, aProgress);
+                const bool isNext = myFadeFrom.x() < myClickPntZo.x();
+                if(toDragImageInSwipe) {
+                    StPointD_t aFadeTo = myFadeFrom;
+                    aFadeTo.x() += isNext ? -aFadeClamp : aFadeClamp;
+
+                    StGLVec2 aVec = getMouseMoveFlat(myClickPntZo, aFadeTo);
+                    aVec.y() = 0.0;
+                    aParams->moveFlat(aVec, float(getRectPx().ratio()));
                 }
+                params.Brightness->setValue(aBrightnessBack - (float )aFadeClamp * 3.0f);
+
+                // animate icon opacity in loop
+                const double anIntensMult  = toDragImageInSwipe ? 1.0 : 3.0;
+                const double anOpacityFrom = stMin(std::abs(myClickPntZo.x() - myFadeFrom.x()) * anIntensMult, 1.0);
+                double anIconProgress = anOpacityFrom + aProgress;
+                const bool isEven = (int(anIconProgress) % 2) == 0;
+                anIconProgress -= int(anIconProgress);
+                if(!isEven) { anIconProgress = 1.0 - anIconProgress; }
+                StGLIcon* anIcon = isNext ? myIconNext : myIconPrev;
+                anIcon->setOpacity((float )anIconProgress, false);
             }
 
             GLfloat anXRotate = aParams->getXRotate();
@@ -748,6 +1043,7 @@
             }
 
             // apply scale
+            const float aVrScale = float(myRoot->getVrZoomOut());
             aModelMat.scale(aParams->ScaleFactor * aVrScale, aParams->ScaleFactor * aVrScale, 1.0f);
 
             // apply position
@@ -785,6 +1081,7 @@
                              case StFormat_SideBySide_RL: {
                                 if(aDispRatio >= 0.85 && aDispRatio <= 1.18) {
                                     aDispRatio *= 2.0;
+                                    mySampleRatio *= 2.0f;
                                 }
                                 break;
                              }
@@ -792,6 +1089,7 @@
                              case StFormat_TopBottom_RL: {
                                 if(aDispRatio >= 3.5 && aDispRatio <= 4.8) {
                                     aDispRatio *= 0.5;
+                                    mySampleRatio *= 0.5f;
                                 }
                                 break;
                              }
@@ -815,24 +1113,64 @@
                 aModelMat.translate(StGLVec3( aSepDeltaX * 0.5f,  aSepDeltaY * 0.5f, 0.0f));
             }
 
-            StGLMatrix anOrthoMat;
-            anOrthoMat.initOrtho(StGLVolume(-aRectRatio * aFrustrumL, aRectRatio * aFrustrumR,
-                                            -1.0f       * aFrustrumB, 1.0f       * aFrustrumT,
-                                            -1.0f, 1.0f));
-            myProgram.getActiveProgram()->setProjMat (aCtx, anOrthoMat);
-            myProgram.getActiveProgram()->setModelMat(aCtx, aModelMat);
+            if(myProgram.init(aCtx, aTextures.getColorModel(), aTextures.getColorScale(), aColorGetter)) {
+                myProgram.getActiveProgram()->use(aCtx);
 
-            myQuad.draw(aCtx, *myProgram.getActiveProgram());
+                // setup data rectangle in the texture
+                myProgram.setTextureSizePx      (aCtx, aTextureSize);
+                myProgram.setTextureMainDataSize(aCtx, aClampVec);
+                myProgram.setTextureUVDataSize  (aCtx, aClampUV);
+                myProgram.setTextureADataSize   (aCtx, aClampA);
 
-            myProgram.getActiveProgram()->unuse(aCtx);
+                StGLMatrix anOrthoMat;
+                anOrthoMat.initOrtho(StGLVolume(-aRectRatio * aFrustrumL, aRectRatio * aFrustrumR,
+                                                -1.0f       * aFrustrumB, 1.0f       * aFrustrumT,
+                                                -1.0f, 1.0f));
+                myProgram.getActiveProgram()->setProjMat (aCtx, anOrthoMat);
+                myProgram.getActiveProgram()->setModelMat(aCtx, aModelMat);
+
+                myQuad.draw(aCtx, *myProgram.getActiveProgram());
+
+                myProgram.getActiveProgram()->unuse(aCtx);
+            }
 
             // restore changed parameters
             aParams->ScaleFactor = aScaleBack;
             aParams->PanCenter   = aPanBack;
+            params.Brightness->setValue(aBrightnessBack);
             break;
         }
-        case StViewSurface_Cubemap: {
-            if(!myProgram.init(aCtx, aTextures.getColorModel(), aTextures.getColorScale(), StGLImageProgram::FragGetColor_Cubemap)) {
+        case StViewSurface_Cubemap:
+        case StViewSurface_CubemapEAC: {
+            // Clamping range is passed through vertex attributes.
+            // To avoid extra vertex attributes, the smallest clamping range is used across planes.
+            // This trick is possible, because cubemap texture lazy resizing is not used,
+            // hence all planes should have same proportions.
+            // The result will be broken for rare formats like YUV422P/YUV411P/YUV440P.
+            StGLVec4 aClamVecMin = aClampVec;
+            if(aTextureUVSize.x() > 0.0f
+            && aTextureUVSize.y() > 0.0f) {
+                aClamVecMin.x() = stMax(aClamVecMin.x(), aClampUV.x());
+                aClamVecMin.y() = stMax(aClamVecMin.y(), aClampUV.y());
+                aClamVecMin.z() = stMin(aClamVecMin.z(), aClampUV.z());
+                aClamVecMin.w() = stMin(aClamVecMin.w(), aClampUV.w());
+            }
+            if(aTextureASize.x() > 0.0f
+            && aTextureASize.y() > 0.0f) {
+                aClamVecMin.x() = stMax(aClamVecMin.x(), aClampA.x());
+                aClamVecMin.y() = stMax(aClamVecMin.y(), aClampA.y());
+                aClamVecMin.z() = stMin(aClamVecMin.z(), aClampA.z());
+                aClamVecMin.w() = stMin(aClamVecMin.w(), aClampA.w());
+            }
+
+            if(myCubeClamp != aClamVecMin
+            || myCubePano != aTextures.getPlane().getPackedPanorama()) {
+                stglInitCube(aClamVecMin, aTextures.getPlane().getPackedPanorama());
+            }
+
+            if(!myProgram.init(aCtx, aTextures.getColorModel(), aTextures.getColorScale(),
+                               StGLImageProgram::FragGetColor_Cubemap,
+                               aViewMode == StViewSurface_CubemapEAC ? StGLImageProgram::FragTexEAC_On : StGLImageProgram::FragTexEAC_Off)) {
                 break;
             }
 
@@ -842,24 +1180,37 @@
             myProgram.setTextureSizePx      (aCtx, aTextureSize);
             myProgram.setTextureMainDataSize(aCtx, aClampVec);
             myProgram.setTextureUVDataSize  (aCtx, aClampUV);
+            myProgram.setTextureADataSize   (aCtx, aClampA);
             myProgram.setCubeTextureFlipZ   (aCtx, aParams->ToFlipCubeZ);
 
-            const float aScale = THE_PANORAMA_DEF_ZOOM * aParams->ScaleFactor * aVrScale;
+            const float aScale = aParams->ScaleFactor;
             aModelMat.scale(aScale, aScale, 1.0f);
 
             // compute orientation
             const StGLQuaternion anOri = getHeadOrientation(theView, true);
             aModelMat = StGLMatrix::multiply(aModelMat, StGLMatrix(anOri));
-
-            StGLMatrix aMatModelInv, aMatProjInv;
-            aModelMat.inverted(aMatModelInv);
-            myProjCam.getProjMatrixMono().inverted(aMatProjInv);
-            myProgram.getActiveProgram()->setProjMat (aCtx, StGLMatrix::multiply(aMatModelInv, aMatProjInv));
             myProgram.getActiveProgram()->setModelMat(aCtx, aModelMat);
 
-            ///glEnable(GL_TEXTURE_CUBE_MAP_SEAMLESS);
+            if(myProjCam.isCustomProjection()) {
+                myProgram.getActiveProgram()->setProjMat (aCtx, myProjCam.getProjMatrix());
+            } else {
+                myProgram.getActiveProgram()->setProjMat (aCtx, myProjCam.getProjMatrixMono());
+            }
 
-            myQuad.draw(aCtx, *myProgram.getActiveProgram());
+        #if !defined(GL_ES_VERSION_2_0)
+            // Issues with seamless cubemap filtering:
+            // - Desktop, available since OpenGL 3.2+ (or ARB_seamless_cube_map) and DISABLED by default;
+            //   some old implementations might be buggy;
+            //   some very old implementation might even switch to software fallback.
+            // - Mobile, OpenGL ES 3.0 requires cubemap filtering to be always ENABLED - no API for disabling;
+            //   OpenGL ES 3.0 implementations might not support seamless filtering without a way to detect it.
+            // - Seamless filtering works is desired for a proper cubemap definition,
+            //   but undesired for EAC video frames with non-square cube sides and has rotated sides.
+            if(aCtx.isGlGreaterEqual(3, 2)) {
+                ///glEnable(GL_TEXTURE_CUBE_MAP_SEAMLESS);
+            }
+        #endif
+            myCube.draw(aCtx, *myProgram.getActiveProgram());
 
             myProgram.getActiveProgram()->unuse(aCtx);
 
@@ -868,13 +1219,46 @@
             aParams->PanCenter   = aPanBack;
             break;
         }
+        case StViewSurface_Cylinder:
+        case StViewSurface_Theater:
+        case StViewSurface_Hemisphere:
         case StViewSurface_Sphere: {
             if(!myProgram.init(aCtx, aTextures.getColorModel(), aTextures.getColorScale(), aColorGetter)) {
                 break;
             }
 
+            StGLMesh* aMesh = &myUVSphere;
+            if(aViewMode == StViewSurface_Hemisphere) {
+                aMesh = &myHemisphere;
+            } else if(aViewMode == StViewSurface_Cylinder) {
+                aMesh = &myCylinder;
+                const StGLVec2 aSrcSize (aTextures.getPlane().getDataSize().x() * (float )aTextures.getPlane().getSizeX(),
+                                         aTextures.getPlane().getDataSize().y() * (float )aTextures.getPlane().getSizeY());
+                float aCylHeight = float(2.0 * M_PI * aSrcSize.y()) / aSrcSize.x();
+                //aVertScale *= aTextures.getPlane().getDisplayRatio();
+                if(myCylinder.getHeight() != aCylHeight) {
+                    myCylinder.setHeight(aCylHeight);
+                    myCylinder.release(aCtx);
+                }
+            } else if(aViewMode == StViewSurface_Theater) {
+                aMesh = &myTheater;
+                const float aCylWidth = float(M_PI * myTheater.getRadius() / myTheater.getAngle());
+                const float aCylHeight = (aCylWidth / aTextures.getPlane().getDisplayRatio()) * 0.75f;
+                if(myTheater.getHeight() != aCylHeight) {
+                    myTheater.setHeight(aCylHeight);
+                    myTheater.release(aCtx);
+                }
+            }
+            if(!aMesh->changeVBO(ST_VBO_VERTEX)->isValid()) {
+                if(!aMesh->initVBOs(aCtx)) {
+                    aCtx.pushError(StString("Fail to init mesh data"));
+                    ST_ERROR_LOG("Fail to init mesh data");
+                    break;
+                }
+            }
+
             // perform scaling
-            const float aScale = THE_SPHERE_RADIUS * THE_PANORAMA_DEF_ZOOM * aParams->ScaleFactor * aVrScale;
+            const float aScale = THE_SPHERE_RADIUS * aParams->ScaleFactor;
             aModelMat.scale(aScale, aScale, THE_SPHERE_RADIUS);
 
             // compute orientation
@@ -888,11 +1272,16 @@
             myProgram.setTextureSizePx      (aCtx, aTextureSize);
             myProgram.setTextureMainDataSize(aCtx, aClampVec);
             myProgram.setTextureUVDataSize  (aCtx, aClampUV);
+            myProgram.setTextureADataSize   (aCtx, aClampA);
 
-            myProgram.getActiveProgram()->setProjMat (aCtx, myProjCam.getProjMatrixMono());
             myProgram.getActiveProgram()->setModelMat(aCtx, aModelMat);
+            if(myProjCam.isCustomProjection()) {
+                myProgram.getActiveProgram()->setProjMat (aCtx, myProjCam.getProjMatrix());
+            } else {
+                myProgram.getActiveProgram()->setProjMat (aCtx, myProjCam.getProjMatrixMono());
+            }
 
-            myUVSphere.draw(aCtx, *myProgram.getActiveProgram());
+            aMesh->draw(aCtx, *myProgram.getActiveProgram());
 
             myProgram.getActiveProgram()->unuse(aCtx);
             break;
@@ -933,7 +1322,10 @@
 bool StGLImageRegion::tryClick(const StClickEvent& theEvent,
                                bool&               theIsItemClicked) {
     StHandle<StStereoParams> aParams = getSource();
-    if(!myIsInitialized || aParams.isNull()) {
+    const bool hasImage = !aParams.isNull()
+                        && myHasVideoStream
+                        && myTextureQueue->getQTexture().getFront(StGLQuadTexture::LEFT_TEXTURE).isValid();
+    if(!myIsInitialized || !hasImage) {
         return false;
     }
 
@@ -946,6 +1338,14 @@
             myClickPntZo = StPointD_t(theEvent.PointX, theEvent.PointY);
             myClickTimer.restart();
             myIsClickAborted = false;
+
+            myDragDelayTmpMs = 0.0f;
+            if(aParams->ViewingMode == StViewSurface_Plain
+            && fabs(aParams->ScaleFactor - 1.0f) < 0.00001f
+            && fabs(aParams->PanCenter.x()) < 0.00001f
+            && fabs(aParams->PanCenter.y()) < 0.00001f) {
+                myDragDelayTmpMs = 250.0;
+            }
         }
         theIsItemClicked = true;
         return true;
@@ -956,7 +1356,10 @@
 bool StGLImageRegion::tryUnClick(const StClickEvent& theEvent,
                                  bool&               theIsItemUnclicked) {
     StHandle<StStereoParams> aParams = getSource();
-    if(!myIsInitialized || aParams.isNull()) {
+    const bool hasImage = !aParams.isNull()
+                        && myHasVideoStream
+                        && myTextureQueue->getQTexture().getFront(StGLQuadTexture::LEFT_TEXTURE).isValid();
+    if(!myIsInitialized || !hasImage) {
         if(isClicked(theEvent.Button)) {
             theIsItemUnclicked = true;
             setClicked(theEvent.Button, false);
@@ -976,10 +1379,39 @@
             case StViewSurface_Plain: {
                 if(!myIsClickAborted) {
                     aParams->moveFlat(getMouseMoveFlat(myClickPntZo, aCursor), GLfloat(getRectPx().ratio()));
+                } else if(!myList.isNull()) {
+                    // previous / next swipe gesture
+                    StPlayList::CurrentPosition aPos = myList->getCurrentPosition();
+                    const double aMouseDX = myClickPntZo.x() - getRoot()->getCursorZo().x();
+                    if(std::abs(aMouseDX) >= 0.25) {
+                        if(aMouseDX < 0.0) {
+                            if(aPos == StPlayList::CurrentPosition_Middle
+                            || aPos == StPlayList::CurrentPosition_Last) {
+                                if(myList->walkToPrev()) {
+                                    signals.onOpenItem();
+                                    myFadeTimer.restart();
+                                    myFadeFrom = getRoot()->getCursorZo();
+                                }
+                            }
+                        } else {
+                            if(aPos == StPlayList::CurrentPosition_Middle
+                            || aPos == StPlayList::CurrentPosition_First) {
+                                if(myList->walkToNext()) {
+                                    signals.onOpenItem();
+                                    myFadeTimer.restart();
+                                    myFadeFrom = getRoot()->getCursorZo();
+                                }
+                            }
+                        }
+                    }
                 }
                 break;
             }
             case StViewSurface_Cubemap:
+            case StViewSurface_CubemapEAC:
+            case StViewSurface_Cylinder:
+            case StViewSurface_Theater:
+            case StViewSurface_Hemisphere:
             case StViewSurface_Sphere: {
                 aParams->moveSphere(getMouseMoveSphere(myClickPntZo, aCursor));
                 break;
@@ -1001,34 +1433,32 @@
         return false;
     }
 
-    const GLfloat SCALE_STEPS = fabs(theEvent.DeltaY) * 0.01f;
-    if(theEvent.DeltaY > 0.001f) {
-        if((myKeyFlags & ST_VF_CONTROL) == ST_VF_CONTROL) {
-            if((myKeyFlags & ST_VF_SHIFT) == ST_VF_SHIFT) {
+    if((myKeyFlags & ST_VF_CONTROL) == ST_VF_CONTROL) {
+        if(theEvent.StepsY == 0) {
+            return false;
+        }
+        if((myKeyFlags & ST_VF_SHIFT) == ST_VF_SHIFT) {
+            if(theEvent.StepsY > 0) {
                 doParamsSepZDec(0.01);
             } else {
-                doParamsSepX(size_t(-1));
-            }
-            return true;
-        } else if((myKeyFlags & ST_VF_SHIFT) == ST_VF_SHIFT) {
-            doParamsSepY(size_t(-1));
-            return true;
-        }
-
-        scaleAt(aCursor, SCALE_STEPS);
-    } else if(theEvent.DeltaY < -0.001f) {
-        if((myKeyFlags & ST_VF_CONTROL) == ST_VF_CONTROL) {
-            if((myKeyFlags & ST_VF_SHIFT) == ST_VF_SHIFT) {
                 doParamsSepZInc(0.01);
-            } else {
-                doParamsSepX(size_t(1));
             }
-            return true;
-        } else if((myKeyFlags & ST_VF_SHIFT) == ST_VF_SHIFT) {
-            doParamsSepY(size_t(1));
-            return true;
+        } else {
+            doParamsSepX(theEvent.StepsY > 0 ? size_t(-1) : size_t(1));
+        }
+        return true;
+    } else if((myKeyFlags & ST_VF_SHIFT) == ST_VF_SHIFT) {
+        if(theEvent.StepsY == 0) {
+            return false;
         }
+        doParamsSepY(theEvent.StepsY > 0 ? size_t(-1) : size_t(1));
+        return true;
+    }
 
+    const GLfloat SCALE_STEPS = fabs(theEvent.DeltaY) * 0.1f;
+    if(theEvent.DeltaY > 0.0001f) {
+        scaleAt(aCursor, SCALE_STEPS);
+    } else if(theEvent.DeltaY < -0.0001f) {
         scaleAt(aCursor, -SCALE_STEPS);
     }
     return true;
@@ -1060,6 +1490,10 @@
             break;
         }
         case StViewSurface_Cubemap:
+        case StViewSurface_CubemapEAC:
+        case StViewSurface_Cylinder:
+        case StViewSurface_Theater:
+        case StViewSurface_Hemisphere:
         case StViewSurface_Sphere: {
             if(theStep < 0.0f
             && aParams->ScaleFactor <= 0.24f) {

sview-17_04.tar.gz/StGLWidgets/StGLMessageBox.cpp -> sview-20_08.tar.gz/StGLWidgets/StGLMessageBox.cpp Changed

@@ -92,14 +92,15 @@
 
 void StGLMessageBox::create(const StString& theTitle,
                             const StString& theText,
-                            const int       theWidth,
-                            const int       theHeight) {
+                            const int  theWidth,
+                            const int  theHeight,
+                            const bool theHasButtons) {
     StGLWidget::signals.onMouseUnclick.connect(this, &StGLMessageBox::doMouseUnclick);
 
     myMarginLeft   = myRoot->scale(OFFSET_PIXELS);
     myMarginRight  = myRoot->scale(OFFSET_PIXELS);
     myMarginTop    = myRoot->scale(OFFSET_PIXELS);
-    myMarginBottom = myRoot->scale(24 * 3);
+    myMarginBottom = myRoot->scale(theHasButtons ? (24 * 3) : OFFSET_PIXELS);
     myMinSizeY     = myRoot->scale(200);
 
     int aTitleOffset =  myRoot->scale(24);
@@ -110,7 +111,7 @@
         myMarginLeft   =  myRoot->scale(4);
         myMarginRight  =  myRoot->scale(4);
         myMarginTop    =  myRoot->scale(4);
-        myMarginBottom =  myRoot->scale(32);
+        myMarginBottom =  myRoot->scale(theHasButtons ? 32 : 4);
         aTitleOffset   =  myRoot->scale(4);
         aBtnBot        = -myRoot->scale(4);
     }
@@ -329,7 +330,7 @@
             if(double(aSizeYToFit) / double(aMaxSizeY) > 0.7) {
                 aNewSizeY = stMax(myMinSizeY, aMaxSizeY);
             }
-            changeRectPx().bottom() = aNewSizeY;
+            changeRectPx().bottom() = getRectPx().top() + aNewSizeY;
             myContent->changeRectPx().bottom() = myContent->getRectPx().top() + aNewSizeY - myMarginTop - myMarginBottom;
         }
     }
@@ -369,7 +370,7 @@
     }
 
     StGLBoxPx aScissorRect;
-    stglScissorRect(aScissorRect);
+    stglScissorRect2d(aScissorRect);
     aCtx.stglSetScissorRect(aScissorRect, true);
 
     StGLWidget::stglDraw(theView); // draw children
@@ -389,17 +390,18 @@
 
 bool StGLMessageBox::tryUnClick(const StClickEvent& theEvent,
                                 bool&               theIsItemUnclicked) {
+    const bool wasDragged = myContent->hasDragged();
     if(//isPointIn(StPointD_t(theEvent.PointX, theEvent.PointY)) &&
        StGLWidget::tryUnClick(theEvent, theIsItemUnclicked)) {
         theIsItemUnclicked = true;
 
-        if(myIsContextual) {
+        if(myIsContextual && !wasDragged) {
             myRoot->destroyWithDelay(this);
         }
         return true;
     }
 
-    if(myIsContextual) {
+    if(myIsContextual && !wasDragged) {
         myRoot->destroyWithDelay(this);
     }
     return false;

sview-17_04.tar.gz/StGLWidgets/StGLOpenFile.cpp -> sview-20_08.tar.gz/StGLWidgets/StGLOpenFile.cpp Changed

@@ -1,6 +1,6 @@
 /**
  * StGLWidgets, small C++ toolkit for writing GUI using OpenGL.
- * Copyright © 2015 Kirill Gavrilov <kirill@sview.ru>
+ * Copyright © 2015-2019 Kirill Gavrilov <kirill@sview.ru>
  *
  * Distributed under the Boost Software License, Version 1.0.
  * See accompanying file license-boost.txt or copy at
@@ -11,17 +11,250 @@
 
 #include <StGLWidgets/StGLMenu.h>
 #include <StGLWidgets/StGLMenuItem.h>
+#include <StGLWidgets/StGLMenuCheckbox.h>
+#include <StGLWidgets/StGLCheckbox.h>
 #include <StGLWidgets/StGLScrollArea.h>
 #include <StGLWidgets/StGLTextureButton.h>
 
+#include <StThreads/StThread.h>
+
+#include <fstream>
+
+#if !defined(_WIN32)
+    #include <unistd.h>
+#endif
+
+#ifdef _WIN32
+/**
+ * Auxiliary tool resolving drive labels.
+ */
+struct StDriveNameResolver {
+
+    StMutex Mutex;
+    std::vector<StString> Drives;
+    std::vector<StString> Labels;
+    volatile int NbProcessed;
+    volatile bool ToAbort;
+
+public:
+    /**
+     * Empty constructor.
+     */
+    StDriveNameResolver() : NbProcessed(0), ToAbort(false) {}
+
+    /**
+     * Init list.
+     */
+    void init() {
+        const DWORD aLogicalDrivesMask = ::GetLogicalDrives();
+        for(int aLetterIter = 'A'; aLetterIter <= 'Z'; ++aLetterIter) {
+            const int aBit = 1 << (aLetterIter - 'A');
+            if((aLogicalDrivesMask & aBit) != 0) {
+                Drives.push_back(StString()         + char(aLetterIter) + ":\\");
+                Labels.push_back(StString("Drive ") + char(aLetterIter) + ":\\");
+            }
+        }
+
+        // enumerate all physical drives seen by Windows
+        const GUID PARTITION_BASIC_DATA_GUID = { 0xEBD0A0A2L, 0xB9E5, 0x4433, {0x87, 0xC0, 0x68, 0xB6, 0xB7, 0x26, 0x99, 0xC7} };
+        static const DWORD aPartInfoSize = sizeof(DRIVE_LAYOUT_INFORMATION_EX) + 128 * sizeof(PARTITION_INFORMATION_EX); // up to 128 partitions
+        char aPartInfoBuffer[aPartInfoSize] = {};
+        DRIVE_LAYOUT_INFORMATION_EX* aPartitions = (DRIVE_LAYOUT_INFORMATION_EX* )aPartInfoBuffer;
+        for(int aDriveIter = 0; aDriveIter < 1000; ++aDriveIter) {
+            const StStringUtfWide aDriveId = StStringUtfWide(L"\\\\.\\PhysicalDrive") + aDriveIter;
+            HANDLE aDriveHandle = CreateFileW(aDriveId.toCString(), 0, FILE_SHARE_READ, NULL, OPEN_EXISTING, 0, 0);
+            if(aDriveHandle == INVALID_HANDLE_VALUE) {
+                break;
+            }
+
+            // list partitions
+            DWORD aDummyIor = 0;
+            if(!DeviceIoControl(aDriveHandle, IOCTL_DISK_GET_DRIVE_LAYOUT_EX, NULL, 0, aPartitions, aPartInfoSize, &aDummyIor, NULL)) {
+                CloseHandle(aDriveHandle);
+                continue;
+            }
+
+            for(DWORD aPartIter = 0; aPartIter < aPartitions->PartitionCount; ++aPartIter) {
+                const PARTITION_INFORMATION_EX& aPart = aPartitions->PartitionEntry[aPartIter];
+                switch(aPart.PartitionStyle) {
+                    case PARTITION_STYLE_MBR: {
+                        if(aPart.Mbr.PartitionType == PARTITION_ENTRY_UNUSED || !aPart.Mbr.RecognizedPartition) {
+                            continue; // ignore unused
+                        }
+                        break;
+                    }
+                    case PARTITION_STYLE_GPT: {
+                        if(aPart.Gpt.PartitionType != PARTITION_BASIC_DATA_GUID) {
+                            continue; // ignore unused
+                        }
+                        break;
+                    }
+                    default: {
+                        continue; // ignore unknown
+                    }
+                }
+
+                const StStringUtfWide aPartVolume = findPartitionVolume(aDriveIter, aPart);
+                if(aPartVolume.isEmpty()) {
+                    continue;
+                }
+
+                // find mount points
+                DWORD aMntPointLen = 0;
+                std::vector<wchar_t> aMntPoints(1);
+                GetVolumePathNamesForVolumeNameW(aPartVolume.toCString(), aMntPoints.data(), 0, &aMntPointLen);
+                if(aMntPointLen > 0) {
+                    aMntPoints.resize (aMntPointLen + 1, '\0');
+                    if(GetVolumePathNamesForVolumeNameW(aPartVolume.toCString(), aMntPoints.data(), aMntPointLen, &aMntPointLen) != FALSE) {
+                        StString aMntPointRes(aMntPoints.data());
+                        for(const wchar_t* aMntPointIter = aMntPoints.data(); aMntPointIter[0] != '\0'; aMntPointIter += wcslen(aMntPointIter)) {
+                            const StString aMntPoint(aMntPointIter);
+                            if(aMntPoint.getLength() == 3
+                            && aMntPoint.toCString()[1] == ':'
+                            && aMntPoint.toCString()[2] == '\\') {
+                                // filter common logical drive letter
+                                aMntPointRes.clear();
+                                break;
+                            }
+                        }
+                        if(!aMntPointRes.isEmpty()) {
+                            if(aMntPointRes.getLength() > 3
+                            && aMntPointRes.isEndsWith('\\')) {
+                                aMntPointRes = aMntPointRes.subString(0, aMntPointRes.getLength() - 1);
+                            }
+                            Drives.push_back(aMntPointRes);
+                            Labels.push_back(StString("Drive ") + aMntPointRes);
+                        }
+                    }
+                }
+            }
+            CloseHandle(aDriveHandle);
+        }
+    }
+
+    /**
+     * Working thread callback.
+     */
+    void resolve() {
+        wchar_t aVolumeName[256];
+        wchar_t aFileSystemName[256];
+        StString aDriveLabel;
+        const StString aDriveA = "A:";
+        const StString aDriveB = "B:";
+        for(; NbProcessed < (int )Drives.size(); StAtomicOp::Increment(NbProcessed)) {
+            const StString& aDrivePath = Drives[NbProcessed];
+            StStringUtfWide aDrivePathW = aDrivePath.toUtfWide();
+            if(!aDrivePath.isEndsWith('\\')) {
+                aDrivePathW += '\\';
+            }
+            DWORD aSerialNumber = 0, aMaxFileNameLength = 0, aFileSystemFlags = 0;
+            if(!aDrivePath.isStartsWithIgnoreCase(aDriveA)
+            && !aDrivePath.isStartsWithIgnoreCase(aDriveB)
+            && ::GetVolumeInformationW(aDrivePathW.toCString(),
+                                       aVolumeName, sizeof(aVolumeName) / sizeof(wchar_t),
+                                       &aSerialNumber, &aMaxFileNameLength, &aFileSystemFlags,
+                                       aFileSystemName, sizeof(aFileSystemName) / sizeof(wchar_t))) {
+                aDriveLabel.fromUnicode(aVolumeName);
+                if(!aDriveLabel.isEmpty() && !ToAbort) {
+                    StMutexAuto aLock(Mutex);
+                    Labels[NbProcessed] = aDrivePath + " [" + aDriveLabel + "]";
+                }
+            }
+
+            if(ToAbort) {
+                return;
+            }
+        }
+    }
+
+    /**
+     * Working thread callback.
+     */
+    static SV_THREAD_FUNCTION resolveThread(void* thePtr) {
+        StHandle<StDriveNameResolver> aThis = *static_cast<StHandle<StDriveNameResolver>* >(thePtr);
+        aThis->resolve();
+        return SV_THREAD_RETURN 0;
+    }
+
+        private:
+
+    /**
+     * Find volume name for partition.
+     */
+    static StStringUtfWide findPartitionVolume(DWORD theDiskNumber, const PARTITION_INFORMATION_EX& thePart) {
+        // handle up-to 256 extents
+        static const DWORD THE_EXTENTS_SIZE = sizeof(VOLUME_DISK_EXTENTS) + 256 * sizeof(DISK_EXTENT);
+        char aBuffer[THE_EXTENTS_SIZE] = {};
+        VOLUME_DISK_EXTENTS* aVolDiskExtents = (VOLUME_DISK_EXTENTS* )aBuffer;
+
+        std::vector<wchar_t> aVolName(4096, '\0');
+        HANDLE aVolIter = FindFirstVolumeW(aVolName.data(), (DWORD )aVolName.size());
+        for(bool hasMoreVolumes = aVolIter != INVALID_HANDLE_VALUE; hasMoreVolumes; hasMoreVolumes = FindNextVolumeW (aVolIter, aVolName.data(), (DWORD )aVolName.size()) != FALSE) {
+            aVolName[wcslen(aVolName.data()) - 1] = '\0'; // volume must be without trailing backslash here
+            HANDLE aVolHandle = CreateFileW(aVolName.data(), 0, FILE_SHARE_READ, NULL, OPEN_EXISTING, 0, 0);
+            aVolName[wcslen(aVolName.data())] = '\\';
+            if(aVolHandle == INVALID_HANDLE_VALUE) {
+                continue;
+            }
+
+            DWORD anExtentsSize = 0;
+            if(DeviceIoControl(aVolHandle, IOCTL_VOLUME_GET_VOLUME_DISK_EXTENTS, NULL, 0, (void* )aVolDiskExtents, THE_EXTENTS_SIZE, &anExtentsSize, NULL) == FALSE) {
+                CloseHandle(aVolHandle);
+                continue;
+            }
+
+            for(DWORD anExtentIter = 0; anExtentIter < aVolDiskExtents->NumberOfDiskExtents; ++anExtentIter) {
+                const DISK_EXTENT& anExtent = aVolDiskExtents->Extents[anExtentIter];
+                if(anExtent.DiskNumber == theDiskNumber
+                && anExtent.StartingOffset.QuadPart == thePart.StartingOffset.QuadPart
+                && anExtent.ExtentLength.QuadPart == thePart.PartitionLength.QuadPart) {
+                    CloseHandle(aVolHandle);
+                    FindVolumeClose(aVolIter);
+                    return StStringUtfWide(aVolName.data());
+                }
+            }
+            CloseHandle(aVolHandle);
+        }
+        FindVolumeClose(aVolIter);
+        return StStringUtfWide();
+    }
+
+};
+#endif
+
+/**
+ * Dummy sub-class overriding scrollable behavior.
+ */
+class StGLOpenFileMenu : public StGLMenu {
+
+        public:
+
+    ST_LOCAL StGLOpenFileMenu(StGLWidget* theParent,
+                              int  theLeft,
+                              int  theTop,
+                              int  theOrient = MENU_VERTICAL,
+                              bool theIsRootMenu = false)
+    : StGLMenu(theParent, theLeft, theTop, theOrient, theIsRootMenu) {}
+
+    ST_LOCAL virtual bool doScroll(const StScrollEvent& theEvent) ST_ATTR_OVERRIDE {
+        return StGLWidget::doScroll(theEvent); // skip StGLMenu
+    }
+
+};
+
 StGLOpenFile::StGLOpenFile(StGLWidget*     theParent,
                            const StString& theTitle,
                            const StString& theCloseText)
 : StGLMessageBox(theParent, theTitle, "",
                  theParent->getRoot()->scale(512), theParent->getRoot()->scale(400)),
   myCurrentPath(NULL),
+  myHotListContent(NULL),
   myHotList(NULL),
   myList(NULL),
+  myMainFilterCheck(NULL),
+  myExtraFilterCheck(NULL),
+  myToShowMainFilter(new StBoolParam(true)),
+  myToShowExtraFilter(new StBoolParam(false)),
   myHighlightColor(0.5f, 0.5f, 0.5f, 1.0f),
   myItemColor     (1.0f, 1.0f, 1.0f, 1.0f),
   myFileColor     (0.7f, 0.7f, 0.7f, 1.0f),
@@ -31,6 +264,9 @@
   myIconSizeX(theParent->getRoot()->scale(16)) {
     myToAdjustY = false;
 
+    myToShowMainFilter ->signals.onChanged = stSlot(this, &StGLOpenFile::doFilterCheck);
+    myToShowExtraFilter->signals.onChanged = stSlot(this, &StGLOpenFile::doFilterCheck);
+
     int aMarginTop = myMarginTop + myRoot->scale(30);
     myCurrentPath = new StGLTextArea(this, myMarginLeft, myMarginTop, StGLCorner(ST_VCORNER_TOP, ST_HCORNER_LEFT),
                                      myContent->getRectPx().width(), myContent->getRectPx().height());
@@ -38,17 +274,19 @@
                                   StGLTextFormatter::ST_ALIGN_Y_TOP);
     myCurrentPath->setTextColor(myRoot->getColorForElement(StGLRootWidget::Color_MessageText));
 
-    myHotList = new StGLMenu(this, 0, 0, StGLMenu::MENU_VERTICAL_COMPACT);
+    myContent->changeRectPx().top()  = aMarginTop;
+    myContent->changeRectPx().left() = myMarginLeft + myHotSizeX;
+
+    myHotListContent = new StGLScrollArea(this, myMarginLeft, aMarginTop,
+                                          StGLCorner(ST_VCORNER_TOP, ST_HCORNER_LEFT),
+                                          myHotSizeX, myContent->getRectPx().height());
+
+    myHotList = new StGLOpenFileMenu(myHotListContent, 0, 0, StGLMenu::MENU_VERTICAL_COMPACT);
     myHotList->setOpacity(1.0f, true);
     myHotList->setItemWidth(myHotSizeX);
     myHotList->setColor(StGLVec4(0.0f, 0.0f, 0.0f, 0.0f));
-    myHotList->changeRectPx().top()   = aMarginTop;
-    myHotList->changeRectPx().left()  = myMarginLeft;
-    myHotList->changeRectPx().right() = myMarginLeft + myHotSizeX;
-    myContent->changeRectPx().top()   = aMarginTop;
-    myContent->changeRectPx().left()  = myMarginLeft + myHotSizeX;
 
-    myList = new StGLMenu(myContent, 0, 0, StGLMenu::MENU_VERTICAL_COMPACT);
+    myList = new StGLOpenFileMenu(myContent, 0, 0, StGLMenu::MENU_VERTICAL_COMPACT);
     myList->setOpacity(1.0f, true);
     myList->setColor(StGLVec4(0.0f, 0.0f, 0.0f, 0.0f));
     myList->setItemWidthMin(myContent->getRectPx().width());
@@ -56,6 +294,88 @@
     //if(!myRoot->isMobile()) {
         addButton(theCloseText);
     //}
+
+    addSystemDrives();
+}
+
+void StGLOpenFile::addSystemDrives() {
+#ifdef _WIN32
+    StHandle<StDriveNameResolver> aResolver = new StDriveNameResolver();
+    aResolver->init();
+    if(!aResolver->Drives.empty()) {
+        // name resolver might hang on resource unavailability
+        StThread aThread(StDriveNameResolver::resolveThread, &aResolver);
+        if(!aThread.wait(1000)) {
+            //aThread.kill();
+            aResolver->ToAbort = true;
+            aThread.detach();
+        }
+
+        StMutexAuto aLock(aResolver->Mutex);
+        for(size_t aDriveIter = 0; aDriveIter < aResolver->Drives.size(); ++aDriveIter) {
+            addHotItem(aResolver->Drives[aDriveIter], aResolver->Labels[aDriveIter]);
+        }
+    }
+#else
+    // modern Android does not permit listing / content
+    if(access("/", R_OK) == 0) {
+        addHotItem("/", "Root");
+    }
+#endif
+
+#if defined(__ANDROID__)
+    std::ifstream aMountsFile("/proc/mounts");
+    if(!aMountsFile.is_open()) {
+        return;
+    }
+    std::string aLineStd;
+    while(std::getline(aMountsFile, aLineStd)) {
+        const StString aLine(aLineStd.c_str());
+        StHandle<StArrayList<StString> > aMountLine = aLine.split(' ');
+        if(aMountLine->size() < 4) {
+            continue;
+        }
+
+        const StString& aDevice  = aMountLine->getValue(0);
+        const StString& aMount   = aMountLine->getValue(1);
+        const StString& aFileSys = aMountLine->getValue(2);
+        const StString aMountLower = aMount.lowerCased();
+        // filter by unsupported file-system
+        /*if(aFileSys == stCString("tmpfs")
+        || aFileSys == stCString("devpts")
+        || aFileSys == stCString("sysfs")
+        || aFileSys == stCString("selinuxfs")
+        || aFileSys == stCString("debugfs")
+        || aFileSys == stCString("configfs")
+        || aFileSys == stCString("cgroup")
+        || aFileSys == stCString("functionfs")) {
+            continue;
+        }*/
+        // filter by supported file-system
+        if(aFileSys != stCString("fuse")
+        && aFileSys != stCString("vfat")
+        && aFileSys != stCString("ntfs")
+        && aFileSys != stCString("ext4")) {
+            continue;
+        }
+        // filter special paths
+        if(aMountLower.isStartsWith(stCString("/mnt/secure"))
+        || aMountLower.isStartsWith(stCString("/mnt/asec"))
+        || aMountLower.isStartsWith(stCString("/mnt/mapper"))
+        || aMountLower.isStartsWith(stCString("/mnt/obb"))
+        || aMountLower == stCString("/storage/emulated")
+        || aMountLower.isStartsWith(stCString("/mnt/shell/emulated"))         // ignore symlink to /storage/emulated/0/ for current user, Android 4.2+
+        || aMountLower.isStartsWith(stCString("/storage/emulated/legacy"))) { // ignore symlink to /storage/emulated/X/ for current user
+            continue;
+        }
+        // filter bootdevice entities
+        if( aDevice.isStartsWith(stCString("/dev/block"))
+        && !aDevice.isStartsWith(stCString("/dev/block/vold"))) {
+            continue;
+        }
+        addHotItem(aMount);
+    }
+#endif
 }
 
 StGLOpenFile::~StGLOpenFile() {
@@ -74,15 +394,70 @@
     }
 }
 
-void StGLOpenFile::setMimeList(const StMIMEList& theFilter) {
-    myFilter     = theFilter;
-    myExtensions = theFilter.getExtensionsList();
+void StGLOpenFile::setMimeList(const StMIMEList& theFilter,
+                               const StString& theName,
+                               const bool theIsExtra) {
+    if(theIsExtra) {
+        myExtraFilter = theFilter;
+    } else {
+        myFilter = theFilter;
+    }
+
+    StGLMenuCheckbox*& aFilterWidget = theIsExtra ? myExtraFilterCheck : myMainFilterCheck;
+    if(!theName.isEmpty() && aFilterWidget == NULL) {
+        StHandle<StBoolParam>& aFilterParam = theIsExtra ? myToShowExtraFilter : myToShowMainFilter;
+        aFilterWidget = addHotCheckbox(aFilterParam, theName);
+    }
+    if(aFilterWidget != NULL) {
+        aFilterWidget->setText(theName);
+    }
+    initExtensions();
+}
+
+StGLMenuCheckbox* StGLOpenFile::addHotCheckbox(const StHandle<StBoolParam>& theParam,
+                                               const StString& theName) {
+    StGLMenuCheckbox* aFilterWidget = new StGLMenuCheckbox(myHotList, theParam);
+
+    StGLCheckbox* aCheckBox = aFilterWidget->getCheckbox();
+    aCheckBox->setColor(myHotColor);
+    aCheckBox->setCorner(StGLCorner(ST_VCORNER_CENTER, ST_HCORNER_RIGHT));
+    aCheckBox->changeRectPx().moveLeftTo(-aCheckBox->getRectPx().left());
+
+    aFilterWidget->changeMargins().left  = -(myMarginX + myIconSizeX + myMarginX); // TODO weird logic
+    aFilterWidget->setupStyle(StFTFont::Style_Italic);
+    aFilterWidget->setText(theName);
+    aFilterWidget->setupAlignment(StGLTextFormatter::ST_ALIGN_X_RIGHT, StGLTextFormatter::ST_ALIGN_Y_CENTER);
+    aFilterWidget->setTextColor(myHotColor);
+    aFilterWidget->setHilightColor(myHighlightColor);
+    return aFilterWidget;
+}
+
+void StGLOpenFile::initExtensions() {
+    myExtensions.clear();
+    StArrayList<StString> aList1 = myToShowMainFilter ->getValue() ? myFilter.getExtensionsList()      : StArrayList<StString>(1);
+    StArrayList<StString> aList2 = myToShowExtraFilter->getValue() ? myExtraFilter.getExtensionsList() : StArrayList<StString>(1);
+    size_t anExtent = aList1.size() + aList2.size();
+    myExtensions.initList(anExtent);
+    for(size_t anExtIter = 0; anExtIter < aList1.size(); ++anExtIter) {
+        myExtensions.add(aList1[anExtIter]);
+    }
+    for(size_t anExtIter = 0; anExtIter < aList2.size(); ++anExtIter) {
+        myExtensions.add(aList2[anExtIter]);
+    }
 }
 
 void StGLOpenFile::doHotItemClick(const size_t theItemId) {
     myItemToLoad = myHotPaths[theItemId];
 }
 
+void StGLOpenFile::doFilterCheck(const bool ) {
+    initExtensions();
+    if(!myFolder.isNull()) {
+        StString aPath = myFolder->getPath();
+        openFolder(aPath);
+    }
+}
+
 void StGLOpenFile::doFileItemClick(const size_t theItemId) {
     const StFileNode* aNode = myFolder->getValue(theItemId);
     myItemToLoad = aNode->getPath();
@@ -104,10 +479,14 @@
         myItemToLoad.clear();
         if(StFolder::isFolder(aPath)) {
             openFolder(aPath);
-        } else {
+        } else if(StFileNode::isFileExists(aPath)) {
             StHandle<StString> aPathHandle = new StString(aPath);
             signals.onFileSelected.emit(aPathHandle);
             myRoot->destroyWithDelay(this);
+        } else {
+            StGLMessageBox* aMsgBox = new StGLMessageBox(myRoot, "Error", StString("Path is inaccessible!\n") + aPath);
+            aMsgBox->addButton("Close");
+            aMsgBox->stglInit();
         }
     }
     return aRes;
@@ -132,6 +511,7 @@
 
     StGLMenuItem* anItem = new StGLPassiveMenuItem(myHotList);
     setItemIcon(anItem, myHotColor, true);
+    anItem->setupStyle(StFTFont::Style_Bold);
     anItem->setText(aName);
     anItem->setTextColor(myHotColor);
     anItem->setHilightColor(myHighlightColor);
@@ -141,7 +521,11 @@
     int aSizeX = anItem->getMargins().left + anItem->computeTextWidth() + anItem->getMargins().right;
     myHotSizeX = stMax(myHotSizeX, aSizeX);
 
-    myContent->changeRectPx().left() = myMarginLeft + myHotSizeX;
+    myHotListContent->changeRectPx().right() = myHotListContent->getRectPx().left() + myHotSizeX;
+    if(myMainFilterCheck != NULL) {
+        myMainFilterCheck->changeRectPx().right() = myHotSizeX;
+    }
+    myContent->changeRectPx().left() = myHotListContent->getRectPx().right();
     myList->setItemWidthMin(myContent->getRectPx().width());
 }
 
@@ -193,7 +577,8 @@
     myFolder = new StFolder(aFolder);
     myFolder->init(myExtensions, 1, true);
     StString aPath = myFolder->getPath();
-    myCurrentPath->setText(StString("<b>Location:*</b>") + aPath + (!aPath.isEmpty() ? ST_FILE_SPLITTER : ""));
+    myCurrentPath->setText(StString("<b>Location:*</b>") + aPath
+                         + (!aPath.isEmpty() && !aPath.isEndsWith(SYS_FS_SPLITTER) ? ST_FILE_SPLITTER : ""));
 
     StString aPathUp = StFileNode::getFolderUp(aPath);
     if(!aPathUp.isEmpty()) {

sview-17_04.tar.gz/StGLWidgets/StGLPlayList.cpp -> sview-20_08.tar.gz/StGLWidgets/StGLPlayList.cpp Changed

sview-17_04.tar.gz/StGLWidgets/StGLRootWidget.cpp -> sview-20_08.tar.gz/StGLWidgets/StGLRootWidget.cpp Changed

@@ -1,6 +1,6 @@
 /**
  * StGLWidgets, small C++ toolkit for writing GUI using OpenGL.
- * Copyright © 2009-2017 Kirill Gavrilov <kirill@sview.ru>
+ * Copyright © 2009-2020 Kirill Gavrilov <kirill@sview.ru>
  *
  * Distributed under the Boost Software License, Version 1.0.
  * See accompanying file license-boost.txt or copy at
@@ -263,31 +263,27 @@
     myGlCtx->stglSyncState();
     myGlCtx->core20fwd->glGetIntegerv(GL_VIEWPORT, myViewport); // cache viewport
 
-    switch(theView) {
-        case ST_DRAW_LEFT:
-            myScrDispX   =             myLensDist * GLfloat(0.5 * myRectGl.width());
-            myScrDispXPx =  int(double(myLensDist) * 0.5 * double(myRectPxFull.width()));
-            break;
-        case ST_DRAW_RIGHT:
-            myScrDispX   =            -myLensDist * GLfloat(0.5 * myRectGl.width());
-            myScrDispXPx = -int(double(myLensDist) * 0.5 * double(myRectPxFull.width()));
-            break;
-        case ST_DRAW_MONO:
-        default:
-            myScrDispX   = 0.0f;
-            myScrDispXPx = 0;
-            break;
-    }
-
-    if(myTextProgram->isValid()) {
-        myTextProgram->use(*myGlCtx);
-        myTextProgram->setProjMat(*myGlCtx,       myProjCamera.getProjMatrix());
-        myTextProgram->unuse(*myGlCtx);
-    }
-    if(myTextBorderProgram->isValid()) {
-        myTextBorderProgram->use(*myGlCtx);
-        myTextBorderProgram->setProjMat(*myGlCtx, myProjCamera.getProjMatrix());
-        myTextBorderProgram->unuse(*myGlCtx);
+    myScrDispX   = 0.0f;
+    myScrDispXPx = 0;
+    if(theView == ST_DRAW_LEFT || theView == ST_DRAW_RIGHT) {
+        if(myProjCamera.isCustomProjection()) {
+            StGLVec4 aTestProj = myProjCamera.getProjMatrix() * StGLVec4(0, 0, myProjCamera.getZScreen(), 1.0f);
+            aTestProj /= aTestProj.w();
+            aTestProj.x() = 0.5f + aTestProj.x() * 0.5f;
+            aTestProj.y() = 0.5f + aTestProj.y() * 0.5f;
+
+            myScrDispX   = float((aTestProj.x() - 0.5f) * myRectGl.width());
+            myScrDispXPx = int(double(aTestProj.x()) * double(myViewport[2]) - double(myViewport[2])/2);
+            //myScrDispYPx = int(double(aTestProj.y()) * double(myViewport[3]) - double(myViewport[3])/2);
+        } else {
+            if(theView == ST_DRAW_LEFT) {
+                myScrDispX   =             myLensDist * float(0.5 * myRectGl.width());
+                myScrDispXPx =  int(double(myLensDist) * 0.5 * double(myViewport[2]));
+            } else {
+                myScrDispX   =            -myLensDist * float(0.5 * myRectGl.width());
+                myScrDispXPx = -int(double(myLensDist) * 0.5 * double(myViewport[2]));
+            }
+        }
     }
 
     StGLWidget::stglDraw(theView);
@@ -314,8 +310,9 @@
     StGLWidget::stglUpdate(theCursorZo, theIsPreciseInput);
 }
 
-void StGLRootWidget::stglScissorRect(const StRectI_t& theRect,
-                                     StGLBoxPx&       theScissorRect) const {
+void StGLRootWidget::stglScissorRectInternal(const StRectI_t& theRect,
+                                             const bool theIs2d,
+                                             StGLBoxPx& theScissorRect) const {
     const GLint aVPortWidth  = myViewport[2];
     const GLint aVPortHeight = myViewport[3];
     const GLint aRootWidth   = myRectPxFull.width();
@@ -330,7 +327,8 @@
     const GLdouble aWidthFactor  = GLdouble(aVPortWidth)  / GLdouble(aRootWidth);
     const GLdouble aHeightFactor = GLdouble(aVPortHeight) / GLdouble(aRootHeight);
 
-    theScissorRect.x() = myViewport[0] + GLint(aWidthFactor  * GLdouble(theRect.left() + myScrDispXPx));
+    const int anEyeShiftPx = theIs2d ? myScrDispXPx : 0;
+    theScissorRect.x() = myViewport[0] + GLint(aWidthFactor  * GLdouble(theRect.left() + anEyeShiftPx));
     theScissorRect.y() = myViewport[1] + GLint(aHeightFactor * GLdouble(aRootHeight - theRect.bottom()));
 
     theScissorRect.width()  = GLint(aWidthFactor  * GLdouble(theRect.width()));
@@ -370,6 +368,16 @@
         myMenuProgram->setProjMat(*myGlCtx, getScreenProjection());
         myMenuProgram->unuse(*myGlCtx);
     }
+    if(myTextProgram->isValid()) {
+        myTextProgram->use(*myGlCtx);
+        myTextProgram->setProjMat(*myGlCtx, getScreenProjection());
+        myTextProgram->unuse(*myGlCtx);
+    }
+    if(myTextBorderProgram->isValid()) {
+        myTextBorderProgram->use(*myGlCtx);
+        myTextBorderProgram->setProjMat(*myGlCtx, getScreenProjection());
+        myTextBorderProgram->unuse(*myGlCtx);
+    }
 
     // update all child widgets
     if(isChanged) {

sview-17_04.tar.gz/StGLWidgets/StGLScrollArea.cpp -> sview-20_08.tar.gz/StGLWidgets/StGLScrollArea.cpp Changed

@@ -27,7 +27,8 @@
   myDragYCumul(0),
   myFlingAccel((double )myRoot->scale(200)),
   myFlingYSpeed(0.0),
-  myFlingYDone(0) {
+  myFlingYDone(0),
+  myScrollYAccum(0.0f) {
     //
 }
 
@@ -167,7 +168,7 @@
     }
 
     StGLBoxPx aScissorRect;
-    stglScissorRect(aScissorRect);
+    stglScissorRect2d(aScissorRect);
     aCtx.stglSetScissorRect(aScissorRect, true);
 
     StGLWidget::stglDraw(theView); // draw children
@@ -274,8 +275,12 @@
 
 bool StGLScrollArea::tryUnClick(const StClickEvent& theEvent,
                                 bool&               theIsItemUnclicked) {
+    bool toCancel = false;
     if(myIsLeftClick
     && theEvent.Button == ST_MOUSE_LEFT) {
+        if(myHasDragged) {
+            toCancel = true;
+        }
         myIsLeftClick = false;
         myHasDragged  = false;
         if(myDragTimer.isOn()) {
@@ -290,6 +295,11 @@
             }
         }
     }
+    if(toCancel) {
+        StClickEvent anEvent = theEvent;
+        anEvent.Type = stEvent_MouseCancel;
+        return StGLWidget::tryUnClick(anEvent, theIsItemUnclicked);
+    }
     return StGLWidget::tryUnClick(theEvent, theIsItemUnclicked);
 }
 
@@ -298,11 +308,12 @@
         return true;
     }
 
-    int aDeltaY = (int )fabs(theEvent.DeltaY * 2.0f);
-    if(theEvent.DeltaY > 0.001f) {
-        doScroll( myRoot->scale(aDeltaY));
-    } else if(theEvent.DeltaY < -0.001f) {
-        doScroll(-myRoot->scale(aDeltaY));
+    myScrollYAccum += theEvent.DeltaY * 20.0f;
+    const int aDeltaY = (int )myScrollYAccum;
+    if(aDeltaY != 0) {
+        myScrollYAccum -= float(aDeltaY);
+        const int aDeltaScaled = myRoot->scale(std::abs(aDeltaY));
+        doScroll(aDeltaY > 0 ? aDeltaScaled : -aDeltaScaled);
     }
     return true;
 }

sview-17_04.tar.gz/StGLWidgets/StGLSeekBar.cpp -> sview-20_08.tar.gz/StGLWidgets/StGLSeekBar.cpp Changed

@@ -233,13 +233,29 @@
         return;
     }
 
-    const double aPos   = stMin(stMax(getPointInEx(theCursor), 0.0), 1.0);
-    const int    aPosPx = int(aPos * double(getRectPx().width()));
-
+    const int aRoundTol = myRoot->scale(1);
+    const int aMaxPosPx = getRectPx().width();
+    double aPos   = stMin(stMax(getPointInEx(theCursor), 0.0), 1.0);
+    int    aPosPx = int(aPos * double(aMaxPosPx));
     const int aMoveTolerPx = myMoveTolerPx > 0 ? myMoveTolerPx : myRoot->scale(theIsPreciseInput ? 1 : 2);
-    if(myClickPos >= 0
-    && std::abs(aPosPx - myClickPos) < aMoveTolerPx) {
-        return;
+    if(std::abs(aPosPx - 0) <= aRoundTol) {
+        aPos   = 0.0;
+        aPosPx = 0;
+    } else if(std::abs(aPosPx - aMaxPosPx) <= aRoundTol) {
+        aPos   = 1.0;
+        aPosPx = aMaxPosPx;
+    }
+
+    if(myClickPos >= 0) {
+        if(myClickPos == aPosPx) {
+            return;
+        }
+
+        if(aPosPx != 0
+        && aPosPx != aMaxPosPx
+        && std::abs(aPosPx - myClickPos) < aMoveTolerPx) {
+            return;
+        }
     }
 
     myClickPos = aPosPx;
@@ -260,9 +276,18 @@
 }
 
 void StGLSeekBar::doMouseUnclick(const int mouseBtn) {
-    const double aPos       = stMin(stMax(getPointInEx(myRoot->getCursorZo()), 0.0), 1.0);
-    const int    aTolerance = myRoot->scale(1);
-    const int    aPosPx     = int(aPos * double(getRectPx().width()));
+    const int aTolerance = myRoot->scale(1);
+    const int aMaxPosPx  = getRectPx().width();
+    double aPos   = stMin(stMax(getPointInEx(myRoot->getCursorZo()), 0.0), 1.0);
+    int    aPosPx = int(aPos * double(aMaxPosPx));
+    if(std::abs(aPosPx - 0) <= aTolerance) {
+        aPos   = 0.0;
+        aPosPx = 0;
+    } else if(std::abs(aPosPx - aMaxPosPx) <= aTolerance) {
+        aPos   = 1.0;
+        aPosPx = aMaxPosPx;
+    }
+
     if(myClickPos >= 0
     && std::abs(aPosPx - myClickPos) < aTolerance) {
         myClickPos = -1;

sview-17_04.tar.gz/StGLWidgets/StGLSubtitles.cpp -> sview-20_08.tar.gz/StGLWidgets/StGLSubtitles.cpp Changed

@@ -1,6 +1,6 @@
 /**
  * StGLWidgets, small C++ toolkit for writing GUI using OpenGL.
- * Copyright © 2010-2015 Kirill Gavrilov <kirill@sview.ru>
+ * Copyright © 2010-2020 Kirill Gavrilov <kirill@sview.ru>
  *
  * Distributed under the Boost Software License, Version 1.0.
  * See accompanying file license-boost.txt or copy at
@@ -11,10 +11,12 @@
 
 #include <StGLCore/StGLCore20.h>
 #include <StGL/StGLProgram.h>
+#include <StGLWidgets/StGLImageRegion.h>
 #include <StGLWidgets/StGLRootWidget.h>
 
 namespace {
     static const size_t SHARE_IMAGE_PROGRAM_ID = StGLRootWidget::generateShareId();
+    static StGLVCorner parseCorner(int theVal) { return (StGLVCorner )theVal; }
 }
 
 class StGLSubtitles::StImgProgram : public StGLProgram {
@@ -87,7 +89,7 @@
 };
 
 StGLSubtitles::StSubShowItems::StSubShowItems()
-: StArrayList<StHandle <StSubItem> >(8) {
+: StArrayList<StHandle <StSubItem> >(8), Scale (1.0f) {
     //
 }
 
@@ -121,8 +123,10 @@
     const StImagePlane& anImage = getFirst()->Image;
     if(!anImage.isNull()) {
         Image.initCopy(anImage, false);
+        Scale = getFirst()->Scale;
     } else {
         Image.nullify();
+        Scale = 1.0f;
     }
 
     return isChanged;
@@ -137,36 +141,31 @@
     const StImagePlane& anImage = theItem->Image;
     if(!anImage.isNull()) {
         Image.initCopy(anImage, false);
+        Scale = theItem->Scale;
     }
 
     StArrayList<StHandle <StSubItem> >::add(theItem);
 }
 
-inline StGLVCorner parseCorner(int theVal) {
-    return (StGLVCorner )theVal;
-}
-
-StGLSubtitles::StGLSubtitles(StGLWidget*                     theParent,
+StGLSubtitles::StGLSubtitles(StGLImageRegion* theParent,
                              const StHandle<StSubQueue>&     theSubQueue,
                              const StHandle<StInt32Param>&   thePlace,
-                             const StHandle<StFloat32Param>& theTopDY,
-                             const StHandle<StFloat32Param>& theBottomDY,
-                             const StHandle<StFloat32Param>& theFontSize,
-                             const StHandle<StFloat32Param>& theParallax,
-                             const StHandle<StEnumParam>&    theParser)
+                             const StHandle<StFloat32Param>& theFontSize)
 : StGLTextArea(theParent,
                0, 0,
                StGLCorner(parseCorner(thePlace->getValue()), ST_HCORNER_CENTER),
                theParent->getRoot()->scale(800), theParent->getRoot()->scale(160)),
-  myPlace(thePlace),
-  myTopDY(theTopDY),
-  myBottomDY(theBottomDY),
-  myFontSize(theFontSize),
-  myParallax(theParallax),
-  myParser(theParser),
   myQueue(theSubQueue),
   myPTS(0.0),
   myImgProgram(getRoot()->getShare(SHARE_IMAGE_PROGRAM_ID)) {
+    params.Place    = thePlace;
+    params.FontSize = theFontSize;
+    params.TopDY    = new StFloat32Param(100.0f);
+    params.BottomDY = new StFloat32Param(100.0f);
+    params.Parallax = new StFloat32Param(0.0f);
+    params.Parser   = new StEnumParam(1, stCString("subsParser"));
+    params.ToApplyStereo = new StBoolParamNamed(true, stCString("subsApplyStereo"));
+
     if(myQueue.isNull()) {
         myQueue = new StSubQueue();
     }
@@ -180,7 +179,7 @@
 
     StHandle<StGLFont> aFontNew = new StGLFont();
     StHandle<StFTLibrary> aLib = getRoot()->getFontManager()->getLibraty();
-    const FontSize     aSize       = (FontSize )(int )myFontSize->getValue();
+    const FontSize     aSize       = (FontSize )(int )params.FontSize->getValue();
     const unsigned int aResolution = getRoot()->getFontManager()->getResolution();
     for(size_t anIter = 0; anIter < StFTFont::SubsetsNB; ++anIter) {
         StHandle<StGLFontEntry>& aFontGlSrc = myFont->changeFont((StFTFont::Subset )anIter);
@@ -190,7 +189,9 @@
 
         StHandle<StFTFont> aFontFt = new StFTFont(aLib);
         for(int aStyleIt = 0; aStyleIt < StFTFont::StylesNB; ++aStyleIt) {
-            aFontFt->load(aFontGlSrc->getFont()->getFilePath((StFTFont::Style )aStyleIt), (StFTFont::Style )aStyleIt);
+            aFontFt->load(aFontGlSrc->getFont()->getFilePath((StFTFont::Style )aStyleIt),
+                          aFontGlSrc->getFont()->getFaceIndex((StFTFont::Style )aStyleIt),
+                          (StFTFont::Style )aStyleIt);
         }
         aFontFt->init(aSize, aResolution);
         aFontNew->changeFont((StFTFont::Subset )anIter) = new StGLFontEntry(aFontFt);
@@ -211,15 +212,10 @@
 bool StGLSubtitles::stglInit() {
     if(!myVertBuf.isValid()) {
         StArray<StGLVec2> aDummyVert(4);
-        StArray<StGLVec2> aTexCoords(4);
-        aTexCoords[0] = StGLVec2(1.0f, 0.0f);
-        aTexCoords[1] = StGLVec2(1.0f, 1.0f);
-        aTexCoords[2] = StGLVec2(0.0f, 0.0f);
-        aTexCoords[3] = StGLVec2(0.0f, 1.0f);
 
         StGLContext& aCtx = getContext();
         myVertBuf.init(aCtx, aDummyVert);
-        myTCrdBuf.init(aCtx, aTexCoords);
+        myTCrdBuf.init(aCtx, aDummyVert);
 
         if(myImgProgram.isNull()) {
             myImgProgram.create(getRoot()->getContextHandle(), new StImgProgram());
@@ -237,12 +233,12 @@
         myShowItems.add(aNewSubItem);
     }
 
-    const StGLVCorner aCorner = parseCorner(myPlace->getValue());
+    const StGLVCorner aCorner = parseCorner(params.Place->getValue());
     bool toResize = myCorner.v != aCorner;
     myCorner.v = aCorner;
     switch(myCorner.v) {
         case ST_VCORNER_TOP: {
-            const int aDisp = myRoot->scale((int )myTopDY->getValue()) + myRoot->getRootMargins().top;
+            const int aDisp = myRoot->scale((int )params.TopDY->getValue()) + myRoot->getRootMargins().top;
             if(getRectPx().top() != aDisp) {
                 toResize = true;
                 changeRectPx().moveTopTo(aDisp);
@@ -261,7 +257,7 @@
             break;
         }
         case ST_VCORNER_BOTTOM: {
-            const int aDisp = -myRoot->scale((int )myBottomDY->getValue()) - myRoot->getRootMargins().bottom;
+            const int aDisp = -myRoot->scale((int )params.BottomDY->getValue()) - myRoot->getRootMargins().bottom;
             if(getRectPx().top() != aDisp) {
                 toResize = true;
                 changeRectPx().moveTopTo(aDisp);
@@ -292,7 +288,7 @@
         ST_DEBUG_LOG("(" + myPTS + ") myShowItems.myText= '" + myShowItems.myText + "'\n" + aLog);*/
     }
 
-    const FontSize aNewSize = (FontSize )(int )myFontSize->getValue();
+    const FontSize aNewSize = (FontSize )(int )params.FontSize->getValue();
     if(!myText.isEmpty()
     && aNewSize != mySize) {
         mySize = aNewSize;
@@ -308,8 +304,8 @@
     }
 
     StGLContext& aCtx = getContext();
-    if(myFormatter.getParser() != (StGLTextFormatter::Parser )myParser->getValue()) {
-        myFormatter.setupParser((StGLTextFormatter::Parser )myParser->getValue());
+    if(myFormatter.getParser() != (StGLTextFormatter::Parser )params.Parser->getValue()) {
+        myFormatter.setupParser((StGLTextFormatter::Parser )params.Parser->getValue());
         myToRecompute = true;
     }
     if(!myText.isEmpty()) {
@@ -317,10 +313,10 @@
 
         switch(theView) {
             case ST_DRAW_LEFT:
-                myTextDX = -myParallax->getValue() * GLfloat(0.5 * 0.001 * myRoot->getRootRectGl().width());
+                myTextDX = -params.Parallax->getValue() * GLfloat(0.5 * 0.001 * myRoot->getRootRectGl().width());
                 break;
             case ST_DRAW_RIGHT:
-                myTextDX =  myParallax->getValue() * GLfloat(0.5 * 0.001 * myRoot->getRootRectGl().width());
+                myTextDX =  params.Parallax->getValue() * GLfloat(0.5 * 0.001 * myRoot->getRootRectGl().width());
                 break;
             case ST_DRAW_MONO:
             default:
@@ -335,20 +331,120 @@
         return;
     }
 
-    aCtx.core20fwd->glBlendFunc(GL_SRC_ALPHA, GL_ONE_MINUS_SRC_ALPHA);
-    aCtx.core20fwd->glEnable(GL_BLEND);
-    myTexture.bind(aCtx);
+    StHandle<StStereoParams> aParams;
+    StFormat aStFormat = StFormat_Mono;
+    unsigned int aView = theView;
+    float aSampleRatio = 1.0f;
+    StVec2<int> aFrameDims(0, 0);
+    if(StGLImageRegion* anImgRegion = !params.ToApplyStereo.isNull() && params.ToApplyStereo->getValue()
+                                    ? dynamic_cast<StGLImageRegion*>(myParent)
+                                    : NULL) {
+        aParams = anImgRegion->getSource();
+        if(!aParams.isNull()) {
+            aStFormat = aParams->StereoFormat;
+            aSampleRatio = anImgRegion->getSampleRatio();
+            aFrameDims   = anImgRegion->getFrameSize();
+            if(aParams->ToSwapLR) {
+                // apply swap flag
+                switch(aStFormat) {
+                    case StFormat_SideBySide_LR: aStFormat = StFormat_SideBySide_RL; break;
+                    case StFormat_SideBySide_RL: aStFormat = StFormat_SideBySide_LR; break;
+                    case StFormat_TopBottom_LR:  aStFormat = StFormat_TopBottom_RL;  break;
+                    case StFormat_TopBottom_RL:  aStFormat = StFormat_TopBottom_LR;  break;
+                    default: break;
+                }
+            }
+            // swap views
+            if(aStFormat == StFormat_SideBySide_RL) {
+                aStFormat = StFormat_SideBySide_LR;
+                if(theView == ST_DRAW_RIGHT) {
+                    aView = ST_DRAW_LEFT;
+                } else if(theView == ST_DRAW_LEFT) {
+                    aView = ST_DRAW_RIGHT;
+                }
+            } else if(aStFormat == StFormat_TopBottom_RL) {
+                aStFormat = StFormat_TopBottom_LR;
+                if(theView == ST_DRAW_RIGHT) {
+                    aView = ST_DRAW_LEFT;
+                } else if(theView == ST_DRAW_LEFT) {
+                    aView = ST_DRAW_RIGHT;
+                }
+            }
+            // reset
+            if(aStFormat != StFormat_SideBySide_LR
+            && aStFormat != StFormat_TopBottom_LR) {
+                aSampleRatio = 1.0f;
+            }
+        }
+    }
 
     // update vertices
-    StRectI_t aRect = getRectPxAbsolute();
-    aRect.top()   = aRect.bottom() - myTexture.getSizeY();
-    aRect.left()  = aRect.left() + aRect.width() / 2 - myTexture.getSizeX() / 2;
-    aRect.right() = aRect.left() + myTexture.getSizeX();
+    StVec2<int> anImgSize (myTexture.getSizeX(), myTexture.getSizeY()), anOffset (0, 0);
+    StArray<StGLVec2> aVertices(4), aTexCoords(4);
+    aTexCoords[0] = StGLVec2(1.0f, 0.0f);
+    aTexCoords[1] = StGLVec2(1.0f, 1.0f);
+    aTexCoords[2] = StGLVec2(0.0f, 0.0f);
+    aTexCoords[3] = StGLVec2(0.0f, 1.0f);
+    if(aSampleRatio >= 1.0f) {
+        anImgSize.x() = int(double(anImgSize.x()) * aSampleRatio);
+    } else {
+        anImgSize.y() = int(double(anImgSize.y()) / aSampleRatio);
+    }
+    const double aFontScale = double(getRoot()->getScale()) * myShowItems.Scale * params.FontSize->getValue() / params.FontSize->getDefValue();
+    anImgSize.x() = int(double(anImgSize.x()) * aFontScale);
+    anImgSize.y() = int(double(anImgSize.y()) * aFontScale);
+
+    switch(aStFormat) {
+        case StFormat_SideBySide_LR: {
+            anImgSize.x() /= 2;
+            const int anOffsetX = int(aFontScale * ((aFrameDims.x() * 2 - myTexture.getSizeX()) / 2));
+            if(aView == ST_DRAW_LEFT) {
+                aTexCoords[0].x() = aTexCoords[1].x() = 0.5f;
+                aTexCoords[2].x() = aTexCoords[3].x() = 0.0f;
+                anOffset.x() = anOffsetX;
+            } else if(aView == ST_DRAW_RIGHT) {
+                aTexCoords[0].x() = aTexCoords[1].x() = 1.0f;
+                aTexCoords[2].x() = aTexCoords[3].x() = 0.5f;
+                anOffset.x() = -anOffsetX;
+            }
+            break;
+        }
+        case StFormat_TopBottom_LR: {
+            anImgSize.y() /= 2;
+            const int anOffsetY = int(aFontScale * ((aFrameDims.y() * 2 - myTexture.getSizeY()) / 2));
+            if(aView == ST_DRAW_LEFT) {
+                aTexCoords[0].y() = aTexCoords[2].y() = 0.0f;
+                aTexCoords[1].y() = aTexCoords[3].y() = 0.5f;
+                anOffset.y() = -anOffsetY;
+            } else if(aView == ST_DRAW_RIGHT) {
+                aTexCoords[0].y() = aTexCoords[2].y() = 0.5f;
+                aTexCoords[1].y() = aTexCoords[3].y() = 1.0f;
+                anOffset.y() = anOffsetY;
+            }
+            break;
+        }
+        default: {
+            break;
+        }
+    }
+    if(aView == ST_DRAW_LEFT) {
+        anOffset.x() -= (int )params.Parallax->getValue();
+    } else if(aView == ST_DRAW_RIGHT) {
+        anOffset.x() += (int )params.Parallax->getValue();
+    }
 
-    StArray<StGLVec2> aVertices(4);
+    StRectI_t aRect = getRectPxAbsolute();
+    aRect.bottom() += anOffset.y();
+    aRect.top()   = aRect.bottom() - anImgSize.y();
+    aRect.left()  = aRect.left() + aRect.width() / 2 - anImgSize.x() / 2 + anOffset.x();
+    aRect.right() = aRect.left() + anImgSize.x();
     myRoot->getRectGl(aRect, aVertices);
     myVertBuf.init(aCtx, aVertices);
+    myTCrdBuf.init(aCtx, aTexCoords);
 
+    aCtx.core20fwd->glBlendFunc(GL_SRC_ALPHA, GL_ONE_MINUS_SRC_ALPHA);
+    aCtx.core20fwd->glEnable(GL_BLEND);
+    myTexture.bind(aCtx);
     myImgProgram->use(aCtx);
 
     myVertBuf.bindVertexAttrib(aCtx, myImgProgram->getVVertexLoc());

sview-17_04.tar.gz/StGLWidgets/StGLTable.cpp -> sview-20_08.tar.gz/StGLWidgets/StGLTable.cpp Changed

@@ -1,6 +1,6 @@
 /**
  * StGLWidgets, small C++ toolkit for writing GUI using OpenGL.
- * Copyright © 2014-2015 Kirill Gavrilov <kirill@sview.ru>
+ * Copyright © 2014-2017 Kirill Gavrilov <kirill@sview.ru>
  *
  * Distributed under the Boost Software License, Version 1.0.
  * See accompanying file license-boost.txt or copy at
@@ -12,6 +12,7 @@
 #include <StGLWidgets/StGLCombobox.h>
 #include <StGLWidgets/StGLCheckbox.h>
 #include <StGLWidgets/StGLMenuItem.h>
+#include <StGLWidgets/StGLRangeFieldFloat32.h>
 #include <StGLWidgets/StGLRootWidget.h>
 
 #include <StGL/StGLContext.h>
@@ -19,6 +20,7 @@
 
 #include <StStrings/StDictionary.h>
 #include <StSettings/StEnumParam.h>
+#include <StSettings/StFloat32Param.h>
 
 #include <stAssert.h>
 
@@ -165,6 +167,7 @@
     int aCol2Width = 0;
     StHandle<StBoolParamNamed> aBool;
     StHandle<StEnumParam>      anEnum;
+    StHandle<StFloat32Param>   aFloat32;
     const int anIconMargin = myRoot->scale(8);
     const int anIconWidth  = anIconMargin * 2 + myRoot->scale(16);
     StMarginsI aCheckMargins;
@@ -194,6 +197,18 @@
             for(size_t aValIter = 0; aValIter < aValues.size(); ++aValIter) {
                 aCol2Width = stMax(aCol2Width, aButton->computeWidth(aValues[aValIter]));
             }
+        } else if(aFloat32.downcastFrom(aParam)) {
+            StGLRangeFieldFloat32* aRange = new StGLRangeFieldFloat32(&anItem, aFloat32,
+                                                                      0, 0, StGLCorner(ST_VCORNER_CENTER, ST_HCORNER_RIGHT),
+                                                                      StGLRangeFieldFloat32::RangeStyle_Seekbar, myRoot->scale(18));
+            aRange->changeRectPx().right() = myRoot->scale(50);
+            aRange->changeMargins().left   = myRoot->scale(8);
+            aRange->changeMargins().right  = myRoot->scale(8);
+            aRange->setCorner(StGLCorner(ST_VCORNER_TOP, ST_HCORNER_LEFT));
+            if(!aFloat32->getFormat().isEmpty()) {
+                aRange->setFormat(aFloat32->getFormat());
+            }
+            aCol2Width = stMax(aCol2Width, aRange->getRectPx().width());
         } else {
             // skip
         }
@@ -209,10 +224,11 @@
             continue;
         }
 
-        StGLCombobox* aButton = dynamic_cast<StGLCombobox* >(anItem.getItem());
-        if(aButton != NULL) {
+        if(StGLCombobox* aButton = dynamic_cast<StGLCombobox* >(anItem.getItem())) {
             anItem.getItem()->changeRectPx().right() = aWidget->getRectPx().left() + aCol2Width;
             aButton->setWidth(aCol2Width);
+        } else if(dynamic_cast<StGLRangeFieldFloat32* >(anItem.getItem()) != NULL) {
+            anItem.getItem()->changeRectPx().right() = aWidget->getRectPx().left() + aCol2Width;
         }
     }
 
@@ -229,6 +245,8 @@
             aLabelText = aBool->getName();
         } else if(anEnum.downcastFrom(aParam)) {
             aLabelText = anEnum->getName();
+        } else if(aFloat32.downcastFrom(aParam)) {
+            aLabelText = aFloat32->getName();
         } else {
             // skip
         }

sview-17_04.tar.gz/StGLWidgets/StGLTextArea.cpp -> sview-20_08.tar.gz/StGLWidgets/StGLTextArea.cpp Changed

@@ -1,6 +1,6 @@
 /**
  * StGLWidgets, small C++ toolkit for writing GUI using OpenGL.
- * Copyright © 2009-2017 Kirill Gavrilov <kirill@sview.ru>
+ * Copyright © 2009-2020 Kirill Gavrilov <kirill@sview.ru>
  *
  * Distributed under the Boost Software License, Version 1.0.
  * See accompanying file license-boost.txt or copy at
@@ -273,15 +273,8 @@
     StRectD_t aTextRectGl = getRoot()->getRectGl(getAbsolute(aTextRectPx));
 
     // size corrector for FTGL
-    StRectD_t zparams; getCamera()->getZParams(zparams);
-    GLfloat aSizeOut = 2.0f * GLfloat(zparams.top()) / GLfloat(getRoot()->getRootFullSizeY());
-
-    StGLMatrix aModelMat;
-    aModelMat.translate(StGLVec3(getRoot()->getScreenDispX() + myTextDX, 0.0f, -getCamera()->getZScreen()));
-    aModelMat.translate(StGLVec3(GLfloat(aTextRectGl.left()),
-                                 GLfloat(aTextRectGl.top()),
-                                 0.0f));
-    aModelMat.scale(aSizeOut, aSizeOut, 0.0f);
+    StRectD_t aZParams; getCamera()->getZParams(aZParams);
+    const GLfloat aSizeOut = 2.0f * GLfloat(aZParams.top()) / GLfloat(getRoot()->getRootFullSizeY());
 
     aCtx.core20fwd->glBlendFunc(GL_SRC_ALPHA, GL_ONE_MINUS_SRC_ALPHA);
     aCtx.core20fwd->glEnable(GL_BLEND);
@@ -294,7 +287,10 @@
 
         StGLTextBorderProgram& aBorderProgram = myRoot->getTextBorderProgram();
         aBorderProgram.use(aCtx);
-        aBorderProgram.setModelMat(aCtx, aModelMat);
+        aBorderProgram.setDisplacement(aCtx,
+                                       StGLVec3(GLfloat(aTextRectGl.left()) + getRoot()->getScreenDispX() + myTextDX,
+                                                GLfloat(aTextRectGl.top()), 0.0f),
+                                       aSizeOut);
 
         aBorderProgram.setColor(aCtx, myBorderColor);
         myBorderOVertBuf.bindVertexAttrib(aCtx, aBorderProgram.getVVertexLoc());
@@ -312,23 +308,22 @@
     aCtx.core20fwd->glActiveTexture(GL_TEXTURE0); // our shader is bound to first texture unit
     StGLTextProgram& aTextProgram = myRoot->getTextProgram();
     aTextProgram.use(aCtx);
-        aTextProgram.setModelMat(aCtx, aModelMat);
+        aTextProgram.setDisplacement(aCtx,
+                                     StGLVec3(GLfloat(aTextRectGl.left()) + getRoot()->getScreenDispX() + myTextDX,
+                                              GLfloat(aTextRectGl.top()), 0.0f),
+                                     aSizeOut);
         aTextProgram.setColor(aCtx, myToDrawShadow ? myShadowColor : aTextColor);
-
         drawText(aCtx);
 
         if(myToDrawShadow) {
-            aModelMat.initIdentity();
             aTextRectPx.left() -= 1;
             aTextRectPx.top()  -= 1;
             aTextRectGl = getRoot()->getRectGl(getAbsolute(aTextRectPx));
-            aModelMat.translate(StGLVec3(getRoot()->getScreenDispX() + myTextDX, 0.0f, -getCamera()->getZScreen()));
-            aModelMat.translate(StGLVec3(GLfloat(aTextRectGl.left()),
-                                         GLfloat(aTextRectGl.top()),
-                                         0.0f));
-            aModelMat.scale(aSizeOut, aSizeOut, 0.0f);
 
-            aTextProgram.setModelMat(aCtx, aModelMat);
+            aTextProgram.setDisplacement(aCtx,
+                                         StGLVec3(GLfloat(aTextRectGl.left()) + getRoot()->getScreenDispX() + myTextDX,
+                                                  GLfloat(aTextRectGl.top()), 0.0f),
+                                         aSizeOut);
             aTextProgram.setColor(aCtx, aTextColor);
 
             drawText(aCtx);

sview-17_04.tar.gz/StGLWidgets/StGLTextBorderProgram.cpp -> sview-20_08.tar.gz/StGLWidgets/StGLTextBorderProgram.cpp Changed

@@ -1,6 +1,6 @@
 /**
  * StGLWidgets, small C++ toolkit for writing GUI using OpenGL.
- * Copyright © 2009-2015 Kirill Gavrilov <kirill@sview.ru>
+ * Copyright © 2009-2020 Kirill Gavrilov <kirill@sview.ru>
  *
  * Distributed under the Boost Software License, Version 1.0.
  * See accompanying file license-boost.txt or copy at
@@ -27,9 +27,10 @@
     theCtx.core20fwd->glUniformMatrix4fv(myUniformProjMat, 1, GL_FALSE, theProjMat);
 }
 
-void StGLTextBorderProgram::setModelMat(StGLContext&      theCtx,
-                                        const StGLMatrix& theModelMat) {
-    theCtx.core20fwd->glUniformMatrix4fv(myUniformModelMat, 1, GL_FALSE, theModelMat);
+void StGLTextBorderProgram::setDisplacement(StGLContext& theCtx,
+                                            const StGLVec3& theDisp,
+                                            const float theScale) {
+    theCtx.core20fwd->glUniform4fv(myUniformDispl, 1, StGLVec4(theDisp, theScale));
 }
 
 void StGLTextBorderProgram::setColor(StGLContext&    theCtx,
@@ -40,10 +41,10 @@
 bool StGLTextBorderProgram::init(StGLContext& theCtx) {
     const char VERTEX_SHADER[] =
        "uniform mat4 uProjMat; \
-        uniform mat4 uModelMat; \
+        uniform vec4 uDisp; \
         attribute vec4 vVertex; \
         void main(void) { \
-            gl_Position = uProjMat * uModelMat * vVertex; \
+            gl_Position = uProjMat * (vec4(vVertex.xy * uDisp.w, 0.0, 1.0) + vec4(uDisp.xyz, 0.0)); \
         }";
 
     const char FRAGMENT_SHADER[] =
@@ -68,9 +69,9 @@
     }
 
     myUniformProjMat  = StGLProgram::getUniformLocation(theCtx, "uProjMat");
-    myUniformModelMat = StGLProgram::getUniformLocation(theCtx, "uModelMat");
+    myUniformDispl    = StGLProgram::getUniformLocation(theCtx, "uDisp");
     myUniformColor    = StGLProgram::getUniformLocation(theCtx, "uColor");
     return myUniformProjMat.isValid()
-        && myUniformModelMat.isValid()
+        && myUniformDispl.isValid()
         && myUniformColor.isValid();
 }

sview-17_04.tar.gz/StGLWidgets/StGLTextProgram.cpp -> sview-20_08.tar.gz/StGLWidgets/StGLTextProgram.cpp Changed

@@ -1,6 +1,6 @@
 /**
  * StGLWidgets, small C++ toolkit for writing GUI using OpenGL.
- * Copyright © 2009-2015 Kirill Gavrilov <kirill@sview.ru>
+ * Copyright © 2009-2020 Kirill Gavrilov <kirill@sview.ru>
  *
  * Distributed under the Boost Software License, Version 1.0.
  * See accompanying file license-boost.txt or copy at
@@ -27,9 +27,10 @@
     theCtx.core20fwd->glUniformMatrix4fv(myUniformProjMat, 1, GL_FALSE, theProjMat);
 }
 
-void StGLTextProgram::setModelMat(StGLContext&      theCtx,
-                                  const StGLMatrix& theModelMat) {
-    theCtx.core20fwd->glUniformMatrix4fv(myUniformModelMat, 1, GL_FALSE, theModelMat);
+void StGLTextProgram::setDisplacement(StGLContext& theCtx,
+                                      const StGLVec3& theDisp,
+                                      const float theScale) {
+    theCtx.core20fwd->glUniform4fv(myUniformDispl, 1, StGLVec4(theDisp, theScale));
 }
 
 void StGLTextProgram::setColor(StGLContext&    theCtx,
@@ -40,13 +41,13 @@
 bool StGLTextProgram::init(StGLContext& theCtx) {
     const char VERTEX_SHADER[] =
        "uniform mat4 uProjMat; \
-        uniform mat4 uModelMat; \
+        uniform vec4 uDisp; \
         attribute vec4 vVertex; \
         attribute vec2 vTexCoord; \
         varying vec2 fTexCoord; \
         void main(void) { \
             fTexCoord = vTexCoord; \
-            gl_Position = uProjMat * uModelMat * vVertex; \
+            gl_Position = uProjMat * (vec4(vVertex.xy * uDisp.w, 0.0, 1.0) + vec4(uDisp.xyz, 0.0)); \
         }";
 
     const char FRAGMENT_GET_RED[] =
@@ -84,7 +85,7 @@
     }
 
     myUniformProjMat  = StGLProgram::getUniformLocation(theCtx, "uProjMat");
-    myUniformModelMat = StGLProgram::getUniformLocation(theCtx, "uModelMat");
+    myUniformDispl    = StGLProgram::getUniformLocation(theCtx, "uDisp");
     myUniformColor    = StGLProgram::getUniformLocation(theCtx, "uTextColor");
 
     StGLVarLocation aUniformTexture = StGLProgram::getUniformLocation(theCtx, "uTexture");
@@ -95,7 +96,7 @@
     }
 
     return myUniformProjMat.isValid()
-        && myUniformModelMat.isValid()
+        && myUniformDispl.isValid()
         && myUniformColor.isValid()
         && aUniformTexture.isValid();
 }

sview-17_04.tar.gz/StGLWidgets/StGLTextureButton.cpp -> sview-20_08.tar.gz/StGLWidgets/StGLTextureButton.cpp Changed

@@ -222,26 +222,20 @@
      * Initialize all programs.
      */
     bool init(StGLContext& theCtx) {
-        /**const char FRAGMENT_GET_RED[] =
+        const char* FRAGMENT_GET_ALPHA = theCtx.arbTexRG
+                                       ? "#define stTextureAlpha(theSampler, theCoords) texture2D(theSampler, theCoords).r\n"
+                                       : "#define stTextureAlpha(theSampler, theCoords) texture2D(theSampler, theCoords).a\n";
+        const char FRAGMENT_GET_COLOR[] =
             "uniform sampler2D uTexture;\n"
             "uniform vec4      uColor;\n"
             "vec4 getColor(in vec2 theTexCoord) {\n"
             "     vec4 aColor = uColor;\n"
-            "     aColor.a *= 1.0 - texture2D(uTexture, theTexCoord).r;\n"
-            "     return aColor;\n"
-            "}\n\n";*/
-
-        const char FRAGMENT_GET_ALPHA[] =
-            "uniform sampler2D uTexture;\n"
-            "uniform vec4      uColor;\n"
-            "vec4 getColor(in vec2 theTexCoord) {\n"
-            "     vec4 aColor = uColor;\n"
-            "     aColor.a *= 1.0 - texture2D(uTexture, theTexCoord).a;\n"
+            "     aColor.a *= 1.0 - stTextureAlpha(uTexture, theTexCoord);\n"
             "     return aColor;\n"
             "}\n\n";
+
         registerFragmentShaderPart(FragSection_GetColor, FragGetColor_Alpha,
-                                   ///theCtx.arbTexRG ? FRAGMENT_GET_RED :
-                                     FRAGMENT_GET_ALPHA);
+                                   StString(FRAGMENT_GET_ALPHA) + FRAGMENT_GET_COLOR);
 
         setFragmentShaderPart(theCtx, FragSection_GetColor, FragGetColor_RGB);
         if(!initProgram(theCtx)) {
@@ -311,6 +305,16 @@
 
 void StGLTextureButton::setTexturePath(const StString* theTexturesPaths,
                                        const size_t    theCount) {
+    if(myTextures.isNull()) {
+        if(theCount != 0) {
+            myTextures = new StGLTextureArray(theCount);
+        } else {
+        #ifdef ST_DEBUG
+            ST_DEBUG_LOG_AT("WARNING, Attempt to set an empty list of textures to StGLTextureButton!");
+        #endif
+            return;
+        }
+    }
     const size_t aNbTextures = (theCount > myTextures->size()) ? myTextures->size() : theCount;
 #ifdef ST_DEBUG
     if(theCount != myTextures->size()) {
@@ -369,6 +373,10 @@
 }
 
 bool StGLTextureButton::stglInit() {
+    if(myTextures.isNull()) {
+        return false;
+    }
+
     StGLContext& aCtx = getContext();
     const StHandle<StResourceManager>& aResMgr = getRoot()->getResourceManager();
     for(size_t aFaceIter = 0; aFaceIter < myTextures->size(); ++aFaceIter) {
@@ -403,7 +411,7 @@
         }
 
         GLint anInternalFormat = GL_RGB;
-        if(!StGLTexture::getInternalFormat(aCtx, anImage.getPlane(), anInternalFormat)) {
+        if(!StGLTexture::getInternalFormat(aCtx, anImage.getPlane().getFormat(), anInternalFormat)) {
             ST_ERROR_LOG("StGLTextureButton, texture '" + aTexture.getName() + "' has unsupported format!");
             continue;
         }

sview-17_04.tar.gz/StGLWidgets/StGLWidget.cpp -> sview-20_08.tar.gz/StGLWidgets/StGLWidget.cpp Changed

sview-17_04.tar.gz/StGLWidgets/StGLWidgets.rc -> sview-20_08.tar.gz/StGLWidgets/StGLWidgets.rc Changed

sview-17_04.tar.gz/StImageViewer/StImageLoader.cpp -> sview-20_08.tar.gz/StImageViewer/StImageLoader.cpp Changed

@@ -1,5 +1,5 @@
 /**
- * Copyright © 2007-2017 Kirill Gavrilov <kirill@sview.ru>
+ * Copyright © 2007-2019 Kirill Gavrilov <kirill@sview.ru>
  *
  * StImageViewer program is free software: you can redistribute it and/or modify
  * it under the terms of the GNU General Public License as published by
@@ -21,12 +21,15 @@
 #include "StImageViewerStrings.h"
 #include "StImageViewerGUI.h"
 
+#include "../StMoviePlayer/StMoviePlayerInfo.h"
+
 #include <StAV/StAVImage.h>
 #include <StThreads/StThread.h>
 
 using namespace StImageViewerStrings;
 
 const char* StImageLoader::ST_IMAGES_MIME_STRING = ST_IMAGE_PLUGIN_MIME_CHAR;
+const char* StImageLoader::ST_VIDEOS_MIME_STRING = ST_VIDEO_PLUGIN_MIME_CHAR;
 
 namespace {
 
@@ -54,6 +57,7 @@
                              const StHandle<StGLTextureQueue>&  theTextureQueue,
                              const GLint                        theMaxTexDim)
 : myMimeList(ST_IMAGES_MIME_STRING),
+  myVideoMimeList(ST_VIDEOS_MIME_STRING),
   myResMgr(theResMgr),
   myLangMap(theLangMap),
   myPlayList(thePlayList),
@@ -64,9 +68,11 @@
   myMsgQueue(theMsgQueue),
   myImageLib(theImageLib),
   myAction(Action_NONE),
+  myIsTheaterMode(false),
   myToStickPano360(false),
   myToFlipCubeZ6x1(false),
-  myToFlipCubeZ3x2(false) {
+  myToFlipCubeZ3x2(false),
+  myToSwapJps(false) {
       myPlayList->setExtensions(myMimeList.getExtensionsList());
       myThread = new StThread(threadFunction, (void* )this, "StImageLoader");
 }
@@ -113,6 +119,7 @@
 }
 
 inline StHandle<StImage> scaledImage(StHandle<StImageFile>& theRef,
+                                     const StGLDeviceCaps&  theCaps,
                                      const size_t           theMaxSizeX,
                                      const size_t           theMaxSizeY,
                                      StCubemap              theCubemap,
@@ -122,7 +129,26 @@
         return theRef;
     }
 
-    if(theCubemap == StCubemap_Packed) {
+    const bool toConvertRgb = !theCaps.isSupportedFormat(theRef->getPlane().getFormat());
+    StImagePlane::ImgFormat anRgbImgFormat = StImagePlane::ImgRGB;
+    if(toConvertRgb) {
+        switch(theRef->getColorModel()) {
+            case StImage::ImgColor_RGB:
+                anRgbImgFormat = StImagePlane::ImgRGB;
+                break;
+            case StImage::ImgColor_RGBA:
+                anRgbImgFormat = StImagePlane::ImgRGBA;
+                break;
+            case StImage::ImgColor_GRAY:
+                anRgbImgFormat = StImagePlane::ImgGray;
+                break;
+            default:
+                anRgbImgFormat = StImagePlane::ImgRGB;
+                break;
+        }
+    }
+
+    if(theCubemap == StCubemap_Packed) { // skip scaling for StCubemap_PackedEAC
         size_t aSizesY[4] = {};
         bool toResize = false;
         size_t aMulX = (thePairRatio == StPairRatio_HalfWidth)  ? 2 : 1;
@@ -136,26 +162,48 @@
                 toResize = true;
             }
         }
-        if(!toResize) {
+        if(!toResize && !toConvertRgb) {
             return theRef;
         }
 
         StHandle<StImage> anImage = new StImage();
-        anImage->setColorModel(theRef->getColorModel());
-        anImage->setColorScale(theRef->getColorScale());
+        if(toConvertRgb) {
+            anImage->setColorModelPacked(anRgbImgFormat);
+            anImage->setColorScale(StImage::ImgScale_Full);
+        } else {
+            anImage->setColorModel(theRef->getColorModel());
+            anImage->setColorScale(theRef->getColorScale());
+        }
 
         double aRatioX = double(aSizesY[0] * theCubeCoeffs[0] * aMulX) / double(theRef->getSizeX());
         double aRatioY = double(aSizesY[0] * theCubeCoeffs[1] * aMulY) / double(theRef->getSizeY());
         anImage->setPixelRatio(float(double(theRef->getPixelRatio()) * aRatioY / aRatioX));
         for(size_t aPlaneId = 0; aPlaneId < 4; ++aPlaneId) {
+            if(toConvertRgb) {
+                if(aPlaneId != 0) {
+                    continue;
+                }
+                if(!anImage->changePlane(0).initTrash(anRgbImgFormat,
+                                                      aSizesY[0] * theCubeCoeffs[0] * aMulX,
+                                                      aSizesY[0] * theCubeCoeffs[1] * aMulY)) {
+                    ST_ERROR_LOG("Scale failed!");
+                    return theRef;
+                }
+                continue;
+            }
+
             const StImagePlane& aFromPlane = theRef->getPlane(aPlaneId);
             if(aFromPlane.isNull()) {
                 continue;
             }
 
+            size_t aPlanesSizeX = aSizesY[aPlaneId] * theCubeCoeffs[0] * aMulX;
+            size_t aSizeRowBytes = aPlanesSizeX * aFromPlane.getSizePixelBytes();
+            aSizeRowBytes = aSizeRowBytes + (32 - aSizeRowBytes % 32);
             if(!anImage->changePlane(aPlaneId).initTrash(aFromPlane.getFormat(),
                                                          aSizesY[aPlaneId] * theCubeCoeffs[0] * aMulX,
-                                                         aSizesY[aPlaneId] * theCubeCoeffs[1] * aMulY)) {
+                                                         aSizesY[aPlaneId] * theCubeCoeffs[1] * aMulY,
+                                                         aSizeRowBytes)) {
                 ST_ERROR_LOG("Scale failed!");
                 return theRef;
             }
@@ -170,17 +218,28 @@
     }
 
     if(theRef->getSizeX() <= theMaxSizeX
-    && theRef->getSizeY() <= theMaxSizeY) {
+    && theRef->getSizeY() <= theMaxSizeY
+    && !toConvertRgb) {
         return theRef;
     }
 
     StHandle<StImage> anImage = new StImage();
     const size_t aSizeX = stMin(theRef->getSizeX(), theMaxSizeX);
     const size_t aSizeY = stMin(theRef->getSizeY(), theMaxSizeY);
-    if(!anImage->initTrashLimited(*theRef, aSizeX, aSizeY)
-    || !StAVImage::resize(*theRef, *anImage)) {
-        ST_ERROR_LOG("Scale failed!");
-        return theRef;
+    if(toConvertRgb) {
+        anImage->setColorModelPacked(anRgbImgFormat);
+        anImage->setColorScale(StImage::ImgScale_Full);
+        if(!anImage->changePlane().initTrash(anRgbImgFormat, aSizeX, aSizeY)
+        || !StAVImage::resize(*theRef, *anImage)) {
+            ST_ERROR_LOG("Scale failed!");
+            return theRef;
+        }
+    } else {
+        if(!anImage->initTrashLimited(*theRef, aSizeX, aSizeY)
+        || !StAVImage::resize(*theRef, *anImage)) {
+            ST_ERROR_LOG("Scale failed!");
+            return theRef;
+        }
     }
     theRef->close();
     return anImage;
@@ -238,6 +297,7 @@
 
     StTimer aLoadTimer(true);
     StFormat  aSrcFormatCurr = myStFormatByUser;
+    StPanorama aSrcPanorama = StPanorama_OFF;
     if(anImgType == StImageFile::ST_TYPE_MPO
     || anImgType == StImageFile::ST_TYPE_JPEG
     || anImgType == StImageFile::ST_TYPE_JPS) {
@@ -286,6 +346,10 @@
             StDictEntry& anEntry  = anImgInfo->Info.addChange("Jpeg.JpsComment");
             anEntry.changeValue() = aParser.getJpsComment();
         }
+        if(!aParser.getXMP().isEmpty()) {
+            StDictEntry& anEntry  = anImgInfo->Info.addChange("Jpeg.XMP");
+            anEntry.changeValue() = aParser.getXMP();
+        }
         if(!anImg1.isNull()) {
             for(size_t anExifId = 0; anExifId < anImg1->Exif.size(); ++anExifId) {
                 metadataFromExif(anImg1->Exif[anExifId], anImgInfo);
@@ -300,6 +364,7 @@
         && aParser.getSrcFormat() != StFormat_AUTO) {
             aSrcFormatCurr = aParser.getSrcFormat();
         }
+        aSrcPanorama = aParser.getPanorama();
 
         //aParser.fillDictionary(anImgInfo->Info, true);
         if(!isParsed) {
@@ -360,6 +425,7 @@
             return false;
         }
         aRawFileL.freeBuffer();
+        aSrcPanorama = anImageFileL->getPanoramaFormat();
 
         StRawFile aRawFileR;
         if(StFileNode::isContentProtocolPath(aFilePathRight)) {
@@ -381,6 +447,7 @@
             return false;
         }
 
+        aSrcPanorama = anImageFileL->getPanoramaFormat();
         anImgInfo->StInfoStream = anImageFileL->getFormat();
         if(myStFormatByUser == StFormat_AUTO) {
             aSrcFormatCurr = anImgInfo->StInfoStream;
@@ -396,7 +463,7 @@
 
     // detect information from file name
     bool isAnamorphByName = false;
-    anImgInfo->StInfoFileName = st::formatFromName(aTitleString, isAnamorphByName);
+    anImgInfo->StInfoFileName = st::formatFromName(aTitleString, myToSwapJps, isAnamorphByName);
     if(aSrcFormatCurr == StFormat_AUTO
     && anImgInfo->StInfoFileName != StFormat_AUTO) {
         aSrcFormatCurr = anImgInfo->StInfoFileName;
@@ -429,27 +496,59 @@
         aSrcFormatCurr = StFormat_SeparateFrames;
     }
 
+    if(aSrcPanorama != StPanorama_OFF) {
+        theParams->ViewingMode = StStereoParams::getViewSurfaceForPanoramaSource(aSrcPanorama, true);
+    }
+    if(myIsTheaterMode && theParams->ViewingMode == StViewSurface_Plain) {
+        theParams->ViewingMode = StViewSurface_Theater;
+    } else if(!myIsTheaterMode && theParams->ViewingMode == StViewSurface_Theater) {
+        theParams->ViewingMode = StViewSurface_Plain;
+    }
+
     if(myToStickPano360
     && theParams->ViewingMode == StViewSurface_Plain) {
         StPanorama aPano = st::probePanorama(aSrcFormatCurr,
                                              theParams->Src1SizeX, theParams->Src1SizeY,
                                              theParams->Src2SizeX, theParams->Src2SizeY);
-        theParams->ViewingMode = (aPano == StPanorama_Cubemap6_1 || aPano == StPanorama_Cubemap3_2)
-                               ? StViewSurface_Cubemap
-                               : StViewSurface_Sphere;
+        theParams->ViewingMode = StStereoParams::getViewSurfaceForPanoramaSource(aPano, true);
+    }
+    StCubemap aSrcCubemap = StCubemap_OFF;
+    if(theParams->ViewingMode == StViewSurface_Cubemap) {
+        aSrcCubemap = StCubemap_Packed;
+    } else if(theParams->ViewingMode == StViewSurface_CubemapEAC) {
+        aSrcCubemap = StCubemap_PackedEAC;
     }
-    StCubemap aSrcCubemap = theParams->ViewingMode == StViewSurface_Cubemap ? StCubemap_Packed : StCubemap_OFF;
 
     size_t aCubeCoeffs[2] = {0, 0};
-    if(aSrcCubemap == StCubemap_Packed) {
+    if(aSrcCubemap == StCubemap_Packed
+    || aSrcCubemap == StCubemap_PackedEAC) {
         if(aSizeX1 / 6 == aSizeY1) {
             aCubeCoeffs[0] = 6;
             aCubeCoeffs[1] = 1;
             theParams->ToFlipCubeZ = myToFlipCubeZ6x1;
+        } else if(aSizeY1 / 6 == aSizeX1) {
+            aCubeCoeffs[0] = 1;
+            aCubeCoeffs[1] = 6;
+            theParams->ToFlipCubeZ = myToFlipCubeZ6x1;
         } else if(aSizeX1 / 3 == aSizeY1 / 2) {
             aCubeCoeffs[0] = 3;
             aCubeCoeffs[1] = 2;
             theParams->ToFlipCubeZ = myToFlipCubeZ3x2;
+        } else if(aSizeX1 / 2 == aSizeY1 / 3) {
+            aCubeCoeffs[0] = 2;
+            aCubeCoeffs[1] = 3;
+            theParams->ToFlipCubeZ = myToFlipCubeZ3x2;
+        } else if(aSrcCubemap == StCubemap_PackedEAC) {
+            // EAC on ytb is so cruel, that they don't use squared cube sides!
+            if(aSizeX1 > aSizeY1) {
+                aCubeCoeffs[0] = 3;
+                aCubeCoeffs[1] = 2;
+                theParams->ToFlipCubeZ = myToFlipCubeZ3x2;
+            } else {
+                aCubeCoeffs[0] = 2;
+                aCubeCoeffs[1] = 3;
+                theParams->ToFlipCubeZ = myToFlipCubeZ3x2;
+            }
         }
         if(!anImageFileR->isNull()
         && (aSizeX1 != aSizeX2 || aSizeY1 != aSizeY2)) {
@@ -466,8 +565,10 @@
         }
     }
 
-    StHandle<StImage> anImageL = scaledImage(anImageFileL, aSizeXLim, aSizeYLim, aSrcCubemap, aCubeCoeffs, aPairRatio);
-    StHandle<StImage> anImageR = scaledImage(anImageFileR, aSizeXLim, aSizeYLim, aSrcCubemap, aCubeCoeffs, aPairRatio);
+    StHandle<StImage> anImageL = scaledImage(anImageFileL, myTextureQueue->getDeviceCaps(), aSizeXLim, aSizeYLim,
+                                             aSrcCubemap, aCubeCoeffs, aPairRatio);
+    StHandle<StImage> anImageR = scaledImage(anImageFileR, myTextureQueue->getDeviceCaps(), aSizeXLim, aSizeYLim,
+                                             aSrcCubemap, aCubeCoeffs, aPairRatio);
 #ifdef ST_DEBUG
     const double aScaleTimeMSec = aLoadTimer.getElapsedTimeInMilliSec() - aLoadTimeMSec;
     if(anImageL != anImageFileL) {
@@ -503,27 +604,27 @@
         anImgInfo->Info.add(StArgument(tr(INFO_PIXEL_RATIO),
                                        StString(anImageFileL->getPixelRatio())));
     }
-    const StString aModelL = anImageFileL->formatImgColorModel();
+    const StString aFormatL = anImageFileL->formatImgPixelFormat();
     if(!anImageFileR->isNull()) {
         anImgInfo->Info.add(StArgument(tr(INFO_DIMENSIONS),
                                        formatSize(anImageL->getSizeX(), anImageL->getSizeY(),
                                                   theParams->Src1SizeX, theParams->Src1SizeY) + " " + tr(INFO_LEFT) + "\n"
                                      + formatSize(anImageR->getSizeX(), anImageR->getSizeY(),
                                                   theParams->Src2SizeX, theParams->Src2SizeY) + " " + tr(INFO_RIGHT)));
-        const StString aModelR = anImageFileR->formatImgColorModel();
-        if(aModelL == aModelR) {
-            anImgInfo->Info.add(StArgument(tr(INFO_COLOR_MODEL), aModelL));
+        const StString aFormatR = anImageFileR->formatImgPixelFormat();
+        if(aFormatL == aFormatR) {
+            anImgInfo->Info.add(StArgument(tr(INFO_PIXEL_FORMAT), aFormatL));
         } else {
-            anImgInfo->Info.add(StArgument(tr(INFO_COLOR_MODEL),
-                                aModelL + " " + tr(INFO_LEFT) + "\n"
-                              + aModelR + " " + tr(INFO_RIGHT)));
+            anImgInfo->Info.add(StArgument(tr(INFO_PIXEL_FORMAT),
+                                aFormatL + " " + tr(INFO_LEFT) + "\n"
+                              + aFormatR + " " + tr(INFO_RIGHT)));
         }
     } else {
         anImgInfo->Info.add(StArgument(tr(INFO_DIMENSIONS),
                                        formatSize(anImageL->getSizeX(), anImageL->getSizeY(),
                                                   theParams->Src1SizeX, theParams->Src1SizeY)));
-        anImgInfo->Info.add(StArgument(tr(INFO_COLOR_MODEL),
-                                       aModelL));
+        anImgInfo->Info.add(StArgument(tr(INFO_PIXEL_FORMAT),
+                                       aFormatL));
     }
     anImgInfo->Info.add(StArgument(tr(INFO_LOAD_TIME), StString(aLoadTimeMSec) + " " + tr(INFO_TIME_MSEC)));
     myLock.lock();
@@ -582,18 +683,18 @@
         aDataResult->initWrapper(aDataLeft);
     }
 
-    const StString& aTitle = myLangMap->getValue(StImageViewerStrings::DIALOG_SAVE_SNAPSHOT);
-    StMIMEList aFilter;
+    StOpenFileName anOpenInfo;
+    anOpenInfo.Title = myLangMap->getValue(StImageViewerStrings::DIALOG_SAVE_SNAPSHOT);
     StString aSaveExt;
     if(toSaveStereo) {
         switch(theImgType) {
             case StImageFile::ST_TYPE_PNG:
                 aSaveExt = ST_PNS_EXT;
-                aFilter.add(StMIME(ST_PNS_MIME, aSaveExt, ST_PNS_DESC));
+                anOpenInfo.Filter.add(StMIME(ST_PNS_MIME, aSaveExt, ST_PNS_DESC));
                 break;
             case StImageFile::ST_TYPE_JPEG:
                 aSaveExt = ST_JPS_EXT;
-                aFilter.add(StMIME(ST_JPS_MIME, aSaveExt, ST_JPS_DESC));
+                anOpenInfo.Filter.add(StMIME(ST_JPS_MIME, aSaveExt, ST_JPS_DESC));
                 break;
             default:
                 return false;
@@ -602,22 +703,22 @@
         switch(theImgType) {
             case StImageFile::ST_TYPE_PNG:
                 aSaveExt = ST_PNG_EXT;
-                aFilter.add(StMIME(ST_PNG_MIME, aSaveExt, ST_PNG_DESC));
+                anOpenInfo.Filter.add(StMIME(ST_PNG_MIME, aSaveExt, ST_PNG_DESC));
                 break;
             case StImageFile::ST_TYPE_JPEG:
                 aSaveExt = ST_JPG_EXT;
-                aFilter.add(StMIME(ST_JPG_MIME, aSaveExt, ST_JPEG_DESC));
+                anOpenInfo.Filter.add(StMIME(ST_JPG_MIME, aSaveExt, ST_JPEG_DESC));
                 break;
             default:
                 return false;
         }
     }
 
-    StString aFileNameSrc, aFolderSrc, aNameSrc, anExtSrc;
-    StFileNode::getFolderAndFile(theSource->getPath(), aFolderSrc, aFileNameSrc);
+    StString aFileNameSrc, aNameSrc, anExtSrc;
+    StFileNode::getFolderAndFile(theSource->getPath(), anOpenInfo.Folder, aFileNameSrc);
     StFileNode::getNameAndExtension(aFileNameSrc, aNameSrc, anExtSrc);
-    StString aFileToSave = (!aFolderSrc.isEmpty() ? aFolderSrc : "") + ST_FILE_SPLITTER + aNameSrc;
-    if(StFileNode::openFileDialog(aFolderSrc, aTitle, aFilter, aFileToSave, true)) {
+    StString aFileToSave = (!anOpenInfo.Folder.isEmpty() ? anOpenInfo.Folder : "") + ST_FILE_SPLITTER + aNameSrc;
+    if(StFileNode::openFileDialog(aFileToSave, anOpenInfo, true)) {
         if(StFileNode::getExtension(aFileToSave) != aSaveExt) {
             aFileToSave += StString('.') + aSaveExt;
         }

sview-17_04.tar.gz/StImageViewer/StImageLoader.h -> sview-20_08.tar.gz/StImageViewer/StImageLoader.h Changed

@@ -1,5 +1,5 @@
 /**
- * Copyright © 2007-2017 Kirill Gavrilov <kirill@sview.ru>
+ * Copyright © 2007-2019 Kirill Gavrilov <kirill@sview.ru>
  *
  * StImageViewer program is free software: you can redistribute it and/or modify
  * it under the terms of the GNU General Public License as published by
@@ -64,12 +64,13 @@
         public:
 
     static const char* ST_IMAGES_MIME_STRING;
+    static const char* ST_VIDEOS_MIME_STRING;
 
         public:
 
-    ST_LOCAL const StMIMEList& getMimeList() const {
-        return myMimeList;
-    }
+    ST_LOCAL const StMIMEList& getMimeListImages() const { return myMimeList; }
+
+    ST_LOCAL const StMIMEList& getMimeListVideo() const { return myVideoMimeList; }
 
     ST_LOCAL StImageLoader(const StImageFile::ImageClass      theImageLib,
                            const StHandle<StResourceManager>& theResMgr,
@@ -135,6 +136,13 @@
     ST_LOCAL void setCompressMemory(const bool theToCompress);
 
     /**
+     * Set theater mode.
+     */
+    ST_LOCAL void setTheaterMode(bool theIsTheater) {
+        myIsTheaterMode = theIsTheater;
+    }
+
+    /**
      * Stick to panorama 360 mode.
      */
     ST_LOCAL void setStickPano360(bool theToStick) {
@@ -155,6 +163,11 @@
         myToFlipCubeZ3x2 = theToFlip;
     }
 
+    /**
+     * Set if JPS file should be read as Left/Right (TRUE) of as Right/Left (FALSE).
+     */
+    ST_LOCAL void setSwapJPS(bool theToSwap) { myToSwapJps = theToSwap; }
+
         public:  //! @name Signals
 
     struct {
@@ -197,6 +210,7 @@
         private:
 
     const StMIMEList            myMimeList;
+    const StMIMEList            myVideoMimeList;
     StHandle<StThread>          myThread;        //!< main loop thread
     StHandle<StResourceManager> myResMgr;        //!< resource manager
     StHandle<StLangMap>         myLangMap;       //!< translations dictionary
@@ -212,9 +226,11 @@
 
     volatile StImageFile::ImageClass myImageLib;
     volatile Action            myAction;
+    volatile bool              myIsTheaterMode;  //!< flag indicating theater mode
     volatile bool              myToStickPano360; //!< stick to panorama 360 mode
     volatile bool              myToFlipCubeZ6x1; //!< flip Z within 6x1 cubemap input
     volatile bool              myToFlipCubeZ3x2; //!< flip Z within 3x2 cubemap input
+    volatile bool              myToSwapJps;      //!< read JPS as Left/Right instead of Right/Left
 
         private: //! @name no copies, please

sview-17_04.tar.gz/StImageViewer/StImageOpenDialog.cpp -> sview-20_08.tar.gz/StImageViewer/StImageOpenDialog.cpp Changed

@@ -91,19 +91,25 @@
 void StImageOpenDialog::dialogLoop() {
     myPathLeft .clear();
     myPathRight.clear();
-    StString aTitle = myPlugin->tr(myState == StImageOpenDialog::Dialog_ActiveDouble
+    StOpenFileName anOpenInfo;
+    anOpenInfo.Title = myPlugin->tr(myState == StImageOpenDialog::Dialog_ActiveDouble
                                  ? StImageViewerStrings::DIALOG_OPEN_LEFT
                                  : StImageViewerStrings::DIALOG_OPEN_FILE);
-
-    StString aDummy;
-    if(!StFileNode::openFileDialog(myFolder, aTitle, myPlugin->myLoader->getMimeList(), myPathLeft, false)) {
+    anOpenInfo.Folder = myFolder;
+    anOpenInfo.Filter = myPlugin->myLoader->getMimeListImages();
+    anOpenInfo.FilterTitle = "Image Files";
+    anOpenInfo.ExtraFilter = myPlugin->myLoader->getMimeListVideo();
+    anOpenInfo.ExtraFilterTitle = "Video Files";
+    if(!StFileNode::openFileDialog(myPathLeft, anOpenInfo, false)) {
         StMutexAuto aLock(myMutex);
         myState = StImageOpenDialog::Dialog_Inactive;
         return;
     } else if(myState == StImageOpenDialog::Dialog_ActiveDouble) {
-        aTitle = myPlugin->tr(StImageViewerStrings::DIALOG_OPEN_RIGHT);
+        anOpenInfo.Title = myPlugin->tr(StImageViewerStrings::DIALOG_OPEN_RIGHT);
+        StString aDummy;
         StFileNode::getFolderAndFile(myPathLeft, myFolder, aDummy);
-        if(!StFileNode::openFileDialog(myFolder, aTitle, myPlugin->myLoader->getMimeList(), myPathRight, false)) {
+        anOpenInfo.Folder = myFolder;
+        if(!StFileNode::openFileDialog(myPathRight, anOpenInfo, false)) {
             StMutexAuto aLock(myMutex);
             myState = StImageOpenDialog::Dialog_Inactive;
             return;

sview-17_04.tar.gz/StImageViewer/StImagePluginInfo.h -> sview-20_08.tar.gz/StImageViewer/StImagePluginInfo.h Changed

sview-17_04.tar.gz/StImageViewer/StImageViewer.cpp -> sview-20_08.tar.gz/StImageViewer/StImageViewer.cpp Changed

@@ -1,5 +1,5 @@
 /**
- * Copyright © 2007-2017 Kirill Gavrilov <kirill@sview.ru>
+ * Copyright © 2007-2020 Kirill Gavrilov <kirill@sview.ru>
  *
  * StImageViewer program is free software: you can redistribute it and/or modify
  * it under the terms of the GNU General Public License as published by
@@ -50,7 +50,6 @@
 
 namespace {
 
-    static const char ST_SETTING_SLIDESHOW_DELAY[] = "slideShowDelay";
     static const char ST_SETTING_LAST_FOLDER[] = "lastFolder";
     static const char ST_SETTING_RECENT_L[]    = "recentL";
     static const char ST_SETTING_RECENT_R[]    = "recentR";
@@ -102,6 +101,7 @@
     params.SrcStereoFormat->setName(tr(MENU_MEDIA_SRC_FORMAT));
     params.ToShowPlayList->setName(tr(PLAYLIST));
     params.ToShowAdjustImage->setName(tr(MENU_VIEW_IMAGE_ADJUST));
+    params.ToSwapJPS->setName(tr(OPTION_SWAP_JPS));
     params.ToStickPanorama->setName(tr(MENU_VIEW_STICK_PANORAMA360));
     params.ToFlipCubeZ6x1->setName(tr(MENU_VIEW_FLIPZ_CUBE6x1));
     params.ToFlipCubeZ3x2->setName(tr(MENU_VIEW_FLIPZ_CUBE3x2));
@@ -109,9 +109,12 @@
     params.ToShowFps->setName(tr(MENU_SHOW_FPS));
     params.ToShowMenu->setName(stCString("Show main menu"));
     params.ToShowTopbar->setName(stCString("Show top toolbar"));
+    params.ToShowBottom->setName(stCString("Show bottom toolbar"));
+    params.SlideShowDelay->setName(stCString("Slideshow delay"));
     params.IsMobileUI->setName(stCString("Mobile UI"));
     params.ToHideStatusBar->setName("Hide system status bar");
     params.ToHideNavBar   ->setName(tr(OPTION_HIDE_NAVIGATION_BAR));
+    params.IsExclusiveFullScreen->setName(tr(MENU_EXCLUSIVE_FULLSCREEN));
     params.IsVSyncOn->setName(tr(MENU_VSYNC));
     params.ToOpenLast->setName(tr(OPTION_OPEN_LAST_ON_STARTUP));
     params.ToSaveRecent->setName(stCString("Remember recent file"));
@@ -129,7 +132,6 @@
   myEventLoaded(false),
   //
   mySlideShowTimer(false),
-  mySlideShowDelay(4.0),
   //
   myToCheckUpdates(true),
   myToSaveSrcFormat(false),
@@ -166,6 +168,8 @@
     params.ToShowPlayList->signals.onChanged = stSlot(this, &StImageViewer::doShowPlayList);
     params.ToShowAdjustImage = new StBoolParamNamed(false, stCString("showAdjustImage"));
     params.ToShowAdjustImage->signals.onChanged = stSlot(this, &StImageViewer::doShowAdjustImage);
+    params.ToSwapJPS = new StBoolParamNamed(false, stCString("toSwapJPS"));
+    params.ToSwapJPS->signals.onChanged = stSlot(this, &StImageViewer::doChangeSwapJPS);
     params.ToStickPanorama = new StBoolParamNamed(false, stCString("toStickPano360"));
     params.ToStickPanorama->signals.onChanged = stSlot(this, &StImageViewer::doChangeStickPano360);
     params.ToFlipCubeZ6x1= new StBoolParamNamed(true,  stCString("toFlipCube6x1"));
@@ -176,6 +180,13 @@
     params.ToShowFps     = new StBoolParamNamed(false, stCString("toShowFps"));
     params.ToShowMenu    = new StBoolParamNamed(true,  stCString("toShowMenu"));
     params.ToShowTopbar  = new StBoolParamNamed(true,  stCString("toShowTopbar"));
+    params.ToShowBottom  = new StBoolParamNamed(true,  stCString("toShowBottom"));
+    params.SlideShowDelay = new StFloat32Param(4.0f, stCString("slideShowDelay2"));
+    params.SlideShowDelay->setMinMaxValues(1.0f, 10.0f);
+    params.SlideShowDelay->setDefValue(4.0f);
+    params.SlideShowDelay->setStep(1.0f);
+    params.SlideShowDelay->setTolerance(0.1f);
+    params.SlideShowDelay->setFormat(stCString("%01.1f s"));
     params.IsMobileUI    = new StBoolParamNamed(StWindow::isMobile(), stCString("isMobileUI"));
     params.IsMobileUI->signals.onChanged = stSlot(this, &StImageViewer::doChangeMobileUI);
     params.IsMobileUISwitch = new StBoolParam(params.IsMobileUI->getValue());
@@ -184,6 +195,7 @@
     params.ToHideStatusBar->signals.onChanged = stSlot(this, &StImageViewer::doHideSystemBars);
     params.ToHideNavBar    = new StBoolParamNamed(true, stCString("toHideNavBar"));
     params.ToHideNavBar   ->signals.onChanged = stSlot(this, &StImageViewer::doHideSystemBars);
+    params.IsExclusiveFullScreen = new StBoolParamNamed(false, stCString("isExclusiveFullScreen"));
     params.IsVSyncOn     = new StBoolParamNamed(true,  stCString("vsync"));
     params.IsVSyncOn->signals.onChanged = stSlot(this, &StImageViewer::doSwitchVSync);
     StApplication::params.VSyncMode->setValue(StGLContext::VSync_ON);
@@ -202,23 +214,22 @@
     mySettings->loadString(ST_SETTING_LAST_FOLDER,        params.lastFolder);
     mySettings->loadParam (params.LastUpdateDay);
     mySettings->loadParam (params.CheckUpdatesDays);
+    mySettings->loadParam (params.ToSwapJPS);
     mySettings->loadParam (params.ToStickPanorama);
     mySettings->loadParam (params.ToFlipCubeZ6x1);
     mySettings->loadParam (params.ToFlipCubeZ3x2);
     myToCheckPoorOrient = !mySettings->loadParam(params.ToTrackHead);
     mySettings->loadParam (params.ToShowFps);
+    mySettings->loadParam (params.SlideShowDelay);
     mySettings->loadParam (params.IsMobileUI);
     mySettings->loadParam (params.ToHideStatusBar);
     mySettings->loadParam (params.ToHideNavBar);
     mySettings->loadParam (params.ToOpenLast);
+    mySettings->loadParam (params.IsExclusiveFullScreen);
     mySettings->loadParam (params.IsVSyncOn);
     mySettings->loadParam (params.ToShowPlayList);
     mySettings->loadParam (params.ToShowAdjustImage);
 
-    int32_t aSlideShowDelayInt = int32_t(mySlideShowDelay);
-    mySettings->loadInt32 (ST_SETTING_SLIDESHOW_DELAY,    aSlideShowDelayInt);
-    mySlideShowDelay = double(aSlideShowDelayInt);
-
 #if defined(__ANDROID__)
     addRenderer(new StOutInterlace  (myResMgr, theParentWin));
     addRenderer(new StOutAnaglyph   (myResMgr, theParentWin));
@@ -251,6 +262,9 @@
     anAction = new StActionBool(stCString("DoShowFPS"), params.ToShowFps);
     addAction(Action_ShowFps, anAction, ST_VK_F12);
 
+    anAction = new StActionIntSlot(stCString("DoShowGUI"), stSlot(this, &StImageViewer::doShowHideGUI), 0);
+    addAction(Action_ShowGUI, anAction, ST_VK_TILDE);
+
     anAction = new StActionIntValue(stCString("DoSrcAuto"), params.SrcStereoFormat, StFormat_AUTO);
     addAction(Action_SrcAuto, anAction, ST_VK_A);
 
@@ -276,10 +290,10 @@
     addAction(Action_ListLast, anAction, ST_VK_END);
 
     anAction = new StActionIntSlot(stCString("DoListPrev"), stSlot(this, &StImageViewer::doListPrev), 0);
-    addAction(Action_ListPrev, anAction, ST_VK_PRIOR);
+    addAction(Action_ListPrev, anAction, ST_VK_PRIOR, StWindow::isMobile() ? ST_VK_VOLUME_UP : 0);
 
     anAction = new StActionIntSlot(stCString("DoListNext"), stSlot(this, &StImageViewer::doListNext), 0);
-    addAction(Action_ListNext, anAction, ST_VK_NEXT);
+    addAction(Action_ListNext, anAction, ST_VK_NEXT,  StWindow::isMobile() ? ST_VK_VOLUME_DOWN : 0);
 
     anAction = new StActionIntSlot(stCString("DoSlideShow"), stSlot(this, &StImageViewer::doSlideShow), 0);
     addAction(Action_SlideShow, anAction, ST_VK_SPACE);
@@ -302,6 +316,23 @@
 
     anAction = new StActionIntSlot(stCString("DoPanoramaOnOff"), stSlot(this, &StImageViewer::doPanoramaOnOff), 0);
     addAction(Action_PanoramaOnOff, anAction, ST_VK_P);
+
+    {
+    anAction = new StActionIntSlot(stCString("DoOutStereoNormal"), stSlot(this, &StImageViewer::doSetStereoOutput), StGLImageRegion::MODE_STEREO);
+    addAction(Action_OutStereoNormal, anAction);
+
+    anAction = new StActionIntSlot(stCString("DoOutStereoLeftView"), stSlot(this, &StImageViewer::doSetStereoOutput), StGLImageRegion::MODE_ONLY_LEFT);
+    addAction(Action_OutStereoLeftView, anAction);
+
+    anAction = new StActionIntSlot(stCString("DoOutStereoRightView"), stSlot(this, &StImageViewer::doSetStereoOutput), StGLImageRegion::MODE_ONLY_RIGHT);
+    addAction(Action_OutStereoRightView, anAction);
+
+    anAction = new StActionIntSlot(stCString("DoOutStereoParallelPair"), stSlot(this, &StImageViewer::doSetStereoOutput), StGLImageRegion::MODE_PARALLEL);
+    addAction(Action_OutStereoParallelPair, anAction);
+
+    anAction = new StActionIntSlot(stCString("DoOutStereoCrossEyed"), stSlot(this, &StImageViewer::doSetStereoOutput), StGLImageRegion::MODE_CROSSYED);
+    addAction(Action_OutStereoCrossEyed, anAction);
+    }
 }
 
 bool StImageViewer::resetDevice() {
@@ -341,19 +372,21 @@
         mySettings->saveParam (params.ScaleAdjust);
         mySettings->saveParam (params.ScaleHiDPI2X);
         mySettings->saveParam (params.TargetFps);
-        mySettings->saveInt32(ST_SETTING_SLIDESHOW_DELAY, int(mySlideShowDelay));
         mySettings->saveParam(params.LastUpdateDay);
         mySettings->saveParam(params.CheckUpdatesDays);
         mySettings->saveString(ST_SETTING_IMAGELIB,  StImageFile::imgLibToString(params.imageLib));
+        mySettings->saveParam (params.ToSwapJPS);
         mySettings->saveParam (params.ToStickPanorama);
         mySettings->saveParam (params.ToFlipCubeZ6x1);
         mySettings->saveParam (params.ToFlipCubeZ3x2);
         mySettings->saveParam (params.ToTrackHead);
         mySettings->saveParam (params.ToShowFps);
+        mySettings->saveParam (params.SlideShowDelay);
         mySettings->saveParam (params.IsMobileUI);
         mySettings->saveParam (params.ToHideStatusBar);
         mySettings->saveParam (params.ToHideNavBar);
         mySettings->saveParam (params.ToOpenLast);
+        mySettings->saveParam (params.IsExclusiveFullScreen);
         mySettings->saveParam (params.IsVSyncOn);
         mySettings->saveParam (params.ToShowPlayList);
         mySettings->saveParam (params.ToShowAdjustImage);
@@ -446,6 +479,12 @@
         return false;
     }
     myGUI->stglInit();
+    StRectF_t aFrustL, aFrustR;
+    if(myWindow->getCustomProjection(aFrustL, aFrustR)) {
+        myGUI->changeCamera()->setCustomProjection(aFrustL, aFrustR);
+    } else {
+        myGUI->changeCamera()->resetCustomProjection();
+    }
     myGUI->stglResize(myWindow->stglViewport(ST_WIN_MASTER), myWindow->getMargins(), (float )myWindow->stglAspectRatio());
 
     for(size_t anIter = 0; anIter < myGUI->myImage->getActions().size(); ++anIter) {
@@ -511,6 +550,7 @@
                                  myGUI->myImage->getTextureQueue(), myContext->getMaxTextureSize());
     myLoader->signals.onLoaded.connect(this, &StImageViewer::doLoaded);
     myLoader->setCompressMemory(myWindow->isMobile());
+    myLoader->setSwapJPS(params.ToSwapJPS->getValue());
     myLoader->setStickPano360(params.ToStickPanorama->getValue());
     myLoader->setFlipCubeZ6x1(params.ToFlipCubeZ6x1->getValue());
     myLoader->setFlipCubeZ3x2(params.ToFlipCubeZ3x2->getValue());
@@ -518,7 +558,7 @@
     // load this parameter AFTER image thread creation
     mySettings->loadParam(params.SrcStereoFormat);
 
-#if !defined(ST_NO_UPDATES_CHECK)
+#if defined(ST_UPDATES_CHECK)
     // read the current time
     time_t aRawtime;
     time(&aRawtime);
@@ -723,6 +763,12 @@
     if(toMobileGui != wasMobileGui) {
         doChangeMobileUI(params.IsMobileUI->getValue());
     } else {
+        StRectF_t aFrustL, aFrustR;
+        if(myWindow->getCustomProjection(aFrustL, aFrustR)) {
+            myGUI->changeCamera()->setCustomProjection(aFrustL, aFrustR);
+        } else {
+            myGUI->changeCamera()->resetCustomProjection();
+        }
         myGUI->stglResize(myWindow->stglViewport(ST_WIN_MASTER), myWindow->getMargins(), (float )myWindow->stglAspectRatio());
     }
 }
@@ -789,7 +835,9 @@
         return;
     }
 
+    const bool isReadOnly = StFileNode::isFileReadOnly(myFileToDelete->getPath());
     const StString aText = myLangMap->getValue(StImageViewerStrings::DIALOG_DELETE_FILE_QUESTION)
+                         + (isReadOnly ? "\nWARNING! The file is READ ONLY!" : "")
                          + "\n" + myFileToDelete->getPath();
 
     StGLMessageBox* aDialog = new StGLMessageBox(myGUI.access(), myLangMap->getValue(StImageViewerStrings::DIALOG_DELETE_FILE_TITLE),
@@ -805,6 +853,7 @@
         return;
     }
 
+    StFileNode::removeReadOnlyFlag(myFileToDelete->getPath());
     myPlayList->removePhysically(myFileToDelete);
     if(!myPlayList->isEmpty()) {
         doUpdateStateLoading();
@@ -918,20 +967,8 @@
 }
 
 void StImageViewer::doGesture(const StGestureEvent& theEvent) {
-    if(myGUI.isNull()
-    || myGUI->myImage == NULL) {
-        return;
-    }
-
-    for(StGLWidget *aChildIter(myGUI->getChildren()->getLast()), *aChildActive(NULL); aChildIter != NULL;) {
-        aChildActive = aChildIter;
-        aChildIter   = aChildIter->getPrev();
-        if(aChildActive->isVisibleAndPointIn(myGUI->getCursorZo())) {
-            if(aChildActive == myGUI->myImage) {
-                myGUI->myImage->doGesture(theEvent);
-            }
-            break;
-        }
+    if(!myGUI.isNull()) {
+        myGUI->doGesture(theEvent);
     }
 }
 
@@ -954,9 +991,19 @@
     }
 
     const StString aFile1 = theEvent.Files[0];
-    /*if(!myPlayList->checkExtension(aFile1)) {
+    if(!myPlayList->checkExtension(aFile1)
+     && myLoader->getMimeListVideo().checkExtension(StFileNode::getExtension(aFile1))) {
+        // redirect to StMoviePlayer
+        myOpenFileOtherApp = new StOpenInfo();
+        StArgumentsMap anArgs;
+        anArgs.add(StArgument("in", "video"));
+        myOpenFileOtherApp->setArgumentsMap(anArgs);
+        myOpenFileOtherApp->setPath(aFile1);
+        exit(0);
         return;
-    } else */if(theEvent.NbFiles == 1) {
+    }
+
+    if(theEvent.NbFiles == 1) {
         myPlayList->open(aFile1);
         doUpdateStateLoading();
         myLoader->doLoadNext();
@@ -1002,7 +1049,18 @@
             myPlayList->clear();
             myPlayList->addOneFile(myOpenDialog->getPathLeft(), myOpenDialog->getPathRight());
         } else {
-            myPlayList->open(myOpenDialog->getPathLeft());
+            if(!myPlayList->checkExtension(myOpenDialog->getPathLeft())
+             && myLoader->getMimeListVideo().checkExtension(StFileNode::getExtension(myOpenDialog->getPathLeft()))) {
+                // redirect to StMoviePlayer
+                myOpenFileOtherApp = new StOpenInfo();
+                StArgumentsMap anArgs;
+                anArgs.add(StArgument("in", "video"));
+                myOpenFileOtherApp->setArgumentsMap(anArgs);
+                myOpenFileOtherApp->setPath(myOpenDialog->getPathLeft());
+                exit(0);
+            } else {
+                myPlayList->open(myOpenDialog->getPathLeft());
+            }
         }
 
         doUpdateStateLoading();
@@ -1024,7 +1082,7 @@
         myLoader->doLoadNext();
     }
 
-    if(mySlideShowTimer.getElapsedTimeInSec() > mySlideShowDelay) {
+    if(mySlideShowTimer.getElapsedTimeInSec() > params.SlideShowDelay->getValue()) {
         mySlideShowTimer.restart();
         doListNext();
     }
@@ -1044,6 +1102,9 @@
     myGUI->setVisibility(myWindow->getMousePos(), myToHideUIFullScr && isFullScreen);
     bool toHideCursor = isFullScreen && myGUI->toHideCursor();
     myWindow->showCursor(!toHideCursor);
+
+    // for image viewer it is OK to make longer smoothed uploads
+    myGUI->myImage->getTextureQueue()->getUploadParams().MaxUploadIterations = 10;
 }
 
 void StImageViewer::stglDraw(unsigned int theView) {
@@ -1145,12 +1206,14 @@
         return;
     }
 
+    myLoader->setTheaterMode(theMode == StViewSurface_Theater);
+
     bool isChanged = false;
     StGLFrameTextures& aTexture = myGUI->myImage->getTextureQueue()->getQTexture().getFront(StGLQuadTexture::LEFT_TEXTURE);
     if(aTexture.getPlane(0).getTarget() == GL_TEXTURE_CUBE_MAP) {
-        isChanged = (theMode != StViewSurface_Cubemap);
+        isChanged = (theMode != StViewSurface_Cubemap && theMode != StViewSurface_CubemapEAC);
     } else {
-        isChanged = (theMode == StViewSurface_Cubemap);
+        isChanged = (theMode == StViewSurface_Cubemap || theMode == StViewSurface_CubemapEAC);
     }
 
     if(isChanged
@@ -1159,6 +1222,13 @@
     }
 }
 
+void StImageViewer::doSetStereoOutput(const size_t theMode) {
+    if(myLoader.isNull()) {
+        return;
+    }
+    myGUI->myImage->params.DisplayMode->setValue((int32_t )theMode);
+}
+
 void StImageViewer::doPanoramaOnOff(const size_t ) {
     if(myLoader.isNull()) {
         return;
@@ -1180,9 +1250,39 @@
     StPanorama aPano = st::probePanorama(aParams->StereoFormat,
                                          aParams->Src1SizeX, aParams->Src1SizeY,
                                          aParams->Src2SizeX, aParams->Src2SizeY);
-    myGUI->myImage->params.ViewMode->setValue(aPano == StPanorama_Cubemap6_1 || aPano == StPanorama_Cubemap3_2
-                                            ? StViewSurface_Cubemap
-                                            : StViewSurface_Sphere);
+    if(aPano == StPanorama_OFF) {
+        size_t aSizeX = aParams->Src1SizeX;
+        size_t aSizeY = aParams->Src1SizeY;
+        StPairRatio aPairRatio = st::formatToPairRatio(aParams->StereoFormat);
+        if(aPairRatio == StPairRatio_HalfWidth) {
+            aSizeX /= 2;
+        } else if(aPairRatio == StPairRatio_HalfHeight) {
+            aSizeY /= 2;
+        }
+        if(aSizeX > 8 && aSizeY > 8) {
+            if(double(aSizeX)/double(aSizeY) > 3.5) {
+                myGUI->myImage->params.ViewMode->setValue(StViewSurface_Cylinder);
+                return;
+            }
+        }
+    }
+    myGUI->myImage->params.ViewMode->setValue(StStereoParams::getViewSurfaceForPanoramaSource(aPano, true));
+}
+
+void StImageViewer::doChangeSwapJPS(const bool ) {
+    if(!myLoader.isNull()) {
+        myLoader->setSwapJPS(params.ToSwapJPS->getValue());
+        StHandle<StStereoParams> aParams = myGUI->myImage->getSource();
+        if(!aParams.isNull()
+        && !myPlayList->isEmpty()) {
+            StString aCurrFile = myPlayList->getCurrentTitle();
+            aCurrFile.toLowerCase();
+            if(aCurrFile.isEndsWith(stCString(".jps"))
+            || aCurrFile.isEndsWith(stCString(".pps"))) {
+                myLoader->doLoadNext();
+            }
+        }
+    }
 }
 
 void StImageViewer::doChangeStickPano360(const bool ) {
@@ -1283,6 +1383,16 @@
     }
 }
 
+void StImageViewer::doShowHideGUI(const size_t ) {
+    const bool toShow = !params.ToShowMenu->getValue() || (!myGUI.isNull() && !myGUI->isVisibleGUI());
+    params.ToShowMenu->setValue(toShow);
+    params.ToShowTopbar->setValue(toShow);
+    params.ToShowBottom->setValue(toShow);
+    if(toShow && !myGUI.isNull()) {
+        myGUI->setVisibility(myWindow->getMousePos(), false, true);
+    }
+}
+
 void StImageViewer::doSlideShow(const size_t ) {
     if(mySlideShowTimer.getElapsedTimeInSec() > 0.0) {
         mySlideShowTimer.stop();
@@ -1310,6 +1420,7 @@
 
 void StImageViewer::doFullscreen(const bool theIsFullscreen) {
     if(!myWindow.isNull()) {
+        myWindow->setAttribute(StWinAttr_ExclusiveFullScreen, params.IsExclusiveFullScreen->getValue());
         myWindow->setFullScreen(theIsFullscreen);
     }
 }

sview-17_04.tar.gz/StImageViewer/StImageViewer.h -> sview-20_08.tar.gz/StImageViewer/StImageViewer.h Changed

@@ -1,5 +1,5 @@
 /**
- * Copyright © 2007-2017 Kirill Gavrilov <kirill@sview.ru>
+ * Copyright © 2007-2020 Kirill Gavrilov <kirill@sview.ru>
  *
  * StImageViewer program is free software: you can redistribute it and/or modify
  * it under the terms of the GNU General Public License as published by
@@ -73,7 +73,7 @@
     /**
      * Reset device - release GL resources in old window and re-create them in new window.
      */
-    ST_CPPEXPORT virtual bool resetDevice();
+    ST_CPPEXPORT virtual bool resetDevice() ST_ATTR_OVERRIDE;
 
         private: //! @name window events slots
 
@@ -105,6 +105,7 @@
     ST_LOCAL void doListLast(const size_t dummy = 0);
     ST_LOCAL void doDeleteFileBegin(const size_t dummy = 0);
     ST_LOCAL void doDeleteFileEnd(const size_t dummy = 0);
+    ST_LOCAL void doShowHideGUI(const size_t dummy = 0);
     ST_LOCAL void doSlideShow(const size_t dummy = 0);
     ST_LOCAL void doQuit(const size_t dummy = 0);
 
@@ -131,19 +132,23 @@
         StHandle<StEnumParam>         CheckUpdatesDays; //!< days count between updates checks
         StHandle<StInt32ParamNamed>   LastUpdateDay;    //!< the last time update has been checked
         StHandle<StInt32ParamNamed>   SrcStereoFormat;  //!< source format
+        StHandle<StBoolParamNamed>    ToSwapJPS;        //!< swap JPS views order
         StHandle<StBoolParamNamed>    ToStickPanorama;  //!< force panorama input for all files
         StHandle<StBoolParamNamed>    ToFlipCubeZ6x1;   //!< flip Z coordinate within Cube map 6x1
         StHandle<StBoolParamNamed>    ToFlipCubeZ3x2;   //!< flip Z coordinate within Cube map 3x2
         StHandle<StBoolParamNamed>    ToTrackHead;      //!< enable/disable head-tracking
         StHandle<StBoolParamNamed>    ToShowMenu;       //!< show main menu
         StHandle<StBoolParamNamed>    ToShowTopbar;     //!< show topbar
+        StHandle<StBoolParamNamed>    ToShowBottom;     //!< show bottom
         StHandle<StBoolParamNamed>    ToShowPlayList;   //!< display playlist
         StHandle<StBoolParamNamed>    ToShowAdjustImage;//!< display image adjustment overlay
         StHandle<StBoolParamNamed>    ToShowFps;        //!< display FPS meter
+        StHandle<StFloat32Param>      SlideShowDelay;   //!< slideshow delay
         StHandle<StBoolParamNamed>    IsMobileUI;       //!< display mobile interface (user option)
         StHandle<StBoolParam>         IsMobileUISwitch; //!< display mobile interface (actual value)
         StHandle<StBoolParamNamed>    ToHideStatusBar;  //!< hide system-provided status bar
         StHandle<StBoolParamNamed>    ToHideNavBar;     //!< hide system-provided navigation bar
+        StHandle<StBoolParamNamed>    IsExclusiveFullScreen; //!< exclusive fullscreen mode
         StHandle<StBoolParamNamed>    IsVSyncOn;        //!< flag to use VSync
         StHandle<StBoolParamNamed>    ToOpenLast;       //!< option to open last file from recent list by default
         StHandle<StBoolParamNamed>    ToSaveRecent;     //!< load/save recent file
@@ -186,7 +191,9 @@
     ST_LOCAL void doFullscreen(const bool theIsFullscreen);
     ST_LOCAL void doSwitchSrcFormat(const int32_t theSrcFormat);
     ST_LOCAL void doSwitchViewMode(const int32_t theMode);
+    ST_LOCAL void doSetStereoOutput(const size_t theMode);
     ST_LOCAL void doPanoramaOnOff(const size_t );
+    ST_LOCAL void doChangeSwapJPS(const bool );
     ST_LOCAL void doChangeStickPano360(const bool );
     ST_LOCAL void doChangeFlipCubeZ(const bool );
     ST_LOCAL void doShowPlayList(const bool theToShow);
@@ -219,6 +226,12 @@
         Action_StereoParamsBegin,
         Action_StereoParamsEnd = Action_StereoParamsBegin + StGLImageRegion::ActionsNb - 1,
         Action_PanoramaOnOff,
+        Action_ShowGUI,
+        Action_OutStereoNormal,
+        Action_OutStereoLeftView,
+        Action_OutStereoRightView,
+        Action_OutStereoParallelPair,
+        Action_OutStereoCrossEyed,
     };
 
         private:
@@ -257,9 +270,7 @@
 
     StCondition                 myEventLoaded;     //!< indicate that new file was open
     StTimer                     myInactivityTimer; //!< timer initialized when application goes into paused state
-
-    StTimer                     mySlideShowTimer;  //!< slideshow stuff
-    double                      mySlideShowDelay;
+    StTimer                     mySlideShowTimer;  //!< slideshow timer
 
     bool                        myToCheckUpdates;
     bool                        myToSaveSrcFormat; //!< indicates that active source format should be saved or not

sview-17_04.tar.gz/StImageViewer/StImageViewer.rc -> sview-20_08.tar.gz/StImageViewer/StImageViewer.rc Changed

sview-17_04.tar.gz/StImageViewer/StImageViewerGUI.cpp -> sview-20_08.tar.gz/StImageViewer/StImageViewerGUI.cpp Changed

@@ -1,5 +1,5 @@
 /**
- * Copyright © 2009-2017 Kirill Gavrilov <kirill@sview.ru>
+ * Copyright © 2009-2020 Kirill Gavrilov <kirill@sview.ru>
  *
  * StImageViewer program is free software: you can redistribute it and/or modify
  * it under the terms of the GNU General Public License as published by
@@ -56,6 +56,8 @@
 
 namespace {
 
+    static const float THE_VISIBILITY_IDLE_TIME = 2.0f;
+
     static const int DISPL_Y_REGION_UPPER = 32;
     static const int DISPL_X_REGION_UPPER = 32;
 
@@ -135,34 +137,34 @@
     const int      anIconStep = scale(48);
     aButtonMargins.extend(scale(8));
 
-    myPanelUpper = new StGLContainer(this, 0, 0, StGLCorner(ST_VCORNER_TOP, ST_HCORNER_LEFT), scale(4096), scale(128));
+    myPanelUpper = new StGLContainer(this, aLeft, aTop, StGLCorner(ST_VCORNER_TOP, ST_HCORNER_LEFT), scale(4096), scale(128));
 
     // append textured buttons
-    myBtnOpen   = new StGLTextureButton(myPanelUpper, aLeft + (aBtnIter++) * anIconStep, aTop);
+    myBtnOpen   = new StGLTextureButton(myPanelUpper, (aBtnIter++) * anIconStep, 0);
     myBtnOpen->signals.onBtnClick.connect(myPlugin, &StImageViewer::doOpen1FileAction);
     myBtnOpen->setTexturePath(iconTexture(stCString("actionOpen"), anIconSize));
     myBtnOpen->setDrawShadow(true);
     myBtnOpen->changeMargins() = aButtonMargins;
 
-    myBtnPrev   = new StGLTextureButton(myPanelUpper, aLeft + (aBtnIter++) * anIconStep, aTop);
+    myBtnPrev   = new StGLTextureButton(myPanelUpper, (aBtnIter++) * anIconStep, 0);
     myBtnPrev->signals.onBtnClick.connect(myPlugin, &StImageViewer::doListPrev);
     myBtnPrev->setTexturePath(iconTexture(stCString("actionBack"), anIconSize));
     myBtnPrev->setDrawShadow(true);
     myBtnPrev->changeMargins() = aButtonMargins;
 
-    myBtnNext   = new StGLTextureButton(myPanelUpper, aLeft + (aBtnIter++) * anIconStep, aTop);
+    myBtnNext   = new StGLTextureButton(myPanelUpper, (aBtnIter++) * anIconStep, 0);
     myBtnNext->signals.onBtnClick.connect(myPlugin, &StImageViewer::doListNext);
     myBtnNext->setTexturePath(iconTexture(stCString("actionNext"), anIconSize));
     myBtnNext->setDrawShadow(true);
     myBtnNext->changeMargins() = aButtonMargins;
 
-    myBtnInfo = new StGLTextureButton(myPanelUpper, aLeft + (aBtnIter++) * anIconStep, aTop);
+    myBtnInfo = new StGLTextureButton(myPanelUpper, (aBtnIter++) * anIconStep, 0);
     myBtnInfo->signals.onBtnClick += stSlot(myPlugin, &StImageViewer::doAboutImage);
     myBtnInfo->setTexturePath(iconTexture(stCString("actionInfo"),  anIconSize));
     myBtnInfo->setDrawShadow(true);
     myBtnInfo->changeMargins() = aButtonMargins;
 
-    StGLTextureButton* aSrcBtn = new StGLTextureButton(myPanelUpper, aLeft + (aBtnIter++) * anIconStep, aTop,
+    StGLTextureButton* aSrcBtn = new StGLTextureButton(myPanelUpper, (aBtnIter++) * anIconStep, 0,
                                                        StGLCorner(ST_VCORNER_TOP, ST_HCORNER_LEFT), StFormat_NB);
     aSrcBtn->changeMargins() = aButtonMargins;
     aSrcBtn->signals.onBtnClick += stSlot(this, &StImageViewerGUI::doDisplayStereoFormatCombo);
@@ -188,7 +190,7 @@
     myBtnSwapLR = new StGLCheckboxTextured(myPanelUpper, myImage->params.SwapLR,
                                            iconTexture(stCString("actionSwapLROff"), anIconSize),
                                            iconTexture(stCString("actionSwapLROn"),  anIconSize),
-                                           aLeft + (aBtnIter++) * anIconStep, aTop,
+                                           (aBtnIter++) * anIconStep, 0,
                                            StGLCorner(ST_VCORNER_TOP, ST_HCORNER_LEFT));
     myBtnSwapLR->setDrawShadow(true);
     myBtnSwapLR->changeMargins() = aButtonMargins;
@@ -197,7 +199,7 @@
     myBtnPanorama = new StGLCheckboxTextured(myPanelUpper, aTrackedPano,
                                              iconTexture(stCString("actionPanoramaOff"), anIconSize),
                                              iconTexture(stCString("actionPanorama"),    anIconSize),
-                                             aLeft + (aBtnIter++) * anIconStep, aTop,
+                                             (aBtnIter++) * anIconStep, 0,
                                              StGLCorner(ST_VCORNER_TOP, ST_HCORNER_LEFT));
     myBtnPanorama->signals.onBtnClick += stSlot(this, &StImageViewerGUI::doPanoramaCombo);
     myBtnPanorama->setDrawShadow(true);
@@ -206,7 +208,7 @@
     myBtnAdjust = new StGLCheckboxTextured(myPanelUpper, myPlugin->params.ToShowAdjustImage,
                                            iconTexture(stCString("actionColorAdjustOff"), anIconSize),
                                            iconTexture(stCString("actionColorAdjust"),    anIconSize),
-                                           aLeft + (aBtnIter++) * anIconStep, aTop,
+                                           (aBtnIter++) * anIconStep, 0,
                                            StGLCorner(ST_VCORNER_TOP, ST_HCORNER_LEFT));
     myBtnAdjust->setDrawShadow(true);
     myBtnAdjust->changeMargins() = aButtonMargins;
@@ -392,10 +394,18 @@
 void StImageViewerGUI::fillPanoramaMenu(StGLMenu* theMenu) {
     theMenu->addItem(tr(MENU_VIEW_SURFACE_PLANE),
                      myImage->params.ViewMode, StViewSurface_Plain);
+    theMenu->addItem(tr(MENU_VIEW_SURFACE_THEATER),
+                     myImage->params.ViewMode, StViewSurface_Theater);
+    theMenu->addItem(tr(MENU_VIEW_SURFACE_CYLINDER),
+                     myImage->params.ViewMode, StViewSurface_Cylinder);
+    theMenu->addItem(tr(MENU_VIEW_SURFACE_HEMISPHERE),
+                     myImage->params.ViewMode, StViewSurface_Hemisphere);
     theMenu->addItem(tr(MENU_VIEW_SURFACE_SPHERE),
                      myImage->params.ViewMode, StViewSurface_Sphere);
     theMenu->addItem(tr(MENU_VIEW_SURFACE_CUBEMAP),
                      myImage->params.ViewMode, StViewSurface_Cubemap);
+    theMenu->addItem(tr(MENU_VIEW_SURFACE_CUBEMAP_EAC),
+                     myImage->params.ViewMode, StViewSurface_CubemapEAC);
     if(myWindow->hasOrientationSensor()) {
         theMenu->addItem(tr(myWindow->isPoorOrientationSensor() ? MENU_VIEW_TRACK_HEAD_POOR : MENU_VIEW_TRACK_HEAD),
                          myPlugin->params.ToTrackHead);
@@ -418,6 +428,8 @@
                    myImage->params.TextureFilter, StGLImageProgram::FILTER_NEAREST);
     aMenu->addItem(tr(MENU_VIEW_TEXFILTER_LINEAR),
                    myImage->params.TextureFilter, StGLImageProgram::FILTER_LINEAR);
+    aMenu->addItem(tr(MENU_VIEW_TEXFILTER_TRILINEAR),
+                   myImage->params.TextureFilter, StGLImageProgram::FILTER_TRILINEAR);
     return aMenu;
 }
 
@@ -546,7 +558,7 @@
     const StGLVec3 THE_WHITE(1.0f, 1.0f, 1.0f);
     const StString anAbout = tr(ABOUT_DPLUGIN_NAME) + '\n'
                            + tr(ABOUT_VERSION) + " " + StVersionInfo::getSDKVersionString()
-                           + "\n \n" + tr(ABOUT_DESCRIPTION).format("2007-2017", "kirill@sview.ru", "www.sview.ru");
+                           + "\n \n" + tr(ABOUT_DESCRIPTION).format("2007-2020", "kirill@sview.ru", "www.sview.ru");
 
     StArgumentsMap anInfo;
     anInfo.add(StDictEntry("CPU cores", StString(StThread::countLogicalProcessors()) + StString(" logical processor(s)")));
@@ -785,9 +797,14 @@
     aParams.add(myPlugin->params.ToStickPanorama);
     aParams.add(myPlugin->params.ToFlipCubeZ6x1);
     aParams.add(myPlugin->params.ToFlipCubeZ3x2);
+    aParams.add(myPlugin->params.ToSwapJPS);
     aParams.add(myPlugin->params.ToShowFps);
+    aParams.add(myPlugin->params.SlideShowDelay);
     aParams.add(myLangMap->params.language);
     aParams.add(myPlugin->params.IsMobileUI);
+#if defined(_WIN32) || defined(__APPLE__) // implemented only on Windows and macOS
+    aParams.add(myPlugin->params.IsExclusiveFullScreen);
+#endif
     if(isMobile()) {
         //aParams.add(myPlugin->params.ToHideStatusBar);
         aParams.add(myPlugin->params.ToHideNavBar);
@@ -795,10 +812,16 @@
         aParams.add(myPlugin->params.ToOpenLast);
     }
     aParams.add(myPlugin->params.ExitOnEscape);
-#if !defined(ST_NO_UPDATES_CHECK)
+#if defined(ST_UPDATES_CHECK)
     aParams.add(myPlugin->params.CheckUpdatesDays);
 #endif
 
+    if(!myWindow->isMobile()) {
+        StHandle<StBoolParamNamed> aDefDrawerParam = myPlugin->createDefaultDrawerParam(stCString("StImageViewer"),
+                                                                                        stCString("sView launcher starts Image Viewer"));
+        aParams.add(aDefDrawerParam);
+    }
+
     StInfoDialog* aDialog = new StInfoDialog(myPlugin, this, tr(MENU_HELP_SETTINGS), scale(768), scale(300));
 
     const int aWidthMax  = aDialog->getContent()->getRectPx().width();
@@ -1148,18 +1171,22 @@
 
 void StImageViewerGUI::doOpenFile(const size_t ) {
     StGLOpenFile* aDialog = new StGLOpenFile(this, tr(DIALOG_OPEN_FILE), tr(BUTTON_CLOSE));
-    aDialog->setMimeList(myPlugin->myLoader->getMimeList());
-#if defined(_WIN32)
-    //
-#else
-    aDialog->addHotItem("/", "Root");
-#endif
-    aDialog->addHotItem(getResourceManager()->getFolder(StResourceManager::FolderId_SdCard));
+
+    const StString anSdCardPath = getResourceManager()->getFolder(StResourceManager::FolderId_SdCard);
+    if(!anSdCardPath.isEmpty()) {
+        StString aFolder, aName;
+        StFileNode::getFolderAndFile(anSdCardPath, aFolder, aName);
+        aDialog->addHotItem(anSdCardPath, stUtfTools::isInteger(aName) ? (StString("sdcard") + aName) : aName);
+    }
     aDialog->addHotItem(getResourceManager()->getFolder(StResourceManager::FolderId_Downloads));
+    aDialog->addHotItem(getResourceManager()->getFolder(StResourceManager::FolderId_Documents));
     aDialog->addHotItem(getResourceManager()->getFolder(StResourceManager::FolderId_Pictures));
     aDialog->addHotItem(getResourceManager()->getFolder(StResourceManager::FolderId_Photos));
     aDialog->signals.onFileSelected = stSlot(myPlugin, &StImageViewer::doOpen1FileFromGui);
 
+    aDialog->setMimeList(myPlugin->myLoader->getMimeListImages(), "Images", false);
+    aDialog->setMimeList(myPlugin->myLoader->getMimeListVideo(),  "Videos", true);
+
     if(myPlugin->params.lastFolder.isEmpty()) {
         StHandle<StFileNode> aCurrFile = myPlugin->myPlayList->getCurrentFile();
         if(!aCurrFile.isNull()) {
@@ -1258,6 +1285,12 @@
     }
 
     myImage = new StGLImageRegion(this, aTextureQueue, true);
+    myImage->changeIconPrev()->setTexturePath(iconTexture(stCString("actionBack"), scaleIcon(64)));
+    myImage->changeIconPrev()->setDrawShadow(true);
+    myImage->changeIconNext()->setTexturePath(iconTexture(stCString("actionNext"), scaleIcon(64)));
+    myImage->changeIconNext()->setDrawShadow(true);
+    myImage->signals.onOpenItem = stSlot(myPlugin, &StImageViewer::doFileNext);
+    myImage->setPlayList(thePlayList);
     myImage->params.DisplayMode->setName(tr(MENU_VIEW_DISPLAY_MODE));
     myImage->params.DisplayMode->changeValues()[StGLImageRegion::MODE_STEREO]     = tr(MENU_VIEW_DISPLAY_MODE_STEREO);
     myImage->params.DisplayMode->changeValues()[StGLImageRegion::MODE_ONLY_LEFT]  = tr(MENU_VIEW_DISPLAY_MODE_LEFT);
@@ -1311,8 +1344,32 @@
     }
 }
 
+void StImageViewerGUI::doGesture(const StGestureEvent& theEvent) {
+    if(myImage == NULL) {
+        return;
+    }
+
+    if(theEvent.Type == stEvent_Gesture1Tap) {
+        myTapTimer.restart();
+    } else if(theEvent.Type == stEvent_Gesture1DoubleTap) {
+        myTapTimer.stop();
+    }
+
+    for(StGLWidget *aChildIter(getChildren()->getLast()), *aChildActive(NULL); aChildIter != NULL;) {
+        aChildActive = aChildIter;
+        aChildIter   = aChildIter->getPrev();
+        if(aChildActive->isVisibleAndPointIn(getCursorZo())) {
+            if(aChildActive == myImage) {
+                myImage->doGesture(theEvent);
+            }
+            return;
+        }
+    }
+}
+
 void StImageViewerGUI::setVisibility(const StPointD_t& theCursor,
-                                     bool              toForceHide) {
+                                     bool theToForceHide,
+                                     bool theToForceShow) {
     const bool toShowAdjust   = myPlugin->params.ToShowAdjustImage->getValue();
     const bool toShowPlayList = myPlugin->params.ToShowPlayList->getValue();
     const bool hasMainMenu    =  myPlugin->params.ToShowMenu->getValue()
@@ -1321,10 +1378,29 @@
                              &&  myPlugin->params.ToShowTopbar->getValue()
                              &&  myPanelUpper  != NULL;
     const bool hasBottomPanel = !myIsMinimalGUI
+                             &&  myPlugin->params.ToShowBottom->getValue()
                              &&  myPanelBottom != NULL;
-    const bool isMouseActive  = myWindow->isMouseMoved();
 
     StHandle<StStereoParams> aParams = myImage->getSource();
+    if(aParams.isNull() && !myEmptyTimer.isOn()
+    && !myPlugin->myPlayList->isEmpty()) {
+        myEmptyTimer.restart();
+    } else {
+        myEmptyTimer.stop();
+    }
+    if(myEmptyTimer.getElapsedTime() >= 2.5) {
+        myVisibilityTimer.restart();
+        myEmptyTimer.stop();
+    }
+    if(myTapTimer.getElapsedTime() >= 0.5) {
+        myVisibilityTimer.restart();
+        myTapTimer.stop();
+    }
+    if(theToForceShow) {
+        myVisibilityTimer.restart();
+    }
+    const bool isMouseActive  = myWindow->isMouseMoved();
+
     StFormat aSrcFormat = (StFormat )myPlugin->params.SrcStereoFormat->getValue();
     if(aSrcFormat == StFormat_AUTO
     && !aParams.isNull()) {
@@ -1337,8 +1413,7 @@
 
     const double aStillTime = myVisibilityTimer.getElapsedTime();
     myIsVisibleGUI = isMouseActive
-        || aParams.isNull()
-        || aStillTime < 2.0
+        || aStillTime < THE_VISIBILITY_IDLE_TIME
         || (hasUpperPanel  && myPanelUpper ->isPointIn(theCursor))
         || (hasBottomPanel && myPanelBottom->isPointIn(theCursor))
         || (myPlayList != NULL && toShowPlayList && myPlayList->isPointIn(theCursor))
@@ -1347,8 +1422,8 @@
     if(isMouseActive) {
         myVisibilityTimer.restart();
     }
-    const bool  toShowAll = !myIsMinimalGUI && myIsVisibleGUI && !toForceHide;
-    const float anOpacity = (float )myVisLerp.perform(toShowAll, toForceHide);
+    const bool  toShowAll = !myIsMinimalGUI && myIsVisibleGUI && !theToForceHide;
+    const float anOpacity = (float )myVisLerp.perform(toShowAll, theToForceHide || theToForceShow);
 
     if(myMenuRoot != NULL) {
         myMenuRoot->setOpacity(hasMainMenu ? anOpacity : 0.0f, true);
@@ -1374,7 +1449,7 @@
     }
     if(myPlayList != NULL
     && toShowPlayList) {
-        myPlayList->setOpacity(anOpacity, true);
+        myPlayList->setOpacity(myPlugin->params.ToShowBottom->getValue() ? anOpacity : 0.0f, true);
     }
     if(myBtnFull != NULL) {
         if(myIsMinimalGUI
@@ -1413,9 +1488,9 @@
     bool toShowPano = aViewMode != StViewSurface_Plain;
     if(!toShowPano
     && !aParams.isNull()
-    &&  st::probePanorama(aParams->StereoFormat,
+    /*&&  st::probePanorama(aParams->StereoFormat,
                           aParams->Src1SizeX, aParams->Src1SizeY,
-                          aParams->Src2SizeX, aParams->Src2SizeY) != StPanorama_OFF) {
+                          aParams->Src2SizeX, aParams->Src2SizeY) != StPanorama_OFF*/) {
         toShowPano = true;
     }
     if(myBtnPanorama != NULL) {
@@ -1451,9 +1526,13 @@
         } else if(::isPointIn(myBtnPanorama, theCursor)) {
             size_t aTrPano = MENU_VIEW_SURFACE_PLANE;
             switch(aViewMode) {
-                case StViewSurface_Plain:   aTrPano = MENU_VIEW_SURFACE_PLANE;   break;
-                case StViewSurface_Sphere:  aTrPano = MENU_VIEW_SURFACE_SPHERE;  break;
-                case StViewSurface_Cubemap: aTrPano = MENU_VIEW_SURFACE_CUBEMAP; break;
+                case StViewSurface_Plain:      aTrPano = MENU_VIEW_SURFACE_PLANE;   break;
+                case StViewSurface_Theater:    aTrPano = MENU_VIEW_SURFACE_THEATER; break;
+                case StViewSurface_Sphere:     aTrPano = MENU_VIEW_SURFACE_SPHERE;  break;
+                case StViewSurface_Hemisphere: aTrPano = MENU_VIEW_SURFACE_HEMISPHERE; break;
+                case StViewSurface_Cubemap:    aTrPano = MENU_VIEW_SURFACE_CUBEMAP;  break;
+                case StViewSurface_CubemapEAC: aTrPano = MENU_VIEW_SURFACE_CUBEMAP_EAC; break;
+                case StViewSurface_Cylinder:   aTrPano = MENU_VIEW_SURFACE_CYLINDER; break;
             }
             myDescr->setText(tr(MENU_VIEW_PANORAMA) + "\n" + tr(aTrPano));
         } else {
@@ -1486,7 +1565,20 @@
                                   float theAspect) {
     const int aNewSizeX  = theViewPort.width();
     const int aNewSizeY  = theViewPort.height();
-    const int aWorkRight = stMax(aNewSizeX - theMargins.right - theMargins.left, 2);
+    int aGapTopX = 0, aGapTopY = 0, aGapBotX = 0, aGapBotY = 0;
+    if(isMobile()) {
+        // add gap for hidden system navigation buttons
+        static const int THE_NAVIGATION_GAPX = 32;
+        static const int THE_NAVIGATION_GAPY = 16;
+        if(theAspect < 9.0 / 16.0 && theAspect > 0.0) {
+            aGapTopY = aGapBotY = stMax(0, scale(stMin(THE_NAVIGATION_GAPY, int((1.0 / theAspect * 360) - 360 * 2))));
+        } else if(theAspect > 9.0 / 16.0) {
+            aGapTopX = aGapBotX = stMax(0, scale(stMin(THE_NAVIGATION_GAPX, int((theAspect * 360) - 360 * 2))));
+        }
+    } else {
+        aGapTopY = scale(DISPL_Y_REGION_UPPER);
+        aGapTopX = scale(DISPL_X_REGION_UPPER);
+    }
 
     // image should fit entire view
     myImage->changeRectPx().top()    = -theMargins.top;
@@ -1495,12 +1587,16 @@
     myImage->changeRectPx().right()  = -theMargins.left + aNewSizeX;
 
     if(myPanelUpper != NULL) {
-        myPanelUpper->changeRectPx().right() = aWorkRight;
+        myPanelUpper->changeRectPx().top()   = aGapTopY;
+        myPanelUpper->changeRectPx().left()  = aGapTopX;
+        myPanelUpper->changeRectPx().right() = aGapTopX + stMax(aNewSizeX - theMargins.right - theMargins.left - 2 * aGapTopX, 2);
         myIsMinimalGUI = (myWindow->isMovable() || myWindow->hasFullscreenMode()) && !isMobile()
                      && (aNewSizeY < scale(400) || aNewSizeX < scale(400));
     }
     if(myPanelBottom != NULL) {
-        myPanelBottom->changeRectPx().right() = aWorkRight;
+        myPanelBottom->changeRectPx().top()   = -aGapBotY;
+        myPanelBottom->changeRectPx().left()  = aGapBotX;
+        myPanelBottom->changeRectPx().right() = aGapBotX + stMax(aNewSizeX - theMargins.right - theMargins.left - 2 * aGapBotX, 2);
     }
     StGLRootWidget::stglResize(theViewPort, theMargins, theAspect);
 }

sview-17_04.tar.gz/StImageViewer/StImageViewerGUI.h -> sview-20_08.tar.gz/StImageViewer/StImageViewerGUI.h Changed

@@ -1,5 +1,5 @@
 /**
- * Copyright © 2009-2017 Kirill Gavrilov <kirill@sview.ru>
+ * Copyright © 2009-2020 Kirill Gavrilov <kirill@sview.ru>
  *
  * StImageViewer program is free software: you can redistribute it and/or modify
  * it under the terms of the GNU General Public License as published by
@@ -102,8 +102,14 @@
                                      float theAspect) ST_ATTR_OVERRIDE;
     ST_LOCAL virtual void stglDraw(unsigned int theView) ST_ATTR_OVERRIDE;
 
+    /**
+     * Handle gesture.
+     */
+    ST_LOCAL void doGesture(const StGestureEvent& theEvent);
+    ST_LOCAL bool isVisibleGUI() const { return myVisLerp.getValue() > 0.0; }
     ST_LOCAL void setVisibility(const StPointD_t& theCursor,
-                                bool              toForceHide);
+                                bool theToForceHide,
+                                bool theToForceShow = false);
 
         public:
 
@@ -203,6 +209,8 @@
     StWindow*           myWindow;           //!< link to the window instance
     StTranslations*     myLangMap;          //!< translated strings map
     StTimer             myVisibilityTimer;  //!< minimum visible delay
+    StTimer             myEmptyTimer;       //!< empty list delay
+    StTimer             myTapTimer;         //!< single tap delay
     StGLAnimationLerp   myVisLerp;
 
     StGLImageRegion*    myImage;            //!< the main image

sview-17_04.tar.gz/StImageViewer/StImageViewerStrings.cpp -> sview-20_08.tar.gz/StImageViewer/StImageViewerStrings.cpp Changed

@@ -1,5 +1,5 @@
 /**
- * Copyright © 2013-2017 Kirill Gavrilov <kirill@sview.ru>
+ * Copyright © 2013-2020 Kirill Gavrilov <kirill@sview.ru>
  *
  * StImageViewer program is free software: you can redistribute it and/or modify
  * it under the terms of the GNU General Public License as published by
@@ -119,10 +119,16 @@
                "Plane");
     theStrings(MENU_VIEW_SURFACE_SPHERE,
                "Sphere");
+    theStrings(MENU_VIEW_SURFACE_HEMISPHERE,
+               "Hemisphere");
     theStrings(MENU_VIEW_SURFACE_CYLINDER,
                "Cylinder");
     theStrings(MENU_VIEW_SURFACE_CUBEMAP,
                "Cubemap");
+    theStrings(MENU_VIEW_SURFACE_THEATER,
+               "Theater");
+    theStrings(MENU_VIEW_SURFACE_CUBEMAP_EAC,
+               "Equiangular cubemap");
     theStrings(MENU_VIEW_TRACK_HEAD,
                "Track orientation");
     theStrings(MENU_VIEW_TRACK_HEAD_POOR,
@@ -153,6 +159,8 @@
                "Nearest");
     theStrings(MENU_VIEW_TEXFILTER_LINEAR,
                "Linear"),
+    theStrings(MENU_VIEW_TEXFILTER_TRILINEAR,
+               "Trilinear"),
     theStrings(MENU_CHANGE_DEVICE,
                "Change Device");
     theStrings(MENU_ABOUT_RENDERER,
@@ -161,6 +169,8 @@
                "Show FPS");
     theStrings(MENU_VSYNC,
                "VSync");
+    theStrings(MENU_EXCLUSIVE_FULLSCREEN,
+               "Exclusive Fullscreen mode");
     theStrings(ABOUT_DPLUGIN_NAME,
                "sView - Image Viewer");
     theStrings(ABOUT_VERSION,
@@ -237,6 +247,8 @@
                "Hide system navigation bar");
     theStrings(OPTION_OPEN_LAST_ON_STARTUP,
                "Open last viewed file on startup");
+    theStrings(OPTION_SWAP_JPS,
+               "Swap JPS/PNS views order");
 
     theStrings(UPDATES_NOTIFY,
                "A new version of sView is available on the official site www.sview.ru.\n"
@@ -286,6 +298,8 @@
                "msec");
     theStrings(INFO_PIXEL_RATIO,
                "Pixel ratio");
+    theStrings(INFO_PIXEL_FORMAT,
+               "Pixel format");
     theStrings(INFO_COLOR_MODEL,
                "Color model");
     theStrings(INFO_NO_SRCFORMAT,
@@ -451,6 +465,15 @@
     addAction(theStrings, StImageViewer::Action_PanoramaOnOff,
               "DoPanoramaOnOff",
               "Enable/disable panorama mode");
+    addAction(theStrings, StImageViewer::Action_ShowGUI,
+              "DoShowGUI",
+              "Show/hide GUI");
+
+    theStrings.addAlias("DoOutStereoNormal",       MENU_VIEW_DISPLAY_MODE_STEREO);
+    theStrings.addAlias("DoOutStereoLeftView",     MENU_VIEW_DISPLAY_MODE_LEFT);
+    theStrings.addAlias("DoOutStereoRightView",    MENU_VIEW_DISPLAY_MODE_RIGHT);
+    theStrings.addAlias("DoOutStereoParallelPair", MENU_VIEW_DISPLAY_MODE_PARALLEL);
+    theStrings.addAlias("DoOutStereoCrossEyed",    MENU_VIEW_DISPLAY_MODE_CROSSYED);
 }
 
 };

sview-17_04.tar.gz/StImageViewer/StImageViewerStrings.h -> sview-20_08.tar.gz/StImageViewer/StImageViewerStrings.h Changed

@@ -1,5 +1,5 @@
 /**
- * Copyright © 2009-2017 Kirill Gavrilov <kirill@sview.ru>
+ * Copyright © 2009-2020 Kirill Gavrilov <kirill@sview.ru>
  *
  * StImageViewer program is free software: you can redistribute it and/or modify
  * it under the terms of the GNU General Public License as published by
@@ -84,6 +84,7 @@
 
         MENU_VIEW_TEXFILTER_NEAREST = 1260,
         MENU_VIEW_TEXFILTER_LINEAR  = 1261,
+        MENU_VIEW_TEXFILTER_TRILINEAR = 1263,
 
         MENU_VIEW_ADJUST_RESET      = 1270,
         MENU_VIEW_ADJUST_BRIGHTNESS = 1271,
@@ -94,17 +95,21 @@
         MENU_VIEW_SURFACE_SPHERE    = 1281,
         MENU_VIEW_SURFACE_CYLINDER  = 1282,
         MENU_VIEW_SURFACE_CUBEMAP   = 1283,
+        MENU_VIEW_SURFACE_HEMISPHERE= 1284,
         MENU_VIEW_TRACK_HEAD        = 1285,
         MENU_VIEW_TRACK_HEAD_POOR   = 1286,
         MENU_VIEW_STICK_PANORAMA360 = 1288,
         MENU_VIEW_FLIPZ_CUBE6x1     = 1291,
         MENU_VIEW_FLIPZ_CUBE3x2     = 1292,
+        MENU_VIEW_SURFACE_CUBEMAP_EAC = 1293,
+        MENU_VIEW_SURFACE_THEATER   = 1294,
 
         // Root -> Output -> Change Device menu
         MENU_CHANGE_DEVICE  = 1400,
         MENU_ABOUT_RENDERER = 1401,
         MENU_SHOW_FPS       = 1402,
         MENU_VSYNC          = 1403,
+        MENU_EXCLUSIVE_FULLSCREEN = 1404,
 
         // Root -> Help menu
         MENU_HELP         = 1500,
@@ -138,6 +143,7 @@
         OPTION_EXIT_ON_ESCAPE_WINDOWED     = 1705,
         OPTION_HIDE_NAVIGATION_BAR         = 1710,
         OPTION_OPEN_LAST_ON_STARTUP        = 1711,
+        OPTION_SWAP_JPS                    = 1712,
 
         // Open/Save dialogs
         DIALOG_OPEN_FILE       = 2000,
@@ -181,10 +187,11 @@
         INFO_LOAD_TIME         = 5004,
         INFO_TIME_MSEC         = 5005,
         INFO_PIXEL_RATIO       = 5006,
-        INFO_COLOR_MODEL       = 5007,
+        INFO_PIXEL_FORMAT      = 5007,
         INFO_NO_SRCFORMAT      = 5008,
         INFO_WRONG_SRCFORMAT   = 5009,
         INFO_NO_SRCFORMAT_EX   = 5011,
+        INFO_COLOR_MODEL       = 5012,
 
         // metadata keys
         METADATA_JPEG_COMMENT     = 5100,

sview-17_04.tar.gz/StImageViewer/lang/chinese/StImageViewer.lng -> sview-20_08.tar.gz/StImageViewer/lang/chinese/StImageViewer.lng Changed

sview-17_04.tar.gz/StImageViewer/lang/czech/StImageViewer.lng -> sview-20_08.tar.gz/StImageViewer/lang/czech/StImageViewer.lng Changed

@@ -48,6 +48,7 @@
 ?1252=Heal anamorphic 1080p/720p
 1260=Sousední
 1261=Lineární
+?1263=Trilinear
 1270=Resetovat nastavení
 1271=Jas
 1272=Sytost
@@ -56,15 +57,19 @@
 1281=Koule
 1282=Válec
 ?1283=Cubemap
+?1284=Hemisphere
 ?1285=Track orientation
 ?1286=Track orientation (poor)
 ?1288=Stick at panorama 360°
 ?1291=Cubemap 6x1 - flip Z
 ?1292=Cubemap 3x2 - flip Z
+?1293=Equiangular cubemap
+?1294=Theater
 1400=Zobrazovací zařizení
 1401=O modulu
 1402=Zobrazovat snímkování (fps)
 1403=Vertikální synchronizace
+?1404=Exclusive Fullscreen mode
 1500=Nápověda
 1501=O aplikaci sView…
 1502=Aktualizace
@@ -91,6 +96,7 @@
 ?1705=On one click windowed mode
 ?1710=Hide system navigation bar
 ?1711=Open last viewed file on startup
+?1712=Swap JPS/PNS views order
 2000=Otevřít
 2001=Otevřít LEVÝ
 2002=Otevřít PRAVÝ
@@ -125,10 +131,11 @@
 5004=Načítání
 5005=ms
 5006=Poměr stran pixelu
-5007=Barevný model
+5007=Formát pixelu
 5008=(metada nejsou v informaci obsažena)
 5009=(neobsahuje metadata)
 5011=(informace není obsažena v metadatech,\nale byla přidělena podle jména souboru)
+5012=Barevný model
 5100=JPEG komentář
 5101=JPS komentář
 5200=Výrobce kamery
@@ -178,3 +185,4 @@
 ?6040=X Rotation - up
 ?6041=X Rotation - down
 ?6042=Enable/disable panorama mode
+?6043=Show/hide GUI

sview-17_04.tar.gz/StImageViewer/lang/english/StImageViewer.lng -> sview-20_08.tar.gz/StImageViewer/lang/english/StImageViewer.lng Changed

@@ -47,6 +47,7 @@
 1252=Heal anamorphic 1080p/720p
 1260=Nearest
 1261=Linear
+1263=Trilinear
 1270=Reset to defaults
 1271=Brightness
 1272=Saturation
@@ -55,15 +56,19 @@
 1281=Sphere
 1282=Cylinder
 1283=Cubemap
+1284=Hemisphere
 1285=Track orientation
 1286=Track orientation (poor)
 1288=Stick at panorama 360°
 1291=Cubemap 6x1 - flip Z
 1292=Cubemap 3x2 - flip Z
+1293=Equiangular cubemap
+1294=Theater
 1400=Change device
 1401=About Plugin...
 1402=Show FPS
 1403=VSync
+1404=Exclusive Fullscreen mode
 1500=Help
 1501=About...
 1502=Check for updates
@@ -90,6 +95,7 @@
 1705=On one click windowed mode
 1710=Hide system navigation bar
 1711=Open last viewed file on startup
+1712=Swap JPS/PNS views order
 2000=Choose the image file to open
 2001=Choose LEFT image file to open
 2002=Choose RIGHT image file to open
@@ -124,10 +130,11 @@
 5004=Load time
 5005=ms
 5006=Pixel ratio
-5007=Color model
+5007=Pixel format
 5008=(does not stored in metadata)
 5009=(does not match metadata)
 5011=(does not stored in metadata,\nbut detected from file name)
+5012=Color model
 5100=JPEG Comment
 5101=JPS Comment
 5200=Camera Maker
@@ -177,3 +184,4 @@
 6040=X Rotation - up
 6041=X Rotation - down
 6042=Enable/disable panorama mode
+6043=Show/hide GUI

sview-17_04.tar.gz/StImageViewer/lang/french/StImageViewer.lng -> sview-20_08.tar.gz/StImageViewer/lang/french/StImageViewer.lng Changed

@@ -47,6 +47,7 @@
 ?1252=Heal anamorphic 1080p/720p
 1260=Plus proche
 1261=Lineaire
+1263=Trilinéaire
 1270=Rétablir par défaut
 1271=Brightness
 1272=Saturation
@@ -55,15 +56,19 @@
 1281=Sphère
 1282=Cylindre
 1283=Cubemap
+1284=Hémisphère
 ?1285=Track orientation
 ?1286=Track orientation (poor)
 ?1288=Stick at panorama 360°
 ?1291=Cubemap 6x1 - flip Z
 ?1292=Cubemap 3x2 - flip Z
+?1293=Equiangular cubemap
+1294=Théâtre
 1400=Changer la sortie
 1401=A propos du Plugin...
 1402=Voir I/S
 1403=Synchro Vert.
+?1404=Exclusive Fullscreen mode
 1500=Aide
 1501=A Propos...
 1502=Vérifier nouvelle version
@@ -90,6 +95,7 @@
 ?1705=On one click windowed mode
 ?1710=Hide system navigation bar
 ?1711=Open last viewed file on startup
+1712=JPS/PNS échange de vues pour
 2000=Choix du fichier image à ouvrir
 2001=Choix du fichier image Gauche à ouvrir
 2002=Choix du fichier image Droite à ouvrir
@@ -124,10 +130,11 @@
 5004=Temps de démarrage
 5005=ms
 5006=Pixel ratio
-5007=Modèle colorimétrique
+5007=Pixel format
 ?5008=(does not stored in metadata)
 ?5009=(does not match metadata)
 ?5011=(does not stored in metadata,\nbut detected from file name)
+5012=Modèle colorimétrique
 5100=JPEG commentaire
 5101=JPS commentaire
 5200=Camera Maker
@@ -177,3 +184,4 @@
 ?6040=X Rotation - up
 ?6041=X Rotation - down
 6042=Activer / désactiver le mode panorama
+6043=Masquer l'interface

sview-17_04.tar.gz/StImageViewer/lang/german/StImageViewer.lng -> sview-20_08.tar.gz/StImageViewer/lang/german/StImageViewer.lng Changed

@@ -47,6 +47,7 @@
 ?1252=Heal anamorphic 1080p/720p
 1260=Nearest
 1261=Linear
+1263=Trilinear
 1270=Auf Standardwerte zurücksetzen
 1271=Helligkeit
 1272=Sättigung
@@ -55,15 +56,19 @@
 1281=Kugel
 1282=Zylinder
 1283=Cubemap
+1284=Hemisphäre
 ?1285=Track orientation
 ?1286=Track orientation (poor)
 ?1288=Stick at panorama 360°
 ?1291=Cubemap 6x1 - flip Z
 ?1292=Cubemap 3x2 - flip Z
+?1293=Equiangular cubemap
+1294=Theater
 1400=Gerät ändern
 1401=Über Plugin...
 1402=FPS anzeigen
 1403=VSync
+1404=Exklusiver Vollbildmodus
 1500=Hilfe
 1501=Über...
 1502=Nach Updates suchen
@@ -90,6 +95,7 @@
 ?1705=Only when windowed
 1710=Navigationsleiste ausblenden
 ?1711=Open last viewed file on startup
+1712=JPS/PNS-Ansichten, um zu tauschen
 2000=Wählen die Bilddatei zu öffnen
 2001=Wählen die linke Bilddatei zu öffnen
 2002=Wählen die rechte Bilddatei zu öffnen
@@ -124,10 +130,11 @@
 5004=Ladezeit
 5005=ms
 5006=Pixelseitenverhältnis
-5007=Farbmodell
+5007=Pixel format
 5008=(nicht in Metadaten gespeichert)
 5009=(keine Metadaten übereinstimmen)
 5011=(nicht in Metadaten gespeichert,\nsondern von Dateinamen detektiert)
+5012=Farbmodell
 5100=JPEG Kommentar
 5101=JPS Kommentar
 5200=Kamerahersteller
@@ -177,3 +184,4 @@
 6040=X-Drehung - nach oben
 6041=X-Drehung - nach unten
 6042=Aktivieren / Deaktivieren der Panorama-Modus
+6043=GUI ausblenden

sview-17_04.tar.gz/StImageViewer/lang/korean/StImageViewer.lng -> sview-20_08.tar.gz/StImageViewer/lang/korean/StImageViewer.lng Changed

@@ -48,6 +48,7 @@
 ?1252=Heal anamorphic 1080p/720p
 ?1260=Nearest
 ?1261=Linear
+?1263=Trilinear
 1270=기본값으로 리셋
 1271=밝기
 ?1272=Saturation
@@ -56,15 +57,19 @@
 ?1281=Sphere
 ?1282=Cylinder
 ?1283=Cubemap
+?1284=Hemisphere
 ?1285=Track orientation
 ?1286=Track orientation (poor)
 ?1288=Stick at panorama 360°
 ?1291=Cubemap 6x1 - flip Z
 ?1292=Cubemap 3x2 - flip Z
+?1293=Equiangular cubemap
+?1294=Theater
 1400=장치 변경
 ?1401=About Plugin...
 ?1402=Show FPS
 ?1403=VSync
+?1404=Exclusive Fullscreen mode
 1500=도움말
 1501=이 프로그램에 대해...
 1502=업데이트 확인
@@ -91,6 +96,7 @@
 ?1705=On one click windowed mode
 ?1710=Hide system navigation bar
 ?1711=Open last viewed file on startup
+?1712=Swap JPS/PNS views order
 2000=열어볼 이미지 파일 선택
 2001=왼쪽 이미지 선택
 2002=오른쪽 이미지 선택
@@ -125,10 +131,11 @@
 ?5004=Load time
 ?5005=ms
 ?5006=Pixel ratio
-?5007=Color model
+?5007=Pixel format
 ?5008=(does not stored in metadata)
 ?5009=(does not match metadata)
 ?5011=(does not stored in metadata,\nbut detected from file name)
+?5012=Color model
 ?5100=JPEG Comment
 ?5101=JPS Comment
 ?5200=Camera Maker
@@ -178,3 +185,4 @@
 ?6040=X Rotation - up
 ?6041=X Rotation - down
 ?6042=Enable/disable panorama mode
+?6043=Show/hide GUI

sview-17_04.tar.gz/StImageViewer/lang/russian/StImageViewer.lng -> sview-20_08.tar.gz/StImageViewer/lang/russian/StImageViewer.lng Changed

@@ -45,8 +45,9 @@
 1250=Исходное
 1251=Запомнить
 ?1252=Heal anamorphic 1080p/720p
-1260=Nearest
-1261=Linear
+1260=Без сглаживания
+1261=Линейное
+1263=Трилинейное
 1270=Сбросить настройки
 1271=Яркость
 1272=Насыщенность
@@ -55,15 +56,19 @@
 1281=Сфера
 1282=Цилиндр
 1283=Куб
+1284=Полусфера
 1285=Отслеживать ориентацию
 1286=Отслеживать ориентацию (poor)
 1288=Закрепить панорамный режим 360°
 1291=Кубмапа 6x1 - инвертировать Z
 1292=Кубмапа 3x2 - инвертировать Z
+?1293=Equiangular cubemap
+1294=Киноэкран
 1400=Выбрать устройство
 1401=О модуле...
 1402=Отображать FPS
 1403=Верт. синхронизация
+1404=Эксклюзивный полноэкранный режим
 1500=Помощь
 1501=О программе...
 1502=Проверить обновления
@@ -90,6 +95,7 @@
 1705=Только в оконном режиме
 1710=Скрыть панель навигации
 1711=Открывать последний файл при старте
+1712=Поменять ракурсы местами в JPS/PNS
 2000=Выберите картинку
 2001=Выберите файл с ЛЕВЫМ ракурсом
 2002=Выберите файл с ПРАВЫМ ракурсом
@@ -124,10 +130,11 @@
 5004=Время загрузки
 5005=мс
 5006=Пропорции пикселя
-5007=Color model
+5007=Пиксельный формат
 5008=(информация отсутствует в метаданных)
 5009=(не соответствует метаданным)
 5011=(информация отсутствует в метаданных,\nно была определена по имени файла)
+5012=Color model
 5100=JPEG комментарий
 5101=JPS комментарий
 5200=Производитель камеры
@@ -177,3 +184,4 @@
 6040=X наклон - наверх
 6041=X наклон - вниз
 6042=Включить/выключить панорамный режим
+6043=Скрыть интерфейс

sview-20_08.tar.gz/StImageViewer/lang/spanish Added

sview-20_08.tar.gz/StImageViewer/lang/spanish/StImageViewer.lng Added

@@ -0,0 +1,186 @@
+# Spanish translation file for StImageViewer
+--------
+1000=Anterior imagen
+1001=Siguiente imagen
+1002=Cambiar izquierdo/derecho
+1003=Revertir cambio izquierdo/derecho
+1004=Formato estereoscópico:
+1015=Abrir otra imagen
+1028=Mostrar/Ocultar lista de reproducción
+1029=Cambiar entre\npantalla completa/ventana
+1100=Medios
+1101=Abrir imagen...
+1102=Guardar imagen como...
+1103=Formato estereoscópico
+1104=Información de la imagen
+1109=Salir
+1110=Desde un archivo
+1111=Archivos izquierdo+derecho
+1130=Fuente
+1131=Mono
+1132=Vista cruzada
+1133=Par paralelo
+1134=Sobre/bajo (D/I)
+1135=Sobre/bajo (I/D)
+1136=Entrelazado
+1137=Anaglifo rojo/cian
+1138=Anaglifo verde/rojo+azul
+1139=Anaglifo amarillo/azul
+1142=2 canales
+1200=Ver
+1201=Salida estéreo
+1202=Pantalla completa
+1203=Restablecer
+1204=Cambiar izquierdo/derecho
+1205=Relación de visualización
+1206=Filtro más suave
+1207=Ajustar imagen
+1208=Panorámica
+1210=Estéreo
+1211=Vista izquierda
+1212=Vista derecha
+1213=Par paralelo
+1214=Vista cruzada
+1250=Fuente
+1251=Conservar al reiniciar
+1252=Corregir anamórfico 1080p/720p
+1260=Más cercano
+1261=Lineal
+1263=Trilineal
+1270=Restablecer predeterminados
+1271=Brillo
+1272=Saturación
+1273=Gamma
+1280=Desactivado
+1281=Esfera
+1282=Cilindro
+1283=Cubemap
+1284=Hemisferio
+1285=Orientación de pista
+1286=Orientación de pista (deficiente)
+1288=Mantener en panorámica de 360°
+1291=Cubemap 6x1 - voltear Z
+1292=Cubemap 3x2 - voltear Z
+?1293=Equiangular cubemap
+1294=Teatro
+1400=Cambiar dispositivo
+1401=Acerca del complemento...
+1402=Mostrar FPS
+1403=Sincronización vertical
+1404=Modo de pantalla completa exclusiva
+1500=Ayuda
+1501=Acerca de...
+1502=Buscar actualizaciones
+1503=Texto de la licencia
+1504=Idioma (Language)
+1506=Consejos para el usuario
+1508=Acerca del sistema
+1509=Escala de la interfaz
+1510=Teclas de acceso rápido
+1511=Ajustes
+1520=Ahora
+1521=Cada día
+1522=Cada semana
+1523=Cada año
+1524=Nunca
+1590=Pequeño
+1591=Normal
+1592=Grande
+1593=Forzar HiDPI 2X
+1701=Salir de sView con escape
+1702=No salir
+1703=Con un clic
+1704=Con doble clic
+1705=Modo de ventana con un clic
+1710=Ocultar la barra de navegación del sistema
+1711=Abrir el último archivo visto al iniciar
+1712=JPS/PNS ve intercambio orden
+2000=Elije el archivo de imagen para abrir
+2001=Elige el archivo de la imagen IZQUIERDA para abrir
+2002=Elije el archivo de la imagen DERECHA para abrir
+2003=Información de la imagen
+2004=No hay disponible información
+2005=Eliminación de archivo
+2006=¿Realmente deseas eliminar completamente este archivo?
+2007=Guardando metadatos del archivo
+2008=¿Realmente deseas guardar los metadatos al archivo?
+2009=Los metadatos solo se pueden guardar en archivos JPEG.
+2010=Elije la ubicación para guardar la instantánea
+2011=¡Nada para guardar!
+2012=¡Instantánea no disponible!
+2013=Asignar nueva tecla de acceso rápido para la acción\n<i>{0}</i>
+2014=En conflicto con: <i>{0}</i>
+3000=sView - Visor de imágenes
+3001=versión
+3002=El visor de imágenes te permite abrir imágenes estereoscópicas en formatos JPEG, PNG, MPO y muchos más.\n © {0} Kirill Gavrilov <{1}>\nSitio oficial: {2}\n\nEste programa se distribuye bajo licencia GPL 3.0
+3003=Hay disponible una nueva versión de sView en el sitio oficial: www.sview.ru.\nPor favor, actualiza el programa.
+3004=Información del sistema
+4000=Cerrar
+4001=Cancelar
+4006=Guardar
+4007=Eliminar
+4008=Predeterminado
+4009=Predeterminados
+4010=Asignar
+5000=[izquierdo]
+5001=[derecho]
+5002=Nombre de archivo
+5003=Dimensiones
+5004=Tiempo de carga
+5005=ms
+5006=Relación de pixeles
+5007=Formato de píxel
+5008=(no almacenado en los metadatos)
+5009=(no coincide con los metadatos)
+5011=(no almacenado en los metadatos,\npero detectado en el nombre de archivo)
+5012=Modelo de color
+5100=Comentario JPEG
+5101=Comentario JPS
+5200=Marca de la cámara
+5201=Modelo de la cámara
+5202=Comentario del usuario
+5203=Marca de tiempo de la imagen
+6000=Cambiar entre pantalla completa/ventana
+6001=Mostrar/ocultar medidor de FPS
+6002=Formato estéreo: Automático
+6003=Formato estéreo: Mono
+6004=Formato estéreo: Sobre/bajo
+6005=Formato estéreo: En paralelo
+6006=Mostrar información del archivo
+6007=Lista de reproducción: Ir al primer elemento
+6008=Lista de reproducción: Ir al último elemento
+6009=Lista de reproducción: Ir al anterior elemento
+6010=Lista de reproducción: Ir al siguiente elemento
+6011=Lista de reproducción: Iniciar/Detener presentación
+6012=Guardar en formato PNG
+6013=Guardar en formato JPEG
+6014=Guardar metadatos del archivo
+6015=Eliminar el archivo del sistema de archivos
+6016=Restablecer el ajuste de la imagen
+6017=Restablecer la posición de la imagen
+6018=Cambiar izquierdo/derecho
+6019=Corrección gamma: disminuir
+6020=Corrección gamma: aumentar
+6021=Separación DX: disminuir
+6022=Separación DX: aumentar
+6023=Separación DY: disminuir
+6024=Separación DY: aumentar
+6025=Separación angular: disminuir
+6026=Separación angular: aumentar
+6027=Rotar 90° a la izquierda
+6028=Rotar 90° a la derecha
+6029=Rotar a la izquierda
+6030=Rotar a la derecha
+6031=Seleccionar el siguiente modo de visualización
+6032=Barrido: navegar hacia la izquierda
+6033=Barrido: navegar hacia la derecha
+6034=Barrido: navegar hacia arriba
+6035=Barrido: navegar hacia abajo
+6036=Escala: aumentar
+6037=Escala: reducir
+6038=Rotación Y: izquierda
+6039=Rotación Y: derecha
+6040=Rotación X: arriba
+6041=Rotación X: abajo
+6042=Activar/Desactivar modo panorámico
+6043=Mostrar/ocultar GUI

sview-17_04.tar.gz/StMoviePlayer/StMovieOpenDialog.cpp -> sview-20_08.tar.gz/StMoviePlayer/StMovieOpenDialog.cpp Changed

@@ -74,18 +74,42 @@
 }
 
 void StMovieOpenDialog::setPaths(const StString& thePathLeft,
-                                 const StString& thePathRight) {
+                                 const StString& thePathRight,
+                                 const StMovieOpenDialog::DialogState theMode) {
     StMutexAuto aLock(myMutex);
     if(myState != StMovieOpenDialog::Dialog_Inactive) {
         return;
     }
 
-    myPathVideoL = thePathLeft;
-    myPathVideoR = thePathRight;
+    myPathVideoL.clear();
+    myPathVideoR.clear();
     myPathAudio.clear();
     myPathSubs .clear();
-    if(!myPathVideoL.isEmpty()) {
-        myState = StMovieOpenDialog::Dialog_HasFiles;
+    switch(theMode) {
+        case Dialog_Audio: {
+            myPathAudio = thePathLeft;
+            if(!myPathAudio.isEmpty()) {
+                myState = StMovieOpenDialog::Dialog_HasFiles;
+            }
+            break;
+        }
+        case Dialog_Subtitles: {
+            myPathSubs = thePathLeft;
+            if(!myPathSubs.isEmpty()) {
+                myState = StMovieOpenDialog::Dialog_HasFiles;
+            }
+            break;
+        }
+        case Dialog_SingleMovie:
+        case Dialog_DoubleMovie:
+        default: {
+            myPathVideoL = thePathLeft;
+            myPathVideoR = thePathRight;
+            if(!myPathVideoL.isEmpty()) {
+                myState = StMovieOpenDialog::Dialog_HasFiles;
+            }
+            break;
+        }
     }
 }
 
@@ -101,28 +125,36 @@
     myPathAudio .clear();
     myPathSubs  .clear();
 
-    StString aTitle;
-    const StMIMEList* aMimeList = &myPlugin->myVideo->getMimeListVideo();
+    StOpenFileName anOpenInfo;
+    anOpenInfo.Folder = myFolder;
     switch(myState) {
         case Dialog_DoubleMovie:
-            aTitle = myPlugin->tr(StMoviePlayerStrings::DIALOG_OPEN_LEFT);
+            anOpenInfo.Title = myPlugin->tr(StMoviePlayerStrings::DIALOG_OPEN_LEFT);
+            anOpenInfo.Filter = myPlugin->myVideo->getMimeListVideo();
+            anOpenInfo.FilterTitle = "Video Files";
             break;
         case Dialog_Audio:
-            aTitle    = "Choose audio file to attach";
-            aMimeList = &myPlugin->myVideo->getMimeListAudio();
+            anOpenInfo.Title = myPlugin->tr(StMoviePlayerStrings::DIALOG_OPEN_AUDIO);
+            anOpenInfo.Filter = myPlugin->myVideo->getMimeListAudio();
+            anOpenInfo.FilterTitle = "Audio Files";
             break;
         case Dialog_Subtitles:
-            aTitle    = "Choose subtitles file to attach";
-            aMimeList = &myPlugin->myVideo->getMimeListSubtitles();
+            anOpenInfo.Title = myPlugin->tr(StMoviePlayerStrings::DIALOG_OPEN_SUBTITLES);
+            anOpenInfo.Filter = myPlugin->myVideo->getMimeListSubtitles();
+            anOpenInfo.FilterTitle = "Subtitle Files";
             break;
         case Dialog_SingleMovie:
         default:
-            aTitle = myPlugin->tr(StMoviePlayerStrings::DIALOG_OPEN_FILE);
+            anOpenInfo.Title = myPlugin->tr(StMoviePlayerStrings::DIALOG_OPEN_FILE);
+            anOpenInfo.Filter = myPlugin->myVideo->getMimeListVideo();
+            anOpenInfo.FilterTitle = "Video Files";
+            anOpenInfo.ExtraFilter = myPlugin->myVideo->getMimeListImages();
+            anOpenInfo.ExtraFilterTitle = "Image files";
             break;
     }
 
-    StString aFilePath, aDummy;
-    if(!StFileNode::openFileDialog(myFolder, aTitle, *aMimeList, aFilePath, false)) {
+    StString aFilePath;
+    if(!StFileNode::openFileDialog(aFilePath, anOpenInfo, false)) {
         StMutexAuto aLock(myMutex);
         myState = StMovieOpenDialog::Dialog_Inactive;
         return;
@@ -130,10 +162,12 @@
 
     switch(myState) {
         case Dialog_DoubleMovie: {
-            aTitle =  myPlugin->tr(StMoviePlayerStrings::DIALOG_OPEN_RIGHT);
+            anOpenInfo.Title = myPlugin->tr(StMoviePlayerStrings::DIALOG_OPEN_RIGHT);
+            StString aDummy;
             StFileNode::getFolderAndFile(aFilePath, myFolder, aDummy);
+            anOpenInfo.Folder = myFolder;
             myPathVideoL = aFilePath;
-            if(!StFileNode::openFileDialog(myFolder, aTitle, *aMimeList, myPathVideoR, false)) {
+            if(!StFileNode::openFileDialog(myPathVideoR, anOpenInfo, false)) {
                 StMutexAuto aLock(myMutex);
                 myState = StMovieOpenDialog::Dialog_Inactive;
                 return;

sview-17_04.tar.gz/StMoviePlayer/StMovieOpenDialog.h -> sview-20_08.tar.gz/StMoviePlayer/StMovieOpenDialog.h Changed

sview-17_04.tar.gz/StMoviePlayer/StMoviePlayer.cpp -> sview-20_08.tar.gz/StMoviePlayer/StMoviePlayer.cpp Changed

@@ -1,5 +1,5 @@
 /**
- * Copyright © 2007-2017 Kirill Gavrilov <kirill@sview.ru>
+ * Copyright © 2007-2020 Kirill Gavrilov <kirill@sview.ru>
  *
  * StMoviePlayer program is free software: you can redistribute it and/or modify
  * it under the terms of the GNU General Public License as published by
@@ -75,6 +75,7 @@
     static const char ST_ARGUMENT_FILE_DEMO[]  = "demo";
     static const char ST_ARGUMENT_FILE_PAUSE[] = "pause";
     static const char ST_ARGUMENT_FILE_PAUSED[]= "paused";
+    static const char ST_ARGUMENT_FILE_SEEK[]  = "seek";
     static const char ST_ARGUMENT_MONITOR[]    = "monitorId";
     static const char ST_ARGUMENT_WINLEFT[]    = "windowLeft";
     static const char ST_ARGUMENT_WINTOP[]     = "windowTop";
@@ -91,7 +92,19 @@
 void StMoviePlayer::doPause(const StPauseEvent& theEvent) {
     StApplication::doPause(theEvent);
     saveAllParams();
-    if(!myVideo.isNull()) {
+    if(myVideo.isNull()) {
+        return;
+    }
+
+    // pause video but keep playing audio in background
+    StWinAttr anAttribs[] = {
+        StWinAttr_ToBlockSleepSystem,  (StWinAttr )0,
+        StWinAttr_ToBlockSleepDisplay, (StWinAttr )0,
+        StWinAttr_NULL
+    };
+    myWindow->getAttributes(anAttribs);
+    if(anAttribs[1] == (StWinAttr )0
+    || anAttribs[3] != (StWinAttr )0) {
         myVideo->pushPlayEvent(ST_PLAYEVENT_PAUSE);
     }
 }
@@ -107,6 +120,7 @@
     params.SubtitlesParser->setName(tr(MENU_SUBTITLES_PARSER));
     params.SubtitlesParser->defineOption(0, tr(MENU_SUBTITLES_PLAIN_TEXT));
     params.SubtitlesParser->defineOption(1, tr(MENU_SUBTITLES_LITE_HTML));
+    params.SubtitlesApplyStereo->setName(tr(MENU_SUBTITLES_STEREO));
     params.AudioAlHrtf->setName(stCString("Audio HRTF mixing"));
     params.AudioAlHrtf->defineOption(0, stCString("Auto"));
     params.AudioAlHrtf->defineOption(1, stCString("Forced ON"));
@@ -133,6 +147,7 @@
     params.SrcStereoFormat->setName(tr(MENU_MEDIA_SRC_FORMAT));
     params.ToShowPlayList->setName(tr(VIDEO_LIST));
     params.ToShowAdjustImage->setName(tr(MENU_VIEW_IMAGE_ADJUST));
+    params.ToSwapJPS->setName(tr(OPTION_SWAP_JPS));
     params.ToStickPanorama->setName(tr(MENU_VIEW_STICK_PANORAMA360));
     params.ToTrackHead->setName(tr(MENU_VIEW_TRACK_HEAD));
     params.ToTrackHeadAudio->setName(tr(MENU_VIEW_TRACK_HEAD_AUDIO));
@@ -140,9 +155,14 @@
     params.ToShowFps->setName(tr(MENU_FPS_METER));
     params.ToShowMenu->setName(stCString("Show main menu"));
     params.ToShowTopbar->setName(stCString("Show top toolbar"));
+    params.ToShowBottom->setName(stCString("Show seekbar"));
+    params.ToMixImagesVideos->setName(stCString("Mix images & videos"));
+    params.SlideShowDelay->setName(stCString("Slideshow delay"));
     params.IsMobileUI->setName(stCString("Mobile UI"));
+    params.IsExclusiveFullScreen->setName(tr(MENU_EXCLUSIVE_FULLSCREEN));
     params.IsVSyncOn->setName(tr(MENU_FPS_VSYNC));
     params.ToLimitFps->setName(tr(MENU_FPS_BOUND));
+    params.ToSmoothUploads->setName("Smooth texture uploading");
     params.StartWebUI->setName(stCString("Web UI start option"));
     params.StartWebUI->defineOption(WEBUI_OFF,  tr(MENU_MEDIA_WEBUI_OFF));
     params.StartWebUI->defineOption(WEBUI_ONCE, tr(MENU_MEDIA_WEBUI_ONCE));
@@ -164,7 +184,7 @@
 #if defined(_WIN32)
     const StCString aGpuAcc = stCString(" (DXVA2)");
 #elif defined(__APPLE__)
-    const StCString aGpuAcc = stCString(" (VDA)");
+    const StCString aGpuAcc = stCString(" (VideoToolbox)");
 #elif defined(__ANDROID__)
     const StCString aGpuAcc = stCString(""); //stCString(" (Android Media Codec)");
 #else
@@ -229,6 +249,7 @@
     params.SubtitlesParallax->setTolerance(0.1f);
     params.ToSearchSubs = new StBoolParamNamed(true, stCString("toSearchSubs"));
     params.SubtitlesParser = new StEnumParam(1, stCString("subsParser"));
+    params.SubtitlesApplyStereo = new StBoolParamNamed(true, stCString("subsApplyStereo"));
     params.AudioAlDevice = new StALDeviceParam();
     params.AudioAlHrtf   = new StEnumParam(0, stCString("alHrtfRequest"));
     params.AudioGain = new StFloat32Param( 0.0f, // sound is unattenuated
@@ -258,6 +279,8 @@
     params.ToShowPlayList->signals.onChanged = stSlot(this, &StMoviePlayer::doShowPlayList);
     params.ToShowAdjustImage = new StBoolParamNamed(false, stCString("showAdjustImage"));
     params.ToShowAdjustImage->signals.onChanged = stSlot(this, &StMoviePlayer::doShowAdjustImage);
+    params.ToSwapJPS  = new StBoolParamNamed(false, stCString("toSwapJPS"));
+    params.ToSwapJPS->signals.onChanged = stSlot(this, &StMoviePlayer::doChangeSwapJPS);
     params.ToStickPanorama  = new StBoolParamNamed(false, stCString("toStickPano360"));
     params.ToStickPanorama->signals.onChanged = stSlot(this, &StMoviePlayer::doChangeStickPano360);
     params.ToTrackHead      = new StBoolParamNamed(true,  stCString("toTrackHead"));
@@ -266,14 +289,25 @@
     params.ToShowFps   = new StBoolParamNamed(false, stCString("toShowFps"));
     params.ToShowMenu  = new StBoolParamNamed(true,  stCString("toShowMenu"));
     params.ToShowTopbar= new StBoolParamNamed(true,  stCString("toShowTopbar"));
+    params.ToShowBottom= new StBoolParamNamed(true,  stCString("toShowBottom"));
+    params.ToMixImagesVideos = new StBoolParamNamed(false,  stCString("toMixImagesVideos"));
+    params.ToMixImagesVideos->signals.onChanged = stSlot(this, &StMoviePlayer::doChangeMixImagesVideos);
+    params.SlideShowDelay = new StFloat32Param(4.0f, stCString("slideShowDelay2"));
+    params.SlideShowDelay->setMinMaxValues(1.0f, 10.0f);
+    params.SlideShowDelay->setDefValue(4.0f);
+    params.SlideShowDelay->setStep(1.0f);
+    params.SlideShowDelay->setTolerance(0.1f);
+    params.SlideShowDelay->setFormat(stCString("%01.1f s"));
     params.IsMobileUI  = new StBoolParamNamed(StWindow::isMobile(), stCString("isMobileUI"));
     params.IsMobileUI->signals.onChanged = stSlot(this, &StMoviePlayer::doChangeMobileUI);
     params.IsMobileUISwitch = new StBoolParam(params.IsMobileUI->getValue());
     params.IsMobileUISwitch->signals.onChanged = stSlot(this, &StMoviePlayer::doScaleHiDPI);
+    params.IsExclusiveFullScreen = new StBoolParamNamed(false, stCString("isExclusiveFullScreen"));
     params.IsVSyncOn   = new StBoolParamNamed(true, stCString("vsync"));
     params.IsVSyncOn->signals.onChanged = stSlot(this, &StMoviePlayer::doSwitchVSync);
     StApplication::params.VSyncMode->setValue(StGLContext::VSync_ON);
     params.ToLimitFps       = new StBoolParamNamed(true, stCString("toLimitFps"));
+    params.ToSmoothUploads  = new StBoolParamNamed(true, stCString("toSmoothUploads"));
     params.StartWebUI       = new StEnumParam(WEBUI_OFF, stCString("webuiOn"));
     params.ToPrintWebErrors = new StBoolParamNamed(true,  stCString("webuiShowErrors"));
     params.IsLocalWebUI     = new StBoolParamNamed(false, stCString("isLocalWebUI"));
@@ -322,17 +356,23 @@
     mySettings->loadParam (params.SubtitlesSize);
     mySettings->loadParam (params.SubtitlesParallax);
     mySettings->loadParam (params.SubtitlesParser);
+    mySettings->loadParam (params.SubtitlesApplyStereo);
     mySettings->loadParam (params.ToSearchSubs);
 
     myToCheckPoorOrient = !mySettings->loadParam(params.ToTrackHead);
+    mySettings->loadParam (params.ToSwapJPS);
     mySettings->loadParam (params.ToStickPanorama);
     mySettings->loadParam (params.ToTrackHeadAudio);
     mySettings->loadParam (params.ToForceBFormat);
     mySettings->loadParam (params.AudioAlHrtf);
     mySettings->loadParam (params.ToShowFps);
+    mySettings->loadParam (params.SlideShowDelay);
+    mySettings->loadParam (params.ToMixImagesVideos);
     mySettings->loadParam (params.IsMobileUI);
+    mySettings->loadParam (params.IsExclusiveFullScreen);
     mySettings->loadParam (params.IsVSyncOn);
     mySettings->loadParam (params.ToLimitFps);
+    mySettings->loadParam (params.ToSmoothUploads);
     mySettings->loadParam (params.UseGpu);
     mySettings->loadParam (params.UseOpenJpeg);
 
@@ -395,6 +435,9 @@
     anAction = new StActionBool(stCString("DoShowFPS"), params.ToShowFps);
     addAction(Action_ShowFps, anAction, ST_VK_F12);
 
+    anAction = new StActionIntSlot(stCString("DoShowGUI"), stSlot(this, &StMoviePlayer::doShowHideGUI), 0);
+    addAction(Action_ShowGUI, anAction, ST_VK_TILDE);
+
     anAction = new StActionIntValue(stCString("DoSrcAuto"), params.SrcStereoFormat, StFormat_AUTO);
     addAction(Action_SrcAuto, anAction, ST_VK_A);
 
@@ -500,6 +543,23 @@
 
     anAction = new StActionIntSlot(stCString("DoPanoramaOnOff"), stSlot(this, &StMoviePlayer::doPanoramaOnOff), 0);
     addAction(Action_PanoramaOnOff, anAction, ST_VK_P);
+
+    {
+    anAction = new StActionIntSlot(stCString("DoOutStereoNormal"), stSlot(this, &StMoviePlayer::doSetStereoOutput), StGLImageRegion::MODE_STEREO);
+    addAction(Action_OutStereoNormal, anAction);
+
+    anAction = new StActionIntSlot(stCString("DoOutStereoLeftView"), stSlot(this, &StMoviePlayer::doSetStereoOutput), StGLImageRegion::MODE_ONLY_LEFT);
+    addAction(Action_OutStereoLeftView, anAction);
+
+    anAction = new StActionIntSlot(stCString("DoOutStereoRightView"), stSlot(this, &StMoviePlayer::doSetStereoOutput), StGLImageRegion::MODE_ONLY_RIGHT);
+    addAction(Action_OutStereoRightView, anAction);
+
+    anAction = new StActionIntSlot(stCString("DoOutStereoParallelPair"), stSlot(this, &StMoviePlayer::doSetStereoOutput), StGLImageRegion::MODE_PARALLEL);
+    addAction(Action_OutStereoParallelPair, anAction);
+
+    anAction = new StActionIntSlot(stCString("DoOutStereoCrossEyed"), stSlot(this, &StMoviePlayer::doSetStereoOutput), StGLImageRegion::MODE_CROSSYED);
+    addAction(Action_OutStereoCrossEyed, anAction);
+    }
 }
 
 bool StMoviePlayer::resetDevice() {
@@ -544,6 +604,7 @@
         mySettings->saveParam (params.SubtitlesSize);
         mySettings->saveParam (params.SubtitlesParallax);
         mySettings->saveParam (params.SubtitlesParser);
+        mySettings->saveParam (params.SubtitlesApplyStereo);
         mySettings->saveParam (params.ToSearchSubs);
         mySettings->saveParam (params.TargetFps);
         mySettings->saveString(params.AudioAlDevice->getKey(), params.AudioAlDevice->getUtfTitle());
@@ -557,14 +618,19 @@
         mySettings->saveParam (params.ToShowPlayList);
         mySettings->saveParam (params.ToShowAdjustImage);
 
+        mySettings->saveParam (params.ToSwapJPS);
         mySettings->saveParam (params.ToStickPanorama);
         mySettings->saveParam (params.ToTrackHead);
         mySettings->saveParam (params.ToTrackHeadAudio);
         mySettings->saveParam (params.ToForceBFormat);
         mySettings->saveParam (params.ToShowFps);
+        mySettings->saveParam (params.SlideShowDelay);
+        mySettings->saveParam (params.ToMixImagesVideos);
         mySettings->saveParam (params.IsMobileUI);
+        mySettings->saveParam (params.IsExclusiveFullScreen);
         mySettings->saveParam (params.IsVSyncOn);
         mySettings->saveParam (params.ToLimitFps);
+        mySettings->saveParam (params.ToSmoothUploads);
         mySettings->saveParam (params.UseGpu);
         mySettings->saveParam (params.UseOpenJpeg);
         if(!params.IsLocalWebUI->getValue()) {
@@ -650,6 +716,12 @@
     }
 
     myGUI->stglInit();
+    StRectF_t aFrustL, aFrustR;
+    if(myWindow->getCustomProjection(aFrustL, aFrustR)) {
+        myGUI->changeCamera()->setCustomProjection(aFrustL, aFrustR);
+    } else {
+        myGUI->changeCamera()->resetCustomProjection();
+    }
     myGUI->stglResize(myWindow->stglViewport(ST_WIN_MASTER), myWindow->getMargins(), (float )myWindow->stglAspectRatio());
 
     for(size_t anIter = 0; anIter < myGUI->myImage->getActions().size(); ++anIter) {
@@ -690,7 +762,9 @@
         return;
     }
 
+    const bool isReadOnly = StFileNode::isFileReadOnly(myFileToDelete->getPath());
     const StString aText = myLangMap->getValue(StMoviePlayerStrings::DIALOG_DELETE_FILE_QUESTION)
+                         + (isReadOnly ? "\nWARNING! The file is READ ONLY!" : "")
                          + "\n" + myFileToDelete->getPath();
 
     StGLMessageBox* aDialog = new StGLMessageBox(myGUI.access(), myLangMap->getValue(StMoviePlayerStrings::DIALOG_DELETE_FILE_TITLE),
@@ -706,6 +780,7 @@
         return;
     }
 
+    StFileNode::removeReadOnlyFlag(myFileToDelete->getPath());
     myVideo->doRemovePhysically(myFileToDelete);
     myFileToDelete.nullify();
 }
@@ -824,8 +899,11 @@
         myVideo->params.UseOpenJpeg  = params.UseOpenJpeg;
         myVideo->params.ToSearchSubs = params.ToSearchSubs;
         myVideo->params.ToTrackHeadAudio = params.ToTrackHeadAudio;
+        myVideo->params.SlideShowDelay = params.SlideShowDelay;
+        myVideo->setSwapJPS(params.ToSwapJPS->getValue());
         myVideo->setStickPano360(params.ToStickPanorama->getValue());
         myVideo->setForceBFormat(params.ToForceBFormat->getValue());
+        doChangeMixImagesVideos(params.ToMixImagesVideos->getValue());
 
     #ifdef ST_HAVE_MONGOOSE
         doStartWebUI();
@@ -850,7 +928,7 @@
     // load this parameter AFTER video thread creation
     mySettings->loadParam(params.SrcStereoFormat);
 
-#if !defined(ST_NO_UPDATES_CHECK)
+#if defined(ST_UPDATES_CHECK)
     // read the current time
     time_t aRawtime;
     time(&aRawtime);
@@ -876,6 +954,7 @@
     StArgument anArgBenchmark  = theArguments[params.Benchmark->getKey()];
     StArgument anArgShowMenu   = theArguments[params.ToShowMenu->getKey()];
     StArgument anArgShowTopbar = theArguments[params.ToShowTopbar->getKey()];
+    StArgument anArgMixImages  = theArguments[params.ToMixImagesVideos->getKey()];
 
     StArgument anArgFullscreen = theArguments[params.IsFullscreen->getKey()];
     StArgument anArgMonitor    = theArguments[ST_ARGUMENT_MONITOR];
@@ -941,6 +1020,9 @@
     if(anArgShowTopbar.isValid()) {
         params.ToShowTopbar->setValue(!anArgShowTopbar.isValueOff());
     }
+    if(anArgMixImages.isValid()) {
+        params.ToMixImagesVideos->setValue(!anArgMixImages.isValueOff());
+    }
 }
 
 bool StMoviePlayer::open() {
@@ -979,6 +1061,8 @@
             doOpenRecent(0); // open last opened file
             if(isPaused) {
                 myVideo->pushPlayEvent(ST_PLAYEVENT_PAUSE);
+            } else if(!anArgLast.isValid() && !anArgPause.isValid() && !anArgPaused.isValid()) {
+                myVideo->pushPlayEvent(ST_PLAYEVENT_PAUSE);
             }
         }
         return true;
@@ -988,8 +1072,13 @@
     myPlayList->clear();
 
     //StArgument argFile1     = myOpenFileInfo->getArgumentsMap()[ST_ARGUMENT_FILE + 1]; // playlist?
-    StArgument argFileLeft  = myOpenFileInfo->getArgumentsMap()[ST_ARGUMENT_FILE_LEFT];
-    StArgument argFileRight = myOpenFileInfo->getArgumentsMap()[ST_ARGUMENT_FILE_RIGHT];
+    const StArgument argFileLeft  = myOpenFileInfo->getArgumentsMap()[ST_ARGUMENT_FILE_LEFT];
+    const StArgument argFileRight = myOpenFileInfo->getArgumentsMap()[ST_ARGUMENT_FILE_RIGHT];
+    const StArgument anArgSeek    = myOpenFileInfo->getArgumentsMap()[ST_ARGUMENT_FILE_SEEK];
+    if(anArgSeek.isValid()) {
+        StCLocale aCLocale;
+        mySeekOnLoad = stStringToDouble(anArgSeek.getValue().toCString(), aCLocale);
+    }
     if(argFileLeft.isValid() && argFileRight.isValid()) {
         // meta-file
         const size_t aRecent = myPlayList->findRecent(argFileLeft.getValue(), argFileRight.getValue());
@@ -1002,19 +1091,50 @@
         }
         myPlayList->addOneFile(argFileLeft.getValue(), argFileRight.getValue());
     } else if(!anOpenMIME.isEmpty()) {
+        // handle URI with #t=SECONDS tail
+        StString aFilePath = myOpenFileInfo->getPath();
+        StHandle< StArrayList<StString> > anUriParams = aFilePath.split('#', 2);
+        if(anUriParams->size() == 2) {
+            aFilePath = anUriParams->getFirst();
+            StString aParams = anUriParams->getLast();
+            if(aParams.isStartsWith(stCString("t="))) {
+                StCLocale aCLocale;
+                mySeekOnLoad = stStringToDouble(aParams.toCString() + 2, aCLocale);
+            }
+        }
+
         // create just one-file playlist
         myPlayList->addOneFile(myOpenFileInfo->getPath(), anOpenMIME);
     } else {
+        // handle URI with #t=SECONDS tail
+        StString aFilePath = myOpenFileInfo->getPath();
+        double aSeekPos = -1.0;
+        StHandle< StArrayList<StString> > anUriParams = aFilePath.split('#', 2);
+        if(anUriParams->size() == 2) {
+            aFilePath = anUriParams->getFirst();
+            StString aParams = anUriParams->getLast();
+            if(aParams.isStartsWith(stCString("t="))) {
+                StCLocale aCLocale;
+                aSeekPos = stStringToDouble(aParams.toCString() + 2, aCLocale);
+            }
+        }
+
         // create playlist from file's folder
-        const size_t aRecent = myPlayList->findRecent(myOpenFileInfo->getPath());
+        const size_t aRecent = myPlayList->findRecent(aFilePath);
         if(aRecent != size_t(-1)) {
             doOpenRecent(aRecent);
+            if(aSeekPos >= 0.0) {
+                mySeekOnLoad = aSeekPos;
+            }
             if(isPaused) {
                 myVideo->pushPlayEvent(ST_PLAYEVENT_PAUSE);
             }
             return true;
         }
-        myPlayList->open(myOpenFileInfo->getPath());
+        if(aSeekPos >= 0.0) {
+            mySeekOnLoad = aSeekPos;
+        }
+        myPlayList->open(aFilePath);
     }
 
     if(!myPlayList->isEmpty()) {
@@ -1039,6 +1159,12 @@
     if(toMobileGui != wasMobileGui) {
         doChangeMobileUI(params.IsMobileUI->getValue());
     } else {
+        StRectF_t aFrustL, aFrustR;
+        if(myWindow->getCustomProjection(aFrustL, aFrustR)) {
+            myGUI->changeCamera()->setCustomProjection(aFrustL, aFrustR);
+        } else {
+            myGUI->changeCamera()->resetCustomProjection();
+        }
         myGUI->stglResize(myWindow->stglViewport(ST_WIN_MASTER), myWindow->getMargins(), (float )myWindow->stglAspectRatio());
     }
 }
@@ -1134,20 +1260,8 @@
 }
 
 void StMoviePlayer::doGesture(const StGestureEvent& theEvent) {
-    if(myGUI.isNull()
-    || myGUI->myImage == NULL) {
-        return;
-    }
-
-    for(StGLWidget *aChildIter(myGUI->getChildren()->getLast()), *aChildActive(NULL); aChildIter != NULL;) {
-        aChildActive = aChildIter;
-        aChildIter   = aChildIter->getPrev();
-        if(aChildActive->isVisibleAndPointIn(myGUI->getCursorZo())) {
-            if(aChildActive == myGUI->myImage) {
-                myGUI->myImage->doGesture(theEvent);
-            }
-            break;
-        }
+    if(!myGUI.isNull()) {
+        myGUI->doGesture(theEvent);
     }
 }
 
@@ -1237,11 +1351,30 @@
         return;
     }
 
+    // handle URI with #t=SECONDS tail
+    double aSeekPos = -1.0;
+    StHandle< StArrayList<StString> > anUriParams = aText.split('#', 2);
+    if(anUriParams->size() == 2) {
+        aText = anUriParams->getFirst();
+        StString aParams = anUriParams->getLast();
+        if(aParams.isStartsWith(stCString("t="))) {
+            StCLocale aCLocale;
+            aSeekPos = stStringToDouble(aParams.toCString() + 2, aCLocale);
+        }
+    }
+
     const size_t aRecent = myPlayList->findRecent(aText);
     if(aRecent != size_t(-1)) {
         doOpenRecent(aRecent);
+        if(aSeekPos >= 0.0) {
+            mySeekOnLoad = aSeekPos;
+        }
         return;
     }
+
+    if(aSeekPos >= 0.0) {
+        mySeekOnLoad = aSeekPos;
+    }
     myPlayList->open(aText);
     if(!myPlayList->isEmpty()) {
         doUpdateStateLoading();
@@ -1292,19 +1425,29 @@
             return;
         }
 
+        if(!myPlayList->checkExtension(aFile1)
+         && myVideo->getMimeListImages().checkExtension(anExt1)) {
+            // redirect to StMoviePlayer
+            myOpenFileOtherApp = new StOpenInfo();
+            StArgumentsMap anArgs;
+            anArgs.add(StArgument("in", "image"));
+            myOpenFileOtherApp->setArgumentsMap(anArgs);
+            myOpenFileOtherApp->setPath(aFile1);
+            exit(0);
+            return;
+        }
+
         // just open the path
-        //if(myPlayList->checkExtension(aFile1)) {
-            const size_t aRecent = myPlayList->findRecent(aFile1);
-            if(aRecent != size_t(-1)) {
-                doOpenRecent(aRecent);
-                return;
-            }
+        const size_t aRecent = myPlayList->findRecent(aFile1);
+        if(aRecent != size_t(-1)) {
+            doOpenRecent(aRecent);
+            return;
+        }
 
-            myPlayList->open(aFile1);
-            doUpdateStateLoading();
-            myVideo->pushPlayEvent(ST_PLAYEVENT_RESUME);
-            myVideo->doLoadNext();
-        //}
+        myPlayList->open(aFile1);
+        doUpdateStateLoading();
+        myVideo->pushPlayEvent(ST_PLAYEVENT_RESUME);
+        myVideo->doLoadNext();
         return;
     } else if(theEvent.NbFiles == 2
           && !StFolder::isFolder(aFile2)
@@ -1343,6 +1486,7 @@
             myPlayList->addOneFile(aPath, StMIME());
         }
     }
+
     doUpdateStateLoading();
     myVideo->pushPlayEvent(ST_PLAYEVENT_RESUME);
     myVideo->doLoadNext();
@@ -1399,8 +1543,19 @@
             myPlayList->clear();
             myPlayList->addOneFile(myOpenDialog->getPathLeft(), myOpenDialog->getPathRight());
         } else {
-            aFilePath = myOpenDialog->getPathLeft();
-            myPlayList->open(myOpenDialog->getPathLeft());
+            if(!myPlayList->checkExtension(myOpenDialog->getPathLeft())
+             && myVideo->getMimeListImages().checkExtension(StFileNode::getExtension(myOpenDialog->getPathLeft()))) {
+                // redirect to StImageViewer
+                myOpenFileOtherApp = new StOpenInfo();
+                StArgumentsMap anArgs;
+                anArgs.add(StArgument("in", "image"));
+                myOpenFileOtherApp->setArgumentsMap(anArgs);
+                myOpenFileOtherApp->setPath(myOpenDialog->getPathLeft());
+                exit(0);
+            } else {
+                aFilePath = myOpenDialog->getPathLeft();
+                myPlayList->open(myOpenDialog->getPathLeft());
+            }
         }
 
         doUpdateStateLoading();
@@ -1508,6 +1663,9 @@
     }
     myWindow->setStereoOutput(hasStereoSource);
 
+    const double aDispMaxFps = myWindow->getMaximumTargetFps();
+    double aTargetFps = myVideo->getAverFps();
+    int aMaxUploadFrames = int((double(aDispMaxFps) + 0.1) / stMax(aTargetFps, 1.0));
     if(params.Benchmark->getValue()
     || !params.ToLimitFps->getValue()) {
         // do not limit FPS
@@ -1515,25 +1673,39 @@
     } else if(params.TargetFps->getValue() >= 1
            && params.TargetFps->getValue() <= 3) {
         // set rendering FPS to 2x averageFPS
-        double aTargetFps = myVideo->getAverFps();
+        const bool toTrackOrientation = myWindow->toTrackOrientation();
         if(aTargetFps < 17.0
         || aTargetFps > 120.0) {
             aTargetFps = 0.0;
         } else if(aTargetFps < 40.0) {
+            if(!toTrackOrientation) {
+                aMaxUploadFrames = 2; // maximum 2 frames to upload single frame
+            }
             aTargetFps *= double(params.TargetFps->getValue());
+        } else {
+            if(!toTrackOrientation) {
+                aMaxUploadFrames = 1; // uploads should be done within single frame
+            }
         }
 
-        if(myWindow->toTrackOrientation()) {
+        if(toTrackOrientation) {
             // do not limit FPS within head-tracking mode
             aTargetFps = 0.0;
+        } else if(aTargetFps > aDispMaxFps) {
+            aTargetFps = 0.0;
         }
 
         myWindow->setTargetFps(aTargetFps);
     } else {
         // set rendering FPS to set value in settings
         myWindow->setTargetFps(double(params.TargetFps->getValue()));
+        aMaxUploadFrames = 1; // uploads should be done within single frame
     }
 
+    if(!params.ToSmoothUploads->getValue()) {
+        aMaxUploadFrames = 1;
+    }
+    myVideo->getTextureQueue()->getUploadParams().MaxUploadIterations = stMax(stMin(aMaxUploadFrames, 3), 1);
 }
 
 void StMoviePlayer::doUpdateOpenALDeviceList(const size_t ) {
@@ -1713,6 +1885,14 @@
     }
 }
 
+void StMoviePlayer::doSwitchViewMode(const int32_t theMode) {
+    if(myVideo.isNull()) {
+        return;
+    }
+
+    myVideo->setTheaterMode(theMode == StViewSurface_Theater);
+}
+
 void StMoviePlayer::doPanoramaOnOff(const size_t ) {
     if(myVideo.isNull()) {
         return;
@@ -1734,9 +1914,7 @@
     StPanorama aPano = st::probePanorama(aParams->StereoFormat,
                                          aParams->Src1SizeX, aParams->Src1SizeY,
                                          aParams->Src2SizeX, aParams->Src2SizeY);
-    myGUI->myImage->params.ViewMode->setValue(aPano == StPanorama_Cubemap6_1 || aPano == StPanorama_Cubemap3_2
-                                            ? StViewSurface_Cubemap
-                                            : StViewSurface_Sphere);
+    myGUI->myImage->params.ViewMode->setValue(StStereoParams::getViewSurfaceForPanoramaSource(aPano, true));
 }
 
 void StMoviePlayer::doChangeStickPano360(const bool ) {
@@ -1747,6 +1925,14 @@
     myVideo->setStickPano360(params.ToStickPanorama->getValue());
 }
 
+void StMoviePlayer::doChangeSwapJPS(const bool ) {
+    if(myVideo.isNull()) {
+        return;
+    }
+
+    myVideo->setSwapJPS(params.ToSwapJPS->getValue());
+}
+
 void StMoviePlayer::doSwitchSrcFormat(const int32_t theSrcFormat) {
     myVideo->setStereoFormat(StFormat(theSrcFormat));
     double aDuration = 0.0;
@@ -1760,6 +1946,13 @@
     }
 }
 
+void StMoviePlayer::doSetStereoOutput(const size_t theMode) {
+    if(myVideo.isNull()) {
+        return;
+    }
+    myGUI->myImage->params.DisplayMode->setValue((int32_t )theMode);
+}
+
 void StMoviePlayer::doScaleGui(const int32_t ) {
     if(myGUI.isNull()) {
         return;
@@ -1778,6 +1971,22 @@
     myToRecreateMenu = true;
 }
 
+void StMoviePlayer::doChangeMixImagesVideos(const bool theToMix) {
+    if(myVideo.isNull()) {
+        return;
+    }
+    if(theToMix) {
+        StArrayList<StString> aMediaExt = myVideo->getMimeListVideo().getExtensionsList();
+        StArrayList<StString> anImgExt  = myVideo->getMimeListImages().getExtensionsList();
+        for(size_t anExtIter = 0; anExtIter < anImgExt.size(); ++anExtIter) {
+            aMediaExt.add(anImgExt.getValue(anExtIter));
+        }
+        myPlayList->setExtensions(aMediaExt);
+    } else {
+        myPlayList->setExtensions(myVideo->getMimeListVideo().getExtensionsList());
+    }
+}
+
 void StMoviePlayer::doLoaded() {
     myEventLoaded.set();
 }
@@ -1810,23 +2019,45 @@
     }
 }
 
+void StMoviePlayer::doShowHideGUI(const size_t ) {
+    const bool toShow = !params.ToShowMenu->getValue() || (!myGUI.isNull() && !myGUI->isVisibleGUI());
+    params.ToShowMenu->setValue(toShow);
+    params.ToShowTopbar->setValue(toShow);
+    params.ToShowBottom->setValue(toShow);
+    if(toShow && !myGUI.isNull()) {
+        myGUI->setVisibility(myWindow->getMousePos(), false, true);
+    }
+}
+
 void StMoviePlayer::doQuit(const size_t ) {
     StApplication::exit(0);
 }
 
 void StMoviePlayer::doOpen1FileFromGui(StHandle<StString> thePath) {
-    myOpenDialog->setPaths(*thePath, "");
+    myOpenDialog->setPaths(*thePath, "", StMovieOpenDialog::Dialog_SingleMovie);
+}
+
+void StMoviePlayer::doOpen1AudioFromGui(StHandle<StString> thePath) {
+    myOpenDialog->setPaths(*thePath, "", StMovieOpenDialog::Dialog_Audio);
+}
+
+void StMoviePlayer::doOpen1SubtitleFromGui(StHandle<StString> thePath) {
+    myOpenDialog->setPaths(*thePath, "", StMovieOpenDialog::Dialog_Subtitles);
 }
 
 void StMoviePlayer::doOpen1FileAction(const size_t ) {
     if(!myGUI.isNull() && (myWindow->isFullScreen() || myGUI->isMobile())) {
-        myGUI->doOpenFile(0);
+        myGUI->doOpenFile(StMovieOpenDialog::Dialog_SingleMovie);
         return;
     }
     myOpenDialog->openDialog(StMovieOpenDialog::Dialog_SingleMovie);
 }
 
 void StMoviePlayer::doOpen2Files(const size_t ) {
+    if(!myGUI.isNull() && (myWindow->isFullScreen() || myGUI->isMobile())) {
+        //myGUI->doOpenFile(StMovieOpenDialog::Dialog_DoubleMovie);
+        //return;
+    }
     myOpenDialog->openDialog(StMovieOpenDialog::Dialog_DoubleMovie);
 }
 
@@ -1858,10 +2089,18 @@
 }
 
 void StMoviePlayer::doAddAudioStream(const size_t ) {
+    if(!myGUI.isNull() && (myWindow->isFullScreen() || myGUI->isMobile())) {
+        myGUI->doOpenFile(StMovieOpenDialog::Dialog_Audio);
+        return;
+    }
     myOpenDialog->openDialog(StMovieOpenDialog::Dialog_Audio);
 }
 
 void StMoviePlayer::doAddSubtitleStream(const size_t ) {
+    if(!myGUI.isNull() && (myWindow->isFullScreen() || myGUI->isMobile())) {
+        myGUI->doOpenFile(StMovieOpenDialog::Dialog_Subtitles);
+        return;
+    }
     myOpenDialog->openDialog(StMovieOpenDialog::Dialog_Subtitles);
 }
 
@@ -1914,6 +2153,7 @@
 
 void StMoviePlayer::doFullscreen(const bool theIsFullscreen) {
     if(!myWindow.isNull()) {
+        myWindow->setAttribute(StWinAttr_ExclusiveFullScreen, params.IsExclusiveFullScreen->getValue());
         myWindow->setFullScreen(theIsFullscreen);
     }
 }
@@ -2007,6 +2247,11 @@
         const long aVol = stStringToLong(aQuery.toCString(), 10, aCLocale);
         params.AudioGain->setValue(volumeToGain(params.AudioGain, GLfloat(aVol) * 0.01f));
         aContent = "audio set volume...";
+    } else if(anURI.isEquals(stCString("/seek"))) {
+        StCLocale aCLocale;
+        const double aPosSec = stStringToDouble(aQuery.toCString(), aCLocale);
+        myVideo->pushPlayEvent(ST_PLAYEVENT_SEEK, aPosSec);
+        aContent = "seek to position...";
     } else if(anURI.isEquals(stCString("/fullscr_win"))) {
         invokeAction(Action_Fullscreen);
         aContent = "switch fullscreen/windowed...";

sview-17_04.tar.gz/StMoviePlayer/StMoviePlayer.h -> sview-20_08.tar.gz/StMoviePlayer/StMoviePlayer.h Changed

@@ -1,5 +1,5 @@
 /**
- * Copyright © 2007-2017 Kirill Gavrilov <kirill@sview.ru>
+ * Copyright © 2007-2020 Kirill Gavrilov <kirill@sview.ru>
  *
  * StMoviePlayer program is free software: you can redistribute it and/or modify
  * it under the terms of the GNU General Public License as published by
@@ -124,11 +124,14 @@
     ST_LOCAL void doSubtitlesNext(size_t theDirection);
     ST_LOCAL void doSubtitlesCopy(size_t dummy = 0);
     ST_LOCAL void doFromClipboard(size_t dummy = 0);
+    ST_LOCAL void doShowHideGUI(const size_t dummy = 0);
 
     ST_LOCAL void doQuit(const size_t dummy = 0);
 
     ST_LOCAL void doFileNext();
     ST_LOCAL void doOpen1FileFromGui(StHandle<StString> thePath);
+    ST_LOCAL void doOpen1AudioFromGui(StHandle<StString> thePath);
+    ST_LOCAL void doOpen1SubtitleFromGui(StHandle<StString> thePath);
     ST_LOCAL void doOpen1FileAction(const size_t dummy = 0);
     ST_LOCAL void doOpen2Files(const size_t dummy = 0);
     ST_LOCAL void doSaveFileInfo(const size_t theToSave);
@@ -186,6 +189,7 @@
         StHandle<StFloat32Param>      SubtitlesParallax; //!< subtitles parallax
         StHandle<StBoolParamNamed>    ToSearchSubs;      //!< automatically search for additional subtitles/audio track files nearby video file
         StHandle<StEnumParam>         SubtitlesParser;   //!< subtitles parser
+        StHandle<StBoolParamNamed>    SubtitlesApplyStereo; //!<  apply stereoscopic format of video to image subtitles
         StHandle<StALDeviceParam>     AudioAlDevice;     //!< active OpenAL device
         StHandle<StEnumParam>         AudioAlHrtf;       //!< OpenAL HRTF flag
         StHandle<StFloat32Param>      AudioGain;         //!< volume factor
@@ -200,6 +204,7 @@
         StHandle<StEnumParam>         CheckUpdatesDays;  //!< days count between updates checks
         StHandle<StInt32ParamNamed>   LastUpdateDay;     //!< the last time update has been checked
         StHandle<StInt32ParamNamed>   SrcStereoFormat;   //!< source format
+        StHandle<StBoolParamNamed>    ToSwapJPS;         //!< swap JPS views order
         StHandle<StBoolParamNamed>    ToStickPanorama;   //!< force panorama input for all files
         StHandle<StBoolParamNamed>    ToTrackHead;       //!< enable/disable head-tracking
         StHandle<StBoolParamNamed>    ToTrackHeadAudio;  //!< enable/disable head-tracking for audio listener
@@ -209,9 +214,14 @@
         StHandle<StBoolParamNamed>    ToShowFps;         //!< display FPS meter
         StHandle<StBoolParamNamed>    ToShowMenu;        //!< show main menu
         StHandle<StBoolParamNamed>    ToShowTopbar;      //!< show topbar
+        StHandle<StBoolParamNamed>    ToShowBottom;      //!< show bottom (seekbar)
+        StHandle<StBoolParamNamed>    ToMixImagesVideos; //!< mix videos and images
+        StHandle<StFloat32Param>      SlideShowDelay;    //!< slideshow delay
         StHandle<StBoolParamNamed>    IsMobileUI;        //!< display mobile interface (user option)
         StHandle<StBoolParam>         IsMobileUISwitch;  //!< display mobile interface (actual value)
+        StHandle<StBoolParamNamed>    IsExclusiveFullScreen; //!< exclusive fullscreen mode
         StHandle<StBoolParamNamed>    ToLimitFps;        //!< limit CPU usage or not
+        StHandle<StBoolParamNamed>    ToSmoothUploads;   //!< smooth texture uploads
         StHandle<StBoolParamNamed>    IsVSyncOn;         //!< flag to use VSync
         StHandle<StEnumParam>         StartWebUI;        //!< to start Web UI or not
         StHandle<StBoolParamNamed>    ToPrintWebErrors;  //!< print Web UI starting errors
@@ -285,6 +295,7 @@
     ST_LOCAL void doScaleGui(const int32_t );
     ST_LOCAL void doChangeMobileUI(const bool );
     ST_LOCAL void doScaleHiDPI(const bool );
+    ST_LOCAL void doChangeMixImagesVideos(const bool );
     ST_LOCAL void doSwitchVSync(const bool theValue);
     ST_LOCAL void doSwitchAudioDevice(const int32_t theDevId);
     ST_LOCAL void doSwitchAudioAlHrtf(const int32_t theValue);
@@ -296,8 +307,11 @@
     ST_LOCAL void doSwitchLoopSingle(const bool theValue);
     ST_LOCAL void doFullscreen(const bool theIsFullscreen);
     ST_LOCAL void doSwitchSrcFormat(const int32_t theSrcFormat);
+    ST_LOCAL void doSetStereoOutput(const size_t theMode);
+    ST_LOCAL void doSwitchViewMode(const int32_t theMode);
     ST_LOCAL void doPanoramaOnOff(const size_t );
     ST_LOCAL void doChangeStickPano360(const bool );
+    ST_LOCAL void doChangeSwapJPS(const bool );
     ST_LOCAL void doSwitchAudioStream(const int32_t theStreamId);
     ST_LOCAL void doSwitchSubtitlesStream(const int32_t theStreamId);
     ST_LOCAL void doShowPlayList(const bool theToShow);
@@ -349,6 +363,12 @@
         Action_StereoParamsBegin,
         Action_StereoParamsEnd = Action_StereoParamsBegin + StGLImageRegion::ActionsNb - 1,
         Action_PanoramaOnOff,
+        Action_ShowGUI,
+        Action_OutStereoNormal,
+        Action_OutStereoLeftView,
+        Action_OutStereoRightView,
+        Action_OutStereoParallelPair,
+        Action_OutStereoCrossEyed,
     };
 
         private: //! @name Web UI methods

sview-17_04.tar.gz/StMoviePlayer/StMoviePlayer.rc -> sview-20_08.tar.gz/StMoviePlayer/StMoviePlayer.rc Changed

sview-17_04.tar.gz/StMoviePlayer/StMoviePlayerGUI.cpp -> sview-20_08.tar.gz/StMoviePlayer/StMoviePlayerGUI.cpp Changed

@@ -1,5 +1,5 @@
 /**
- * Copyright © 2009-2017 Kirill Gavrilov <kirill@sview.ru>
+ * Copyright © 2009-2020 Kirill Gavrilov <kirill@sview.ru>
  *
  * StMoviePlayer program is free software: you can redistribute it and/or modify
  * it under the terms of the GNU General Public License as published by
@@ -24,6 +24,7 @@
 
 #include "StVideo/StALContext.h"
 #include "StVideo/StVideo.h"
+#include "StMovieOpenDialog.h"
 
 #include <StCore/StSearchMonitors.h>
 #include <StImage/StImageFile.h>
@@ -61,6 +62,8 @@
 
 namespace {
 
+    static const float THE_VISIBILITY_IDLE_TIME = 2.0f;
+
     static const int DISPL_Y_REGION_UPPER  = 32;
     static const int DISPL_X_REGION_UPPER  = 32;
     static const int DISPL_X_REGION_BOTTOM = 52;
@@ -130,22 +133,22 @@
     const int      anIconStep = scale(48);
     aButtonMargins.extend(scale(8));
 
-    myPanelUpper = new StGLContainer(this, 0, 0, StGLCorner(ST_VCORNER_TOP, ST_HCORNER_LEFT), scale(4096), scale(128));
+    myPanelUpper = new StGLContainer(this, aLeft, aTop, StGLCorner(ST_VCORNER_TOP, ST_HCORNER_LEFT), scale(4096), scale(128));
 
     // append the textured buttons
-    myBtnOpen = new StGLTextureButton(myPanelUpper, aLeft + (aBtnIter++) * anIconStep, aTop);
+    myBtnOpen = new StGLTextureButton(myPanelUpper, (aBtnIter++) * anIconStep, 0);
     myBtnOpen->signals.onBtnClick.connect(myPlugin, &StMoviePlayer::doOpen1FileAction);
     myBtnOpen->setTexturePath(iconTexture(stCString("actionOpen"), anIconSize));
     myBtnOpen->setDrawShadow(true);
     myBtnOpen->changeMargins() = aButtonMargins;
 
-    myBtnInfo = new StGLTextureButton(myPanelUpper, aLeft + (aBtnIter++) * anIconStep, aTop);
+    myBtnInfo = new StGLTextureButton(myPanelUpper, (aBtnIter++) * anIconStep, 0);
     myBtnInfo->signals.onBtnClick += stSlot(myPlugin, &StMoviePlayer::doAboutFile);
     myBtnInfo->setTexturePath(iconTexture(stCString("actionInfo"),  anIconSize));
     myBtnInfo->setDrawShadow(true);
     myBtnInfo->changeMargins() = aButtonMargins;
 
-    StGLTextureButton* aSrcBtn = new StGLTextureButton(myPanelUpper, aLeft + (aBtnIter++) * anIconStep, aTop,
+    StGLTextureButton* aSrcBtn = new StGLTextureButton(myPanelUpper, (aBtnIter++) * anIconStep, 0,
                                                        StGLCorner(ST_VCORNER_TOP, ST_HCORNER_LEFT), StFormat_NB + 1);
     aSrcBtn->changeMargins() = aButtonMargins;
     aSrcBtn->signals.onBtnClick += stSlot(this, &StMoviePlayerGUI::doDisplayStereoFormatCombo);
@@ -172,7 +175,7 @@
     myBtnSwapLR = new StGLCheckboxTextured(myPanelUpper, myImage->params.SwapLR,
                                            iconTexture(stCString("actionSwapLROff"), anIconSize),
                                            iconTexture(stCString("actionSwapLROn"),  anIconSize),
-                                           aLeft + (aBtnIter++) * anIconStep, aTop,
+                                           (aBtnIter++) * anIconStep, 0,
                                            StGLCorner(ST_VCORNER_TOP, ST_HCORNER_LEFT));
     myBtnSwapLR->setDrawShadow(true);
     myBtnSwapLR->changeMargins() = aButtonMargins;
@@ -181,7 +184,7 @@
     myBtnPanorama = new StGLCheckboxTextured(myPanelUpper, aTrackedPano,
                                              iconTexture(stCString("actionPanoramaOff"), anIconSize),
                                              iconTexture(stCString("actionPanorama"),    anIconSize),
-                                             aLeft + (aBtnIter++) * anIconStep, aTop,
+                                             (aBtnIter++) * anIconStep, 0,
                                              StGLCorner(ST_VCORNER_TOP, ST_HCORNER_LEFT));
     myBtnPanorama->signals.onBtnClick += stSlot(this, &StMoviePlayerGUI::doPanoramaCombo);
     myBtnPanorama->setDrawShadow(true);
@@ -190,7 +193,7 @@
     myBtnAdjust = new StGLCheckboxTextured(myPanelUpper, myPlugin->params.ToShowAdjustImage,
                                            iconTexture(stCString("actionColorAdjustOff"), anIconSize),
                                            iconTexture(stCString("actionColorAdjust"),    anIconSize),
-                                           aLeft + (aBtnIter++) * anIconStep, aTop,
+                                           (aBtnIter++) * anIconStep, 0,
                                            StGLCorner(ST_VCORNER_TOP, ST_HCORNER_LEFT));
     myBtnAdjust->setDrawShadow(true);
     myBtnAdjust->changeMargins() = aButtonMargins;
@@ -200,7 +203,7 @@
     myBtnSubs = new StGLCheckboxTextured(myPanelUpper, aTrackedSubs,
                                          iconTexture(stCString("actionStreamSubtitlesOff"), anIconSize),
                                          iconTexture(stCString("actionStreamSubtitles"),    anIconSize),
-                                         (aNbBtnRight++) * (-anIconStep) - aLeft, aTop,
+                                         (aNbBtnRight++) * (-anIconStep), 0,
                                          StGLCorner(ST_VCORNER_TOP, ST_HCORNER_RIGHT));
     myBtnSubs->signals.onBtnClick = stSlot(this, &StMoviePlayerGUI::doSubtitlesStreamsCombo);
     myBtnSubs->setDrawShadow(true);
@@ -210,7 +213,7 @@
     myBtnAudio = new StGLCheckboxTextured(myPanelUpper, aTrackedAudio,
                                           iconTexture(stCString("actionStreamAudioOff"), anIconSize),
                                           iconTexture(stCString("actionStreamAudio"),    anIconSize),
-                                          (aNbBtnRight++) * (-anIconStep) - aLeft, aTop,
+                                          (aNbBtnRight++) * (-anIconStep), 0,
                                           StGLCorner(ST_VCORNER_TOP, ST_HCORNER_RIGHT));
     myBtnAudio->signals.onBtnClick = stSlot(this, &StMoviePlayerGUI::doAudioStreamsCombo);
     myBtnAudio->setDrawShadow(true);
@@ -620,10 +623,18 @@
 void StMoviePlayerGUI::fillPanoramaMenu(StGLMenu* theMenu) {
     theMenu->addItem(tr(MENU_VIEW_SURFACE_PLANE),
                      myImage->params.ViewMode, StViewSurface_Plain);
+    theMenu->addItem(tr(MENU_VIEW_SURFACE_THEATER),
+                     myImage->params.ViewMode, StViewSurface_Theater);
+    theMenu->addItem(tr(MENU_VIEW_SURFACE_CYLINDER),
+                     myImage->params.ViewMode, StViewSurface_Cylinder);
+    theMenu->addItem(tr(MENU_VIEW_SURFACE_HEMISPHERE),
+                     myImage->params.ViewMode, StViewSurface_Hemisphere);
     theMenu->addItem(tr(MENU_VIEW_SURFACE_SPHERE),
                      myImage->params.ViewMode, StViewSurface_Sphere);
     theMenu->addItem(tr(MENU_VIEW_SURFACE_CUBEMAP),
                      myImage->params.ViewMode, StViewSurface_Cubemap);
+    theMenu->addItem(tr(MENU_VIEW_SURFACE_CUBEMAP_EAC),
+                     myImage->params.ViewMode, StViewSurface_CubemapEAC);
     if(myWindow->hasOrientationSensor()) {
         theMenu->addItem(tr(myWindow->isPoorOrientationSensor() ? MENU_VIEW_TRACK_HEAD_POOR : MENU_VIEW_TRACK_HEAD),
                          myPlugin->params.ToTrackHead);
@@ -648,6 +659,8 @@
                    myImage->params.TextureFilter, StGLImageProgram::FILTER_NEAREST);
     aMenu->addItem(tr(MENU_VIEW_TEXFILTER_LINEAR),
                    myImage->params.TextureFilter, StGLImageProgram::FILTER_LINEAR);
+    aMenu->addItem(tr(MENU_VIEW_TEXFILTER_TRILINEAR),
+                   myImage->params.TextureFilter, StGLImageProgram::FILTER_TRILINEAR);
     aMenu->addItem(tr(MENU_VIEW_TEXFILTER_BLEND),
                    myImage->params.TextureFilter, StGLImageProgram::FILTER_BLEND);
     return aMenu;
@@ -749,11 +762,26 @@
 
     StDelayControl(StMoviePlayerGUI*               theParent,
                    const StHandle<StFloat32Param>& theTrackedValue)
-    : StGLMessageBox(theParent, theParent->tr(DIALOG_AUDIO_DELAY_TITLE), "", theParent->scale(400), theParent->scale(260)),
+    : StGLMessageBox(theParent),
       myRange(NULL) {
-        changeRectPx().moveX( myRoot->scale( 64));
-        changeRectPx().moveY(-myRoot->scale(128));
+        int aWidth  = stMin(theParent->scale(400), myRoot->getRectPx().width());
+        int aHeight = stMin(theParent->scale(220), myRoot->getRectPx().height());
+        const bool isCompact = myRoot->getRectPx().width()  <= myRoot->scale(450)
+                            || myRoot->getRectPx().height() <= myRoot->scale(450);
+        if(isCompact) {
+            aHeight = stMin(theParent->scale(150), aHeight);
+        } else {
+            changeRectPx().left() = myRoot->scale(64);
+            changeRectPx().top() = -myRoot->scale(128);
+        }
         setCorner(StGLCorner(ST_VCORNER_BOTTOM, ST_HCORNER_LEFT));
+        changeRectPx().right()  = getRectPx().left() + aWidth;
+        changeRectPx().bottom() = getRectPx().top()  + aHeight;
+        create(theParent->tr(DIALOG_AUDIO_DELAY_TITLE), "", aWidth, aHeight);
+        if(isCompact) {
+            myMinSizeY = theParent->scale(150);
+        }
+
         StGLButton* aResetBtn = addButton(theParent->tr(BUTTON_RESET));
         addButton(theParent->tr(BUTTON_CLOSE));
 
@@ -903,7 +931,7 @@
     const StGLVec3 THE_WHITE(1.0f, 1.0f, 1.0f);
     const StString anAbout = tr(ABOUT_DPLUGIN_NAME) + '\n'
                            + tr(ABOUT_VERSION) + " " + StVersionInfo::getSDKVersionString()
-                           + "\n \n" + tr(ABOUT_DESCRIPTION).format("2007-2017", "kirill@sview.ru", "www.sview.ru")
+                           + "\n \n" + tr(ABOUT_DESCRIPTION).format("2007-2020", "kirill@sview.ru", "www.sview.ru")
                            + "\n\n<b><i>Used projects</i></b>"
                            + "\n \nFFmpeg " + stAV::getVersionInfo() + " (" + stAV::getLicenseInfo() + ")\nhttps://ffmpeg.org/"
                            + "\n \nOpenAL Soft (LGPL)\nhttp://kcat.strangesoft.net/openal.html"
@@ -1274,6 +1302,8 @@
     const IconSize anIconSize = scaleIcon(32, aButtonMargins);
     aButtonMargins.extend(scale(12));
 
+    ///
+    ///const int aBotOffset = scale(56);
     myPanelBottom = new StGLContainer(this, 0, 0, StGLCorner(ST_VCORNER_BOTTOM, ST_HCORNER_LEFT), scale(4096), scale(56));
 
     const StGLCorner aLeftCorner = StGLCorner(ST_VCORNER_TOP, ST_HCORNER_LEFT);
@@ -1441,19 +1471,59 @@
     myBtnReset3d->changeMargins() = aButtonMargins;
 }
 
-void StMoviePlayerGUI::doOpenFile(const size_t ) {
-    StGLOpenFile* aDialog = new StGLOpenFile(this, tr(DIALOG_OPEN_FILE), tr(BUTTON_CLOSE));
-    aDialog->setMimeList(myPlugin->myVideo->getMimeListVideo());
-#if defined(_WIN32)
-    //
-#else
-    aDialog->addHotItem("/", "Root");
-#endif
-    aDialog->addHotItem(getResourceManager()->getFolder(StResourceManager::FolderId_SdCard));
+void StMoviePlayerGUI::doOpenFile(const size_t theFileType) {
+    StString aTitle;
+    switch(theFileType) {
+        case StMovieOpenDialog::Dialog_Audio: {
+            aTitle = tr(DIALOG_OPEN_AUDIO);
+            break;
+        }
+        case StMovieOpenDialog::Dialog_Subtitles: {
+            aTitle = tr(DIALOG_OPEN_SUBTITLES);
+            break;
+        }
+        case StMovieOpenDialog::Dialog_SingleMovie:
+        case StMovieOpenDialog::Dialog_DoubleMovie:
+        default: {
+            aTitle = tr(DIALOG_OPEN_FILE);
+            break;
+        }
+    }
+
+    StGLOpenFile* aDialog = new StGLOpenFile(this, aTitle, tr(BUTTON_CLOSE));
+    const StString anSdCardPath = getResourceManager()->getFolder(StResourceManager::FolderId_SdCard);
+    if(!anSdCardPath.isEmpty()) {
+        StString aFolder, aName;
+        StFileNode::getFolderAndFile(anSdCardPath, aFolder, aName);
+        aDialog->addHotItem(anSdCardPath, stUtfTools::isInteger(aName) ? (StString("sdcard") + aName) : aName);
+    }
     aDialog->addHotItem(getResourceManager()->getFolder(StResourceManager::FolderId_Downloads));
+    aDialog->addHotItem(getResourceManager()->getFolder(StResourceManager::FolderId_Documents));
     aDialog->addHotItem(getResourceManager()->getFolder(StResourceManager::FolderId_Videos));
     aDialog->addHotItem(getResourceManager()->getFolder(StResourceManager::FolderId_Music));
-    aDialog->signals.onFileSelected = stSlot(myPlugin, &StMoviePlayer::doOpen1FileFromGui);
+
+    switch(theFileType) {
+        case StMovieOpenDialog::Dialog_Audio: {
+            aDialog->signals.onFileSelected = stSlot(myPlugin, &StMoviePlayer::doOpen1AudioFromGui);
+            aDialog->setMimeList(myPlugin->myVideo->getMimeListAudio(), "Audio", false);
+            break;
+        }
+        case StMovieOpenDialog::Dialog_Subtitles: {
+            aDialog->signals.onFileSelected = stSlot(myPlugin, &StMoviePlayer::doOpen1SubtitleFromGui);
+            aDialog->setMimeList(myPlugin->myVideo->getMimeListSubtitles(), "Subtitles", false);
+            break;
+        }
+        case StMovieOpenDialog::Dialog_SingleMovie:
+        case StMovieOpenDialog::Dialog_DoubleMovie:
+        default: {
+            aDialog->signals.onFileSelected = stSlot(myPlugin, &StMoviePlayer::doOpen1FileFromGui);
+            aDialog->setDisplayExtra(myPlugin->params.ToMixImagesVideos->getValue());
+            aDialog->setMimeList(myPlugin->myVideo->getMimeListVideo(),  "Videos", false);
+            aDialog->setMimeList(myPlugin->myVideo->getMimeListImages(), "Images", true);
+            aDialog->addHotCheckbox(myPlugin->params.ToMixImagesVideos, myPlugin->params.ToMixImagesVideos->getName());
+            break;
+        }
+    }
 
     if(myPlugin->params.lastFolder.isEmpty()) {
         StHandle<StFileNode> aCurrFile = myPlugin->myPlayList->getCurrentFile();
@@ -1484,12 +1554,18 @@
         anItem = aMenu->addItem(tr(BUTTON_DELETE), myPlugin->getAction(StMoviePlayer::Action_DeleteFile));
         anItem->setIcon(stCMenuIcon("actionDiscard"));
 
+        const bool hasVideo = myPlugin->myVideo->hasVideoStream();
         const StHandle< StArrayList<StString> >& anAudioStreams = myPlugin->myVideo->params.activeAudio->getList();
         if(!anAudioStreams.isNull()
         && !anAudioStreams->isEmpty()) {
             anItem = aMenu->addItem(tr(MENU_AUDIO));
             anItem->setIcon(stCMenuIcon("actionStreamAudio"));
             anItem->signals.onItemClick += stSlot(this, &StMoviePlayerGUI::doAudioStreamsCombo);
+        } else if(hasVideo) {
+            anItem = aMenu->addItem(tr(MENU_AUDIO));
+            anItem->setIcon(stCMenuIcon("actionStreamAudio"));
+            //anItem->signals.onItemClick += stSlot(myPlugin,  &StMoviePlayer::doAddAudioStream);
+            anItem->signals.onItemClick += stSlot(this, &StMoviePlayerGUI::doAudioStreamsCombo);
         }
 
         const StHandle< StArrayList<StString> >& aSubsStreams = myPlugin->myVideo->params.activeSubtitles->getList();
@@ -1498,9 +1574,15 @@
             anItem = aMenu->addItem(tr(MENU_SUBTITLES));
             anItem->setIcon(stCMenuIcon("actionStreamSubtitles"));
             anItem->signals.onItemClick += stSlot(this, &StMoviePlayerGUI::doSubtitlesStreamsCombo);
+        } else if(myPlugin->myVideo->hasAudioStream()
+               || hasVideo) {
+            anItem = aMenu->addItem(tr(MENU_SUBTITLES));
+            anItem->setIcon(stCMenuIcon("actionStreamSubtitles"));
+            //anItem->signals.onItemClick += stSlot(myPlugin,  &StMoviePlayer::doAddSubtitleStream);
+            anItem->signals.onItemClick += stSlot(this, &StMoviePlayerGUI::doSubtitlesStreamsCombo);
         }
 
-        if(myPlugin->myVideo->hasVideoStream()) {
+        if(hasVideo) {
             anItem = aMenu->addItem(tr(MENU_VIEW_DISPLAY_RATIO));
             anItem->setIcon(stCMenuIcon("actionDisplayRatio"));
             anItem->signals.onItemClick += stSlot(this, &StMoviePlayerGUI::doDisplayRatioCombo);
@@ -1588,7 +1670,13 @@
     myPlugin->params.ToShowFps->signals.onChanged.connect(this, &StMoviePlayerGUI::doShowFPS);
 
     myImage = new StGLImageRegion(this, theTextureQueue, false);
-    myImage->setDragDelayMs(500.0);
+    myImage->changeIconPrev()->setTexturePath(iconTexture(stCString("actionBack"), scaleIcon(64)));
+    myImage->changeIconPrev()->setDrawShadow(true);
+    myImage->changeIconNext()->setTexturePath(iconTexture(stCString("actionNext"), scaleIcon(64)));
+    myImage->changeIconNext()->setDrawShadow(true);
+    myImage->signals.onOpenItem = stSlot(myPlugin, &StMoviePlayer::doFileNext);
+    myImage->setPlayList(thePlayList);
+    //myImage->setDragDelayMs(500.0);
     myImage->params.DisplayMode->setName(tr(MENU_VIEW_DISPLAY_MODE));
     myImage->params.DisplayMode->changeValues()[StGLImageRegion::MODE_STEREO]     = tr(MENU_VIEW_DISPLAY_MODE_STEREO);
     myImage->params.DisplayMode->changeValues()[StGLImageRegion::MODE_ONLY_LEFT]  = tr(MENU_VIEW_DISPLAY_MODE_LEFT);
@@ -1596,14 +1684,16 @@
     myImage->params.DisplayMode->changeValues()[StGLImageRegion::MODE_PARALLEL]   = tr(MENU_VIEW_DISPLAY_MODE_PARALLEL);
     myImage->params.DisplayMode->changeValues()[StGLImageRegion::MODE_CROSSYED]   = tr(MENU_VIEW_DISPLAY_MODE_CROSSYED);
     myImage->params.ToHealAnamorphicRatio->setValue(true);
+    myImage->params.ViewMode->signals.onChanged += stSlot(myPlugin, &StMoviePlayer::doSwitchViewMode);
 
     mySubtitles = new StGLSubtitles  (myImage, theSubQueue,
                                       myPlugin->params.SubtitlesPlace,
-                                      myPlugin->params.SubtitlesTopDY,
-                                      myPlugin->params.SubtitlesBottomDY,
-                                      myPlugin->params.SubtitlesSize,
-                                      myPlugin->params.SubtitlesParallax,
-                                      myPlugin->params.SubtitlesParser);
+                                      myPlugin->params.SubtitlesSize);
+    mySubtitles->params.TopDY    = myPlugin->params.SubtitlesTopDY;
+    mySubtitles->params.BottomDY = myPlugin->params.SubtitlesBottomDY;
+    mySubtitles->params.Parallax = myPlugin->params.SubtitlesParallax;
+    mySubtitles->params.Parser   = myPlugin->params.SubtitlesParser;
+    mySubtitles->params.ToApplyStereo = myPlugin->params.SubtitlesApplyStereo;
 
     if(myPlugin->params.ToShowFps->getValue()) {
         myFpsWidget = new StGLFpsLabel(this);
@@ -1664,6 +1754,21 @@
                                   float theAspect) {
     const int aNewSizeX = theViewPort.width();
     const int aNewSizeY = theViewPort.height();
+    int aGapTopX = 0, aGapTopY = 0, aGapBotX = 0, aGapBotY = 0;
+    if(isMobile()) {
+        // add gap for hidden system navigation buttons
+        static const int THE_NAVIGATION_GAPX = 32;
+        static const int THE_NAVIGATION_GAPY = 16;
+        if(theAspect < 9.0 / 16.0 && theAspect > 0.0) {
+            aGapTopY = aGapBotY = stMax(0, scale(stMin(THE_NAVIGATION_GAPY, int((1.0 / theAspect * 360) - 360 * 2))));
+        } else if(theAspect > 9.0 / 16.0) {
+            aGapTopX = aGapBotX = stMax(0, scale(stMin(THE_NAVIGATION_GAPX, int((theAspect * 360) - 360 * 2))));
+        }
+    } else {
+        aGapTopY = scale(DISPL_Y_REGION_UPPER);
+        aGapTopX = scale(DISPL_X_REGION_UPPER);
+        aGapBotX = scale(DISPL_X_REGION_BOTTOM);
+    }
 
     // image should fit entire view
     myImage->changeRectPx().top()    = -theMargins.top;
@@ -1672,11 +1777,14 @@
     myImage->changeRectPx().right()  = -theMargins.left + aNewSizeX;
 
     if(myPanelUpper != NULL) {
-        myPanelUpper->changeRectPx().right()  = stMax(aNewSizeX - theMargins.right - theMargins.left, 2);
+        myPanelUpper->changeRectPx().top()   = aGapTopY;
+        myPanelUpper->changeRectPx().left()  = aGapTopX;
+        myPanelUpper->changeRectPx().right() = aGapTopX + stMax(aNewSizeX - theMargins.right - theMargins.left - 2 * aGapTopX, 2);
     }
     if(myPanelBottom != NULL) {
-        const int aGapX = myPanelBottom->changeRectPx().left();
-        myPanelBottom->changeRectPx().right() = aGapX + stMax(aNewSizeX - theMargins.right - theMargins.left - 2 * aGapX, 2);
+        myPanelBottom->changeRectPx().top()   = -aGapBotY;
+        myPanelBottom->changeRectPx().left()  = aGapBotX;
+        myPanelBottom->changeRectPx().right() = aGapBotX + stMax(aNewSizeX - theMargins.right - theMargins.left - 2 * aGapBotX, 2);
     }
 
     stglResizeSeekBar();
@@ -1686,7 +1794,7 @@
 void StMoviePlayerGUI::stglResizeSeekBar() {
     if(mySeekBar != NULL
     && myPanelBottom != NULL) {
-        const int aPanelSizeY = myPanelBottom->getRectPx().height();
+        const int aPanelSizeY = myPanelBottom->getRectPx().top() + myPanelBottom->getRectPx().height();
         const int aPanelSizeX = myPanelBottom->getRectPx().width();
         const int aSeekSizeY  = mySeekBar->getRectPx().height();
         const int aBoxWidth   = myTimeBox->getRectPx().width();
@@ -1771,16 +1879,62 @@
 
 }
 
-void StMoviePlayerGUI::setVisibility(const StPointD_t& theCursor) {
+void StMoviePlayerGUI::doGesture(const StGestureEvent& theEvent) {
+    if(myImage == NULL) {
+        return;
+    }
+
+    if(theEvent.Type == stEvent_Gesture1Tap) {
+        myTapTimer.restart();
+    } else if(theEvent.Type == stEvent_Gesture1DoubleTap) {
+        myTapTimer.stop();
+    }
+
+    for(StGLWidget *aChildIter(getChildren()->getLast()), *aChildActive(NULL); aChildIter != NULL;) {
+        aChildActive = aChildIter;
+        aChildIter   = aChildIter->getPrev();
+        if(aChildActive->isVisibleAndPointIn(getCursorZo())) {
+            if(aChildActive == myImage) {
+                myImage->doGesture(theEvent);
+            }
+            return;
+        }
+    }
+}
+
+void StMoviePlayerGUI::setVisibility(const StPointD_t& theCursor,
+                                     bool theToForceHide,
+                                     bool theToForceShow) {
     const bool toShowAdjust   = myPlugin->params.ToShowAdjustImage->getValue();
     const bool toShowPlayList = myPlugin->params.ToShowPlayList->getValue();
     const bool hasMainMenu    = myPlugin->params.ToShowMenu->getValue()
                              && myMenuRoot != NULL;
     const bool hasUpperPanel  = myPlugin->params.ToShowTopbar->getValue()
                              && myPanelUpper != NULL;
+    const bool hasBottomPanel = myPlugin->params.ToShowBottom->getValue()
+                             && (myPanelBottom != NULL || mySeekBar != NULL);
 
     const int  aRootSizeY     = getRectPx().height();
     const bool hasVideo       = myPlugin->myVideo->hasVideoStream();
+    if(!hasVideo && !myTapTimer.isOn()
+    && !myPlugin->myPlayList->isEmpty()) {
+        myEmptyTimer.restart();
+    } else {
+        myEmptyTimer.stop();
+    }
+    if(myEmptyTimer.getElapsedTime() >= 2.5) {
+        myVisibilityTimer.restart();
+        myEmptyTimer.stop();
+    }
+    if(myTapTimer.getElapsedTime() >= 0.5) {
+        myVisibilityTimer.restart();
+        myTapTimer.stop();
+    }
+    if(theToForceShow) {
+        myVisibilityTimer.restart();
+    } else if(theToForceHide) {
+        myVisibilityTimer.restart(THE_VISIBILITY_IDLE_TIME + 0.001);
+    }
     const bool isMouseActive  = myWindow->isMouseMoved();
     const double aStillTime   = myVisibilityTimer.getElapsedTime();
 
@@ -1800,15 +1954,15 @@
                          && aSrcFormat != StFormat_Mono
                          && aSrcFormat != StFormat_AUTO;
 
-    myIsVisibleGUI = !hasVideo
-        || isMouseActive
+    myIsVisibleGUI = isMouseActive
         || aParams.isNull()
-        || aStillTime < 2.0
+        || aStillTime < THE_VISIBILITY_IDLE_TIME
         || (hasUpperPanel && myPanelUpper->isPointIn(theCursor))
-        || (myPanelBottom != NULL && int(aRootSizeY * theCursor.y()) > (aRootSizeY - 2 * myPanelBottom->getRectPx().height())
-                                  && theCursor.y() < 1.0)
-        || (mySeekBar     != NULL && mySeekBar    ->isPointIn(theCursor))
-        || (myPlayList    != NULL && toShowPlayList && myPlayList->isPointIn(theCursor))
+        || (hasBottomPanel && myPanelBottom != NULL
+         && int(aRootSizeY * theCursor.y()) > (aRootSizeY - 2 * myPanelBottom->getRectPx().height())
+         && theCursor.y() < 1.0)
+        || (hasBottomPanel && mySeekBar != NULL && mySeekBar->isPointIn(theCursor))
+        || (hasBottomPanel && myPlayList != NULL && toShowPlayList && myPlayList->isPointIn(theCursor))
         || (hasMainMenu           && myMenuRoot->isActive());
     if(!myIsVisibleGUI
      && myBtnPlay != NULL
@@ -1817,7 +1971,7 @@
       || theCursor.y() < 0.0 || theCursor.y() > 1.0)) {
         myIsVisibleGUI = true;
     }
-    const float anOpacity = (float )myVisLerp.perform(myIsVisibleGUI, false);
+    const float anOpacity = (float )myVisLerp.perform(myIsVisibleGUI, theToForceHide || theToForceShow);
     if(isMouseActive) {
         myVisibilityTimer.restart();
     }
@@ -1829,10 +1983,10 @@
         myPanelUpper->setOpacity(hasUpperPanel ? anOpacity : 0.0f, true);
     }
     if(mySeekBar != NULL) {
-        mySeekBar->setOpacity(anOpacity, false);
+        mySeekBar->setOpacity(hasBottomPanel ? anOpacity : 0.0f, false);
     }
     if(myPanelBottom != NULL) {
-        myPanelBottom->setOpacity(anOpacity, true);
+        myPanelBottom->setOpacity(hasBottomPanel ? anOpacity : 0.0f, true);
     }
 
     if(myAdjustOverlay != NULL
@@ -1850,7 +2004,7 @@
     }
     if(myPlayList != NULL
     && toShowPlayList) {
-        myPlayList->setOpacity(anOpacity, true);
+        myPlayList->setOpacity(hasBottomPanel ? anOpacity : 0.0f, true);
     }
 
     const StPlayList::CurrentPosition aCurrPos = myPlugin->myPlayList->getCurrentPosition();
@@ -1894,9 +2048,9 @@
     if(!toShowPano
     &&  hasVideo
     && !aParams.isNull()
-    &&  st::probePanorama(aParams->StereoFormat,
+    /*&&  st::probePanorama(aParams->StereoFormat,
                           aParams->Src1SizeX, aParams->Src1SizeY,
-                          aParams->Src2SizeX, aParams->Src2SizeY) != StPanorama_OFF) {
+                          aParams->Src2SizeX, aParams->Src2SizeY) != StPanorama_OFF*/) {
         toShowPano = true;
     }
     if(myBtnPanorama != NULL) {
@@ -1922,9 +2076,13 @@
         } else if(::isPointIn(myBtnPanorama, theCursor)) {
             size_t aTrPano = MENU_VIEW_SURFACE_PLANE;
             switch(aViewMode) {
-                case StViewSurface_Plain:   aTrPano = MENU_VIEW_SURFACE_PLANE;   break;
-                case StViewSurface_Sphere:  aTrPano = MENU_VIEW_SURFACE_SPHERE;  break;
-                case StViewSurface_Cubemap: aTrPano = MENU_VIEW_SURFACE_CUBEMAP; break;
+                case StViewSurface_Plain:      aTrPano = MENU_VIEW_SURFACE_PLANE;   break;
+                case StViewSurface_Theater:    aTrPano = MENU_VIEW_SURFACE_THEATER; break;
+                case StViewSurface_Sphere:     aTrPano = MENU_VIEW_SURFACE_SPHERE;  break;
+                case StViewSurface_Hemisphere: aTrPano = MENU_VIEW_SURFACE_HEMISPHERE;  break;
+                case StViewSurface_Cubemap:    aTrPano = MENU_VIEW_SURFACE_CUBEMAP;  break;
+                case StViewSurface_CubemapEAC: aTrPano = MENU_VIEW_SURFACE_CUBEMAP_EAC; break;
+                case StViewSurface_Cylinder:   aTrPano = MENU_VIEW_SURFACE_CYLINDER; break;
             }
             myDescr->setText(tr(MENU_VIEW_PANORAMA) + "\n" + tr(aTrPano));
         } else if(::isPointIn(myBtnAdjust, theCursor)) {
@@ -1987,10 +2145,6 @@
             aBuilder.getMenu()->addItem(myPlugin->params.ToForceBFormat);
         }
     }
-    if(myWindow->isMobile()) {
-        aBuilder.display();
-        return;
-    }
 
     //aBuilder.getMenu()->addSplitter();
     StGLMenuItem* aDelayItem = NULL;
@@ -2017,8 +2171,65 @@
     aBuilder.display();
 }
 
+void StMoviePlayerGUI::doSubtitlesPlacement(const size_t ) {
+    StGLMenu* aMenu  = new StGLMenu(this, 0, 0, StGLMenu::MENU_VERTICAL, true);
+    aMenu->setCorner(StGLCorner(ST_VCORNER_BOTTOM, ST_HCORNER_RIGHT));
+    aMenu->setContextual(true);
+    fillSubtitlesFontSize(aMenu);
+    fillSubtitlesPlacement(aMenu);
+    aMenu->stglInit();
+    setFocus(aMenu);
+}
+
+void StMoviePlayerGUI::fillSubtitlesFontSize(StGLMenu* theMenu) {
+    StGLMenuItem* anItem = theMenu->addItem(tr(MENU_SUBTITLES_SIZE));
+    anItem->setIcon(stCMenuIcon("actionFontSize"), false);
+    anItem->changeMargins().right = scale(100 + 16);
+    StGLRangeFieldFloat32* aRange = new StGLRangeFieldFloat32(anItem, myPlugin->params.SubtitlesSize,
+                                                              -scale(16), 0, StGLCorner(ST_VCORNER_CENTER, ST_HCORNER_RIGHT));
+    aRange->changeRectPx().bottom() = aRange->getRectPx().top() + theMenu->getItemHeight();
+    aRange->setFormat(stCString("%02.0f"));
+    aRange->setColor(StGLRangeFieldFloat32::FieldColor_Default,  aBlack);
+    aRange->setColor(StGLRangeFieldFloat32::FieldColor_Positive, aBlack);
+    aRange->setColor(StGLRangeFieldFloat32::FieldColor_Negative, aBlack);
+}
+
+void StMoviePlayerGUI::fillSubtitlesPlacement(StGLMenu* theMenu) {
+    StGLMenuItem* anItem = theMenu->addItem(tr(MENU_SUBTITLES_TOP), myPlugin->params.SubtitlesPlace, ST_VCORNER_TOP);
+    anItem->changeMargins().right  = scale(100 + 16);
+    StGLRangeFieldFloat32* aRange = new StGLRangeFieldFloat32(anItem, myPlugin->params.SubtitlesTopDY,
+                                                              -scale(16), 0, StGLCorner(ST_VCORNER_CENTER, ST_HCORNER_RIGHT));
+    aRange->changeRectPx().bottom() = aRange->getRectPx().top() + theMenu->getItemHeight();
+    aRange->setFormat(stCString("%+03.0f"));
+    aRange->setColor(StGLRangeFieldFloat32::FieldColor_Default,  aBlack);
+    aRange->setColor(StGLRangeFieldFloat32::FieldColor_Positive, aGreen);
+    aRange->setColor(StGLRangeFieldFloat32::FieldColor_Negative, aRed);
+
+    anItem = theMenu->addItem(tr(MENU_SUBTITLES_BOTTOM), myPlugin->params.SubtitlesPlace, ST_VCORNER_BOTTOM);
+    anItem->changeMargins().right  = scale(100 + 16);
+    aRange = new StGLRangeFieldFloat32(anItem, myPlugin->params.SubtitlesBottomDY,
+                                       -scale(16), 0, StGLCorner(ST_VCORNER_CENTER, ST_HCORNER_RIGHT));
+    aRange->changeRectPx().bottom() = aRange->getRectPx().top() + theMenu->getItemHeight();
+    aRange->setFormat(stCString("%+03.0f"));
+    aRange->setColor(StGLRangeFieldFloat32::FieldColor_Default,  aBlack);
+    aRange->setColor(StGLRangeFieldFloat32::FieldColor_Positive, aGreen);
+    aRange->setColor(StGLRangeFieldFloat32::FieldColor_Negative, aRed);
+
+    anItem = theMenu->addItem(tr(MENU_SUBTITLES_PARALLAX));
+    anItem->changeMargins().right  = scale(100 + 16);
+    aRange = new StGLRangeFieldFloat32(anItem, myPlugin->params.SubtitlesParallax,
+                                       -scale(16), 0, StGLCorner(ST_VCORNER_CENTER, ST_HCORNER_RIGHT));
+    aRange->changeRectPx().bottom() = aRange->getRectPx().top() + theMenu->getItemHeight();
+    aRange->setFormat(stCString("%+03.0f"));
+    aRange->setColor(StGLRangeFieldFloat32::FieldColor_Default,  aBlack);
+    aRange->setColor(StGLRangeFieldFloat32::FieldColor_Positive, aBlack);
+    aRange->setColor(StGLRangeFieldFloat32::FieldColor_Negative, aBlack);
+}
+
 void StMoviePlayerGUI::doSubtitlesStreamsCombo(const size_t ) {
     const StHandle< StArrayList<StString> >& aStreams = myPlugin->myVideo->params.activeSubtitles->getList();
+    const bool hasAudioStream = myPlugin->myVideo->hasAudioStream();
+    const bool hasVideoStream = myPlugin->myVideo->hasVideoStream();
 
     StGLCombobox::ListBuilder aBuilder(this);
 
@@ -2037,64 +2248,40 @@
             aBuilder.getMenu()->addItem(aStreams->getValue(aStreamId), myPlugin->params.SubtitlesStream, int32_t(aStreamId));
         }
     }
-    if(myWindow->isMobile()) {
-        aBuilder.display();
-        return;
-    }
 
     if(!aStreams.isNull()
     && !aStreams->isEmpty()) {
         //myMenuSubtitles->addSplitter();
-        StGLMenuItem* anItem = aBuilder.getMenu()->addItem(tr(MENU_SUBTITLES_SIZE));
-        anItem->setIcon(stCMenuIcon("actionFontSize"), false);
-        anItem->changeMargins().right = scale(100 + 16);
-        StGLRangeFieldFloat32* aRange = new StGLRangeFieldFloat32(anItem, myPlugin->params.SubtitlesSize,
-                                                                 -scale(16), 0, StGLCorner(ST_VCORNER_CENTER, ST_HCORNER_RIGHT));
-        aRange->changeRectPx().bottom() = aRange->getRectPx().top() + aBuilder.getMenu()->getItemHeight();
-        aRange->setFormat(stCString("%02.0f"));
-        aRange->setColor(StGLRangeFieldFloat32::FieldColor_Default,  aBlack);
-        aRange->setColor(StGLRangeFieldFloat32::FieldColor_Positive, aBlack);
-        aRange->setColor(StGLRangeFieldFloat32::FieldColor_Negative, aBlack);
+        if(!myWindow->isMobile()) {
+            fillSubtitlesFontSize(aBuilder.getMenu());
+        }
 
         StGLMenu* aPlaceMenu = new StGLMenu(this, 0, 0, StGLMenu::MENU_VERTICAL);
+        fillSubtitlesPlacement(aPlaceMenu);
+        aBuilder.getMenu()->addItem(tr(MENU_SUBTITLES_PLACEMENT), aPlaceMenu)
+                          ->signals.onItemClick.connect(this, &StMoviePlayerGUI::doSubtitlesPlacement);
+    }
 
-        anItem = aPlaceMenu->addItem(tr(MENU_SUBTITLES_TOP), myPlugin->params.SubtitlesPlace, ST_VCORNER_TOP);
-        anItem->changeMargins().right  = scale(100 + 16);
-        aRange = new StGLRangeFieldFloat32(anItem, myPlugin->params.SubtitlesTopDY,
-                                          -scale(16), 0, StGLCorner(ST_VCORNER_CENTER, ST_HCORNER_RIGHT));
-        aRange->changeRectPx().bottom() = aRange->getRectPx().top() + aBuilder.getMenu()->getItemHeight();
-        aRange->setFormat(stCString("%+03.0f"));
-        aRange->setColor(StGLRangeFieldFloat32::FieldColor_Default,  aBlack);
-        aRange->setColor(StGLRangeFieldFloat32::FieldColor_Positive, aGreen);
-        aRange->setColor(StGLRangeFieldFloat32::FieldColor_Negative, aRed);
-
-        anItem = aPlaceMenu->addItem(tr(MENU_SUBTITLES_BOTTOM), myPlugin->params.SubtitlesPlace, ST_VCORNER_BOTTOM);
-        anItem->changeMargins().right  = scale(100 + 16);
-        aRange = new StGLRangeFieldFloat32(anItem, myPlugin->params.SubtitlesBottomDY,
-                                          -scale(16), 0, StGLCorner(ST_VCORNER_CENTER, ST_HCORNER_RIGHT));
-        aRange->changeRectPx().bottom() = aRange->getRectPx().top() + aBuilder.getMenu()->getItemHeight();
-        aRange->setFormat(stCString("%+03.0f"));
-        aRange->setColor(StGLRangeFieldFloat32::FieldColor_Default,  aBlack);
-        aRange->setColor(StGLRangeFieldFloat32::FieldColor_Positive, aGreen);
-        aRange->setColor(StGLRangeFieldFloat32::FieldColor_Negative, aRed);
-
-        anItem = aPlaceMenu->addItem(tr(MENU_SUBTITLES_PARALLAX));
-        anItem->changeMargins().right  = scale(100 + 16);
-        aRange = new StGLRangeFieldFloat32(anItem, myPlugin->params.SubtitlesParallax,
-                                          -scale(16), 0, StGLCorner(ST_VCORNER_CENTER, ST_HCORNER_RIGHT));
-        aRange->changeRectPx().bottom() = aRange->getRectPx().top() + aBuilder.getMenu()->getItemHeight();
-        aRange->setFormat(stCString("%+03.0f"));
-        aRange->setColor(StGLRangeFieldFloat32::FieldColor_Default,  aBlack);
-        aRange->setColor(StGLRangeFieldFloat32::FieldColor_Positive, aBlack);
-        aRange->setColor(StGLRangeFieldFloat32::FieldColor_Negative, aBlack);
-
-        anItem = aBuilder.getMenu()->addItem(tr(MENU_SUBTITLES_PLACEMENT), aPlaceMenu);
-    }
-
-    aBuilder.getMenu()->addItem(tr(MENU_SUBTITLES_PARSER), aParserMenu)
-                      ->setIcon(stCMenuIcon("actionTextFormat"), false);
-    if(myPlugin->myVideo->hasAudioStream()
-    || myPlugin->myVideo->hasVideoStream()) {
+    if(!aStreams.isNull()
+    && !aStreams->isEmpty()
+    && hasVideoStream) {
+        StHandle<StStereoParams> aParams = myImage->getSource();
+        StFormat aSrcFormat = (StFormat )myPlugin->params.SrcStereoFormat->getValue();
+        if(aSrcFormat == StFormat_AUTO && !aParams.isNull()) {
+            aSrcFormat = aParams->StereoFormat;
+        }
+        if(aSrcFormat == StFormat_SideBySide_LR
+        || aSrcFormat == StFormat_SideBySide_RL
+        || aSrcFormat == StFormat_TopBottom_LR
+        || aSrcFormat == StFormat_TopBottom_RL) {
+            aBuilder.getMenu()->addItem(tr(MENU_SUBTITLES_STEREO), myPlugin->params.SubtitlesApplyStereo);
+        }
+    }
+    if(!myWindow->isMobile()) {
+        aBuilder.getMenu()->addItem(tr(MENU_SUBTITLES_PARSER), aParserMenu)
+                          ->setIcon(stCMenuIcon("actionTextFormat"), false);
+    }
+    if(hasAudioStream || hasVideoStream) {
         //aBuilder.getMenu()->addSplitter();
         aBuilder.getMenu()->addItem(tr(MENU_SUBTITLES_ATTACH))
                           ->setIcon(stCMenuIcon("actionOpen"), false)
@@ -2259,6 +2446,7 @@
     aParams.add(myPlugin->StApplication::params.ActiveDevice);
     aParams.add(myImage->params.DisplayMode);
     aParams.add(myPlugin->params.ToStickPanorama);
+    aParams.add(myPlugin->params.ToSwapJPS);
     aRend->getOptions(aParams);
     aParams.add(myPlugin->params.ToShowFps);
     aParams.add(myPlugin->params.UseGpu);
@@ -2271,7 +2459,13 @@
     }
 
     aParams.add(myLangMap->params.language);
+    aParams.add(myPlugin->params.ToMixImagesVideos);
+    aParams.add(myPlugin->params.SlideShowDelay);
     aParams.add(myPlugin->params.IsMobileUI);
+#if defined(_WIN32) || defined(__APPLE__) // implemented only on Windows and macOS
+    aParams.add(myPlugin->params.IsExclusiveFullScreen);
+#endif
+    aParams.add(myPlugin->params.ToSmoothUploads);
     if(isMobile()) {
         //aParams.add(myPlugin->params.ToHideStatusBar);
         aParams.add(myPlugin->params.ToHideNavBar);
@@ -2284,10 +2478,16 @@
         aParams.add(myPlugin->params.BlockSleeping);
         aParams.add(myPlugin->params.ToOpenLast);
     }
-#if !defined(ST_NO_UPDATES_CHECK)
+#if defined(ST_UPDATES_CHECK)
     aParams.add(myPlugin->params.CheckUpdatesDays);
 #endif
 
+    if(!myWindow->isMobile()) {
+        StHandle<StBoolParamNamed> aDefDrawerParam = myPlugin->createDefaultDrawerParam(stCString("StMoviePlayer"),
+                                                                                        stCString("sView launcher starts Movie Player"));
+        aParams.add(aDefDrawerParam);
+    }
+
     StInfoDialog* aDialog = new StInfoDialog(myPlugin, this, tr(MENU_HELP_SETTINGS), scale(768), scale(300));
 
     const int aWidthMax  = aDialog->getContent()->getRectPx().width();

sview-17_04.tar.gz/StMoviePlayer/StMoviePlayerGUI.h -> sview-20_08.tar.gz/StMoviePlayer/StMoviePlayerGUI.h Changed

@@ -1,5 +1,5 @@
 /**
- * Copyright © 2009-2017 Kirill Gavrilov <kirill@sview.ru>
+ * Copyright © 2009-2020 Kirill Gavrilov <kirill@sview.ru>
  *
  * StMoviePlayer program is free software: you can redistribute it and/or modify
  * it under the terms of the GNU General Public License as published by
@@ -115,7 +115,14 @@
     ST_LOCAL virtual void stglUpdate(const StPointD_t& thePointZo,
                                      bool theIsPreciseInput) ST_ATTR_OVERRIDE;
 
-    ST_LOCAL void setVisibility(const StPointD_t& theCursor);
+    /**
+     * Handle gesture.
+     */
+    ST_LOCAL void doGesture(const StGestureEvent& theEvent);
+    ST_LOCAL bool isVisibleGUI() const { return myVisLerp.getValue() > 0.0; }
+    ST_LOCAL void setVisibility(const StPointD_t& theCursor,
+                                bool theToForceHide = false,
+                                bool theToForceShow = false);
 
         public:
 
@@ -167,6 +174,8 @@
     ST_LOCAL void fillDisplayRatioMenu(StGLMenu* theMenu);
     ST_LOCAL void fillSrcFormatMenu(StGLMenu* theMenu);
     ST_LOCAL void fillPanoramaMenu (StGLMenu* theMenu);
+    ST_LOCAL void fillSubtitlesFontSize(StGLMenu* theMenu);
+    ST_LOCAL void fillSubtitlesPlacement(StGLMenu* theMenu);
 
         private: //! @name mobile interface creation routines
 
@@ -196,11 +205,12 @@
     ST_LOCAL void doChangeHotKey1(const size_t );
     ST_LOCAL void doChangeHotKey2(const size_t );
 
-    ST_LOCAL void doOpenFile(const size_t );
+    ST_LOCAL void doOpenFile(const size_t theFileType);
     ST_LOCAL void doShowMobileExMenu(const size_t );
     ST_LOCAL void doMobileSettings(const size_t );
     ST_LOCAL void doAudioStreamsCombo(const size_t );
     ST_LOCAL void doSubtitlesStreamsCombo(const size_t );
+    ST_LOCAL void doSubtitlesPlacement(const size_t );
     ST_LOCAL void doDisplayRatioCombo(const size_t );
     ST_LOCAL void doDisplayStereoFormatCombo(const size_t );
     ST_LOCAL void doPanoramaCombo(const size_t );
@@ -211,6 +221,8 @@
     StWindow*           myWindow;           //!< link to the window instance
     StTranslations*     myLangMap;          //!< translated strings map
     StTimer             myVisibilityTimer;  //!< minimum visible delay
+    StTimer             myEmptyTimer;       //!< empty list delay
+    StTimer             myTapTimer;         //!< single tap delay
     StGLAnimationLerp   myVisLerp;
 
     StGLImageRegion*    myImage;            //!< the main video frame

sview-17_04.tar.gz/StMoviePlayer/StMoviePlayerInfo.h -> sview-20_08.tar.gz/StMoviePlayer/StMoviePlayerInfo.h Changed

sview-17_04.tar.gz/StMoviePlayer/StMoviePlayerStrings.cpp -> sview-20_08.tar.gz/StMoviePlayer/StMoviePlayerStrings.cpp Changed

@@ -1,5 +1,5 @@
 /**
- * Copyright © 2013-2017 Kirill Gavrilov <kirill@sview.ru>
+ * Copyright © 2013-2020 Kirill Gavrilov <kirill@sview.ru>
  *
  * StMoviePlayer program is free software: you can redistribute it and/or modify
  * it under the terms of the GNU General Public License as published by
@@ -89,6 +89,8 @@
                "Top");
     theStrings(MENU_SUBTITLES_BOTTOM,
                "Bottom");
+    theStrings(MENU_SUBTITLES_STEREO,
+               "Apply stereo format");
     theStrings(MENU_SUBTITLES_PLAIN_TEXT,
                "Plain text");
     theStrings(MENU_SUBTITLES_LITE_HTML,
@@ -185,10 +187,16 @@
                "Plane");
     theStrings(MENU_VIEW_SURFACE_SPHERE,
                "Sphere");
+    theStrings(MENU_VIEW_SURFACE_HEMISPHERE,
+               "Hemisphere");
     theStrings(MENU_VIEW_SURFACE_CYLINDER,
                "Cylinder");
     theStrings(MENU_VIEW_SURFACE_CUBEMAP,
                "Cubemap");
+    theStrings(MENU_VIEW_SURFACE_THEATER,
+               "Theater");
+    theStrings(MENU_VIEW_SURFACE_CUBEMAP_EAC,
+               "Equiangular cubemap");
     theStrings(MENU_VIEW_TRACK_HEAD,
                "Track orientation");
     theStrings(MENU_VIEW_TRACK_HEAD_POOR,
@@ -217,6 +225,8 @@
                "Nearest");
     theStrings(MENU_VIEW_TEXFILTER_LINEAR,
                "Linear");
+    theStrings(MENU_VIEW_TEXFILTER_TRILINEAR,
+               "Trilinear");
     theStrings(MENU_VIEW_TEXFILTER_BLEND,
                "Blend Deinterlace");
     theStrings(MENU_CHANGE_DEVICE,
@@ -225,6 +235,8 @@
                "About Plugin...");
     theStrings(MENU_FPS,
                "FPS Control");
+    theStrings(MENU_EXCLUSIVE_FULLSCREEN,
+               "Exclusive Fullscreen mode");
     theStrings(MENU_FPS_VSYNC,
                "VSync");
     theStrings(MENU_FPS_METER,
@@ -307,6 +319,8 @@
                "Hide system navigation bar");
     theStrings(OPTION_OPEN_LAST_ON_STARTUP,
                "Open last played file on startup");
+    theStrings(OPTION_SWAP_JPS,
+               "Swap JPS/PNS views order");
 
     theStrings(FILE_VIDEO_OPEN,
                "Open another movie");
@@ -331,6 +345,10 @@
                "Choose the video file to open");
     theStrings(DIALOG_OPEN_RIGHT,
                "Choose RIGHT video file to open");
+    theStrings(DIALOG_OPEN_AUDIO,
+               "Choose audio file to attach");
+    theStrings(DIALOG_OPEN_SUBTITLES,
+               "Choose subtitles file to attach");
     theStrings(DIALOG_FILE_INFO,
                "File Info");
     theStrings(DIALOG_FILE_NOINFO,
@@ -643,6 +661,15 @@
     addAction(theStrings, StMoviePlayer::Action_PanoramaOnOff,
               "DoPanoramaOnOff",
               "Enable/disable panorama mode");
+    addAction(theStrings, StMoviePlayer::Action_ShowGUI,
+              "DoShowGUI",
+              "Show/hide GUI");
+
+    theStrings.addAlias("DoOutStereoNormal",       MENU_VIEW_DISPLAY_MODE_STEREO);
+    theStrings.addAlias("DoOutStereoLeftView",     MENU_VIEW_DISPLAY_MODE_LEFT);
+    theStrings.addAlias("DoOutStereoRightView",    MENU_VIEW_DISPLAY_MODE_RIGHT);
+    theStrings.addAlias("DoOutStereoParallelPair", MENU_VIEW_DISPLAY_MODE_PARALLEL);
+    theStrings.addAlias("DoOutStereoCrossEyed",    MENU_VIEW_DISPLAY_MODE_CROSSYED);
 }
 
 };

sview-17_04.tar.gz/StMoviePlayer/StMoviePlayerStrings.h -> sview-20_08.tar.gz/StMoviePlayer/StMoviePlayerStrings.h Changed

@@ -1,5 +1,5 @@
 /**
- * Copyright © 2009-2017 Kirill Gavrilov <kirill@sview.ru>
+ * Copyright © 2009-2020 Kirill Gavrilov <kirill@sview.ru>
  *
  * StMoviePlayer program is free software: you can redistribute it and/or modify
  * it under the terms of the GNU General Public License as published by
@@ -103,6 +103,7 @@
         MENU_VIEW_TEXFILTER_NEAREST = 1260,
         MENU_VIEW_TEXFILTER_LINEAR  = 1261,
         MENU_VIEW_TEXFILTER_BLEND   = 1262,
+        MENU_VIEW_TEXFILTER_TRILINEAR = 1263,
 
         MENU_VIEW_ADJUST_RESET      = 1270,
         MENU_VIEW_ADJUST_BRIGHTNESS = 1271,
@@ -113,10 +114,13 @@
         MENU_VIEW_SURFACE_SPHERE    = 1281,
         MENU_VIEW_SURFACE_CYLINDER  = 1282,
         MENU_VIEW_SURFACE_CUBEMAP   = 1283,
+        MENU_VIEW_SURFACE_HEMISPHERE= 1284,
         MENU_VIEW_TRACK_HEAD        = 1285,
         MENU_VIEW_TRACK_HEAD_POOR   = 1286,
         MENU_VIEW_TRACK_HEAD_AUDIO  = 1287,
         MENU_VIEW_STICK_PANORAMA360 = 1288,
+        MENU_VIEW_SURFACE_CUBEMAP_EAC = 1293,
+        MENU_VIEW_SURFACE_THEATER   = 1294,
 
         // Root -> Audio menu
         MENU_AUDIO = 1300,
@@ -140,6 +144,7 @@
         MENU_SUBTITLES_PLACEMENT= 1357,
         MENU_SUBTITLES_TOP      = 1358,
         MENU_SUBTITLES_BOTTOM   = 1359,
+        MENU_SUBTITLES_STEREO   = 1370,
 
         MENU_SUBTITLES_PLAIN_TEXT = 1360,
         MENU_SUBTITLES_LITE_HTML  = 1361,
@@ -148,6 +153,7 @@
         MENU_CHANGE_DEVICE  = 1400, // Root -> Output -> Change Device menu
         MENU_ABOUT_RENDERER = 1401,
         MENU_FPS            = 1402,
+        MENU_EXCLUSIVE_FULLSCREEN = 1404,
 
         // Root -> Output -> FPS Control menu
         MENU_FPS_VSYNC      = 1420,
@@ -194,6 +200,7 @@
         OPTION_EXIT_ON_ESCAPE_WINDOWED     = 1705,
         OPTION_HIDE_NAVIGATION_BAR         = 1710,
         OPTION_OPEN_LAST_ON_STARTUP        = 1711,
+        OPTION_SWAP_JPS                    = 1712,
 
         // Open/Save dialogs
         DIALOG_OPEN_FILE       = 2000,
@@ -204,6 +211,8 @@
         DIALOG_DELETE_FILE_TITLE    = 2005,
         DIALOG_DELETE_FILE_QUESTION = 2006,
         DIALOG_FILE_DECODERS   = 2007,
+        DIALOG_OPEN_AUDIO      = 2008,
+        DIALOG_OPEN_SUBTITLES  = 2009,
 
         DIALOG_SAVE_SNAPSHOT   = 2010,
         DIALOG_NOTHING_TO_SAVE = 2011,

sview-17_04.tar.gz/StMoviePlayer/StVideo/StAVPacketQueue.cpp -> sview-20_08.tar.gz/StMoviePlayer/StVideo/StAVPacketQueue.cpp Changed

@@ -45,6 +45,7 @@
   myCodecCtx(NULL),
   myCodec(NULL),
   myCodecAuto(NULL),
+  myCodecAutoId(AV_CODEC_ID_NONE),
   myGetFrmtInit(NULL),
   myGetBuffInit(NULL),
   myPtsStartBase(0.0),
@@ -103,14 +104,58 @@
     myFormatCtx      = theFormatCtx;
     myStream         = myFormatCtx->streams[theStreamId];
     myStreamId       = theStreamId;
-    myCodecCtx       = myStream->codec;
     myPtsStartBase   = detectPtsStartBase(theFormatCtx);
     myPtsStartStream = unitsToSeconds(myStream->start_time);
+    myIsAttachedPic  = stAV::isAttachedPicture(myStream);
+    if(stAV::getCodecType(myStream) != getCodecType()) {
+        signals.onError(stCString("Internal error: unsupported codec type"));
+        deinit();
+        return false;
+    }
+#ifdef ST_AV_NEWCODECPAR
+    myCodecAutoId = myStream->codecpar->codec_id;
+    myCodecCtx = avcodec_alloc_context3(NULL);
+    if(avcodec_parameters_to_context(myCodecCtx, myStream->codecpar) < 0) {
+        signals.onError(stCString("Internal error: unable to copy codec parameters"));
+        deinit();
+        return false;
+    }
+
+#else
+    myCodecCtx    = stAV::getCodecCtx(myStream);
+    myCodecAutoId = myCodecCtx->codec_id;
+#endif
+
     myGetFrmtInit    = myCodecCtx->get_format;
 #if(LIBAVCODEC_VERSION_INT >= AV_VERSION_INT(55, 0, 0))
     myGetBuffInit    = myCodecCtx->get_buffer2;
 #endif
-    myIsAttachedPic = stAV::isAttachedPicture(myStream);
+
+    if(myCodecAutoId == AV_CODEC_ID_TEXT) {
+        return true; // special case - decoder is not needed
+    }
+
+    myCodec = NULL;
+    myCodecAuto = avcodec_find_decoder(myCodecAutoId);
+    if(myCodecAuto == NULL) {
+        switch(getCodecType()) {
+            case AVMEDIA_TYPE_VIDEO:
+                signals.onError(stCString("FFmpeg: Video codec not found"));
+                break;
+            case AVMEDIA_TYPE_AUDIO:
+                signals.onError(stCString("FFmpeg: Audio codec not found"));
+                break;
+            case AVMEDIA_TYPE_SUBTITLE:
+                signals.onError(stCString("FFmpeg: Subtitle codec not found"));
+                break;
+            default:
+                signals.onError(stCString("FFmpeg: codec not found"));
+                break;
+        }
+        deinit();
+        return false;
+    }
+
     return true;
 }
 
@@ -118,16 +163,25 @@
     myFileName.clear();
     myFormatCtx = NULL;
     myStream    = NULL;
+    if(myCodec != NULL) {
+        fillCodecInfo(NULL);
+    }
+#ifdef ST_AV_NEWCODECPAR
+    if(myCodecCtx != NULL) {
+        avcodec_free_context(&myCodecCtx);
+    }
+#else
     if(myCodec != NULL && myCodecCtx != NULL) {
         avcodec_close(myCodecCtx);
         myCodecCtx->get_format  = myGetFrmtInit;
     #if(LIBAVCODEC_VERSION_INT >= AV_VERSION_INT(55, 0, 0))
         myCodecCtx->get_buffer2 = myGetBuffInit;
     #endif
-        fillCodecInfo(NULL);
     }
+#endif
     myCodec       = NULL;
     myCodecAuto   = NULL;
+    myCodecAutoId = AV_CODEC_ID_NONE;
     myCodecCtx    = NULL;
     myGetFrmtInit = NULL;
     myGetBuffInit = NULL;

sview-17_04.tar.gz/StMoviePlayer/StVideo/StAVPacketQueue.h -> sview-20_08.tar.gz/StMoviePlayer/StVideo/StAVPacketQueue.h Changed

@@ -59,6 +59,11 @@
     ST_LOCAL void clear();
 
     /**
+     * Return codec type.
+     */
+    ST_LOCAL virtual AVMediaType getCodecType() const = 0;
+
+    /**
      * Close stream.
      */
     ST_LOCAL virtual void deinit();
@@ -229,9 +234,9 @@
     /**
      * Open stream.
      */
-    ST_LOCAL virtual bool init(AVFormatContext*   theFormatCtx,
-                               const unsigned int theStreamId,
-                               const StString&    theFileName);
+    ST_LOCAL bool init(AVFormatContext*   theFormatCtx,
+                       const unsigned int theStreamId,
+                       const StString&    theFileName);
 
         protected: //! @name Fields should be full-controlled by heirs
 
@@ -241,6 +246,7 @@
     AVCodecContext*  myCodecCtx;       //!< codec context
     AVCodec*         myCodec;          //!< codec
     AVCodec*         myCodecAuto;      //!< original codec (autodetected - before overriding)
+    AVCodecID        myCodecAutoId;    //!< original code id
     typedef AVPixelFormat (*aGetFrmt_t)(AVCodecContext* , const AVPixelFormat* );
     typedef int           (*aGetBuf2_t)(AVCodecContext* , AVFrame* frame, int );
     aGetFrmt_t       myGetFrmtInit;
@@ -270,6 +276,8 @@
     double           mySizeSeconds;    //!< cumulative packets length in seconds
     mutable StMutex  myMutex;          //!< lock for thread-safety
 
+        protected:
+
     StString         myCodecName;      //!< active codec name
     StString         myCodecDesc;      //!< active codec description
     StString         myCodecStr;       //!< active codec description

sview-17_04.tar.gz/StMoviePlayer/StVideo/StAudioQueue.cpp -> sview-20_08.tar.gz/StMoviePlayer/StVideo/StAudioQueue.cpp Changed

@@ -736,29 +736,22 @@
         return false;
     }
 
-    if(!StAVPacketQueue::init(theFormatCtx, theStreamId, theFileName)
-    || myCodecCtx->codec_type != AVMEDIA_TYPE_AUDIO) {
+    if(!StAVPacketQueue::init(theFormatCtx, theStreamId, theFileName)) {
         signals.onError(stCString("FFmpeg: invalid stream"));
         deinit();
         return false;
     }
 
-    // get AUDIO codec
-    myCodec = avcodec_find_decoder(myCodecCtx->codec_id);
-    if(myCodec == NULL) {
-        signals.onError(stCString("FFmpeg: audio codec not found"));
-        deinit();
-        return false;
-    }
 #if(LIBAVCODEC_VERSION_INT >= AV_VERSION_INT(53, 8, 0))
-    if(avcodec_open2(myCodecCtx, myCodec, NULL) < 0) {
+    if(avcodec_open2(myCodecCtx, myCodecAuto, NULL) < 0) {
 #else
-    if(avcodec_open(myCodecCtx, myCodec) < 0) {
+    if(avcodec_open(myCodecCtx, myCodecAuto) < 0) {
 #endif
         signals.onError(stCString("FFmpeg: could not open audio codec"));
         deinit();
         return false;
     }
+    myCodec = myCodecAuto;
 
     // setup buffers
     if(!initBuffers()) {
@@ -923,6 +916,8 @@
         );
     }
     myDbgPrevQueued = aQueued;
+#else
+    (void )myDbgPrevQueued;
 #endif
 
     if((aState == AL_PLAYING
@@ -1112,18 +1107,38 @@
     int anAudioPktSize = thePacket->getSize();
     bool checkMoreFrames = false;
     int isGotFrame = 0;
+    bool toSendPacket = true;
     // packet could store multiple frames
     for(;;) {
         while(anAudioPktSize > 0) {
             int aDataSize = (int )myBufferSrc.getBufferSizeWhole();
 
-        #if(LIBAVCODEC_VERSION_INT >= AV_VERSION_INT(52, 23, 0))
+        #if(LIBAVCODEC_VERSION_INT >= AV_VERSION_INT(57, 106, 102))
+            (void )aDataSize;
+            if(toSendPacket) {
+                const int aRes = avcodec_send_packet(myCodecCtx, thePacket->getType() == StAVPacket::DATA_PACKET ? thePacket->getAVpkt() : NULL);
+                if(aRes < 0 && aRes != AVERROR_EOF) {
+                    anAudioPktSize = 0;
+                    break;
+                }
+                toSendPacket = false;
+            }
+
+            myFrame.reset();
+            const int aRes2 = avcodec_receive_frame(myCodecCtx, myFrame.Frame);
+            if(aRes2 < 0) {
+                anAudioPktSize = 0;
+                break;
+            }
+            isGotFrame = 1;
+            int aLen1 = 0; // dummy for code compatible with old syntax
+        #elif(LIBAVCODEC_VERSION_INT >= AV_VERSION_INT(52, 23, 0))
             StAVPacket anAvPkt;
             anAvPkt.getAVpkt()->data = (uint8_t* )anAudioPktData;
             anAvPkt.getAVpkt()->size = anAudioPktSize;
+            (void )toSendPacket;
 
             #if(LIBAVCODEC_VERSION_INT >= AV_VERSION_INT(53, 40, 0))
-            //av_frame_unref(myFrame.Frame);
             (void )aDataSize;
             myFrame.reset();
             const int aLen1 = avcodec_decode_audio4(myCodecCtx, myFrame.Frame,
@@ -1270,6 +1285,16 @@
                 aPts = 0.0;
                 continue;
             }
+            case StAVPacket::DATA_PACKET: {
+                break;
+            }
+            case StAVPacket::LAST_PACKET: {
+            #if(LIBAVCODEC_VERSION_INT >= AV_VERSION_INT(57, 106, 102))
+                break; // redirect NULL packet to avcodec_send_packet()
+            #else
+                continue;
+            #endif
+            }
             case StAVPacket::END_PACKET: {
                 pushPlayEvent(ST_PLAYEVENT_NONE);
                 // TODO (Kirill Gavrilov#3#) improve file-by-file playback

sview-17_04.tar.gz/StMoviePlayer/StVideo/StAudioQueue.h -> sview-20_08.tar.gz/StMoviePlayer/StVideo/StAudioQueue.h Changed

sview-17_04.tar.gz/StMoviePlayer/StVideo/StSubtitleQueue.cpp -> sview-20_08.tar.gz/StMoviePlayer/StVideo/StSubtitleQueue.cpp Changed

@@ -42,6 +42,7 @@
   myOutQueue(theSubtitlesQueue),
   myThread(NULL),
   evDowntime(true),
+  myImageScale(1.0f),
   toQuit(false) {
     myThread = new StThread(threadFunction, (void* )this, "StSubtitleQueue");
 }
@@ -59,36 +60,25 @@
 bool StSubtitleQueue::init(AVFormatContext*   theFormatCtx,
                            const unsigned int theStreamId,
                            const StString&    theFileName) {
-    if(!StAVPacketQueue::init(theFormatCtx, theStreamId, theFileName)
-    || myCodecCtx->codec_type != AVMEDIA_TYPE_SUBTITLE) {
+    myImageScale = 1.0f;
+    if(!StAVPacketQueue::init(theFormatCtx, theStreamId, theFileName)) {
         signals.onError(stCString("FFmpeg: invalid stream"));
         deinit();
         return false;
     }
 
-#if(LIBAVCODEC_VERSION_INT >= AV_VERSION_INT(54, 51, 100))
-    if(myCodecCtx->codec_id != AV_CODEC_ID_TEXT) {
-#else
-    if(myCodecCtx->codec_id != CODEC_ID_TEXT) {
-#endif
-        // find the decoder for the subtitles stream
-        myCodec = avcodec_find_decoder(myCodecCtx->codec_id);
-        if(myCodec == NULL) {
-            signals.onError(stCString("FFmpeg: Subtitle decoder not found"));
-            deinit();
-            return false;
-        }
-
+    if(myCodecAutoId != AV_CODEC_ID_TEXT) {
         // open SUBTITLE codec
     #if(LIBAVCODEC_VERSION_INT >= AV_VERSION_INT(53, 8, 0))
-        if(avcodec_open2(myCodecCtx, myCodec, NULL) < 0) {
+        if(avcodec_open2(myCodecCtx, myCodecAuto, NULL) < 0) {
     #else
-        if(avcodec_open(myCodecCtx, myCodec) < 0) {
+        if(avcodec_open(myCodecCtx, myCodecAuto) < 0) {
     #endif
             signals.onError(stCString("FFmpeg: Could not open subtitle codec"));
             deinit();
             return false;
         }
+        myCodec = myCodecAuto;
 
         // initialize ASS parser
     #if(LIBAVCODEC_VERSION_INT >= AV_VERSION_INT(52, 95, 0))
@@ -97,6 +87,9 @@
                    myCodecCtx->subtitle_header_size);
     #endif
     }
+    if(myCodecAuto != NULL && StString(myCodecAuto->name).isEquals(stCString("pgssub"))) {
+        myImageScale = 0.5f;
+    }
     fillCodecInfo(myCodec);
     return true;
 }
@@ -137,6 +130,12 @@
                 myOutQueue->clear();
                 continue;
             }
+            case StAVPacket::DATA_PACKET: {
+                break;
+            }
+            case StAVPacket::LAST_PACKET: {
+                continue; // ignore as avcodec_send_packet() is not used
+            }
             case StAVPacket::END_PACKET: {
                 if(toQuit) {
                     return;
@@ -177,6 +176,15 @@
 
                             StHandle<StSubItem> aNewSubItem = new StSubItem(aPts, aPts + aDuration);
                             aNewSubItem->Image.initTrash(StImagePlane::ImgRGBA, aRect->w, aRect->h);
+                            aNewSubItem->Scale = myImageScale;
+
+                        #if(LIBAVCODEC_VERSION_INT >= AV_VERSION_INT(57, 9, 100))
+                            uint8_t** anImgData = aRect->data;
+                            int* anImgLineSizes = aRect->linesize;
+                        #else
+                            uint8_t** anImgData = aRect->pict.data;
+                            int* anImgLineSizes = aRect->pict.linesize;
+                        #endif
 
                             SwsContext* aCtxToRgb = sws_getContext(aRect->w, aRect->h, stAV::PIX_FMT::PAL8,
                                                                    aRect->w, aRect->h, stAV::PIX_FMT::RGBA32,
@@ -186,20 +194,14 @@
                             }
 
                             uint8_t* aDstData[4] = {
-                                (uint8_t* )aNewSubItem->Image.getData(),
-                                NULL,
-                                NULL,
-                                NULL
+                                (uint8_t* )aNewSubItem->Image.getData(), NULL, NULL, NULL
                             };
                             /*const*/ int aDstLinesize[4] = {
-                                (int )aNewSubItem->Image.getSizeRowBytes(),
-                                0,
-                                0,
-                                0
+                                (int )aNewSubItem->Image.getSizeRowBytes(), 0, 0, 0
                             };
 
                             sws_scale(aCtxToRgb,
-                                      aRect->pict.data, aRect->pict.linesize,
+                                      anImgData, anImgLineSizes,
                                       0, aRect->h,
                                       aDstData, aDstLinesize);
                             sws_freeContext(aCtxToRgb);
@@ -220,7 +222,7 @@
                         }
                         case SUBTITLE_ASS: {
                             StString aTextData = aRect->ass;
-                            StHandle<StSubItem> aNewSubItem = myASS.parseEvent(aTextData, aPts);
+                            StHandle<StSubItem> aNewSubItem = myASS.parseEvent(aTextData, aPts, aDuration);
                             if(!aNewSubItem.isNull()) {
                                 myOutQueue->push(aNewSubItem);
                             }

sview-17_04.tar.gz/StMoviePlayer/StVideo/StSubtitleQueue.h -> sview-20_08.tar.gz/StMoviePlayer/StVideo/StSubtitleQueue.h Changed

@@ -51,14 +51,19 @@
     }
 
     /**
+     * Return codec type.
+     */
+    ST_LOCAL virtual AVMediaType getCodecType() const ST_ATTR_OVERRIDE { return AVMEDIA_TYPE_SUBTITLE; }
+
+    /**
      * Initialization function.
      * @param theFormatCtx pointer to video format context
      * @param streamId     stream id in video format context
      * @return true if no error
      */
-    ST_LOCAL virtual bool init(AVFormatContext*   theFormatCtx,
-                               const unsigned int theStreamId,
-                               const StString&    theFileName) ST_ATTR_OVERRIDE;
+    ST_LOCAL bool init(AVFormatContext*   theFormatCtx,
+                       const unsigned int theStreamId,
+                       const StString&    theFileName);
 
     /**
      * Clean function.
@@ -76,6 +81,7 @@
     StThread*            myThread;   //!< decoding loop thread
     StSubtitlesASS       myASS;      //!< ASS subtitles parser
     StCondition          evDowntime;
+    float                myImageScale;
     volatile bool        toQuit;
 
 };

sview-17_04.tar.gz/StMoviePlayer/StVideo/StSubtitlesASS.cpp -> sview-20_08.tar.gz/StMoviePlayer/StVideo/StSubtitlesASS.cpp Changed

@@ -1,5 +1,5 @@
 /**
- * Copyright © 2011-2014 Kirill Gavrilov <kirill@sview.ru>
+ * Copyright © 2011-2020 Kirill Gavrilov <kirill@sview.ru>
  *
  * StMoviePlayer program is free software: you can redistribute it and/or modify
  * it under the terms of the GNU General Public License as published by
@@ -191,18 +191,39 @@
             if(*anIter.getBufferHere() == stUtf8_t('i')) {
                 // italic
                 if(       *anIter.getBufferNext() == stUtf8_t('1')) {
-                    ///aText += "<i>";  // on
+                    aText += "<i>";
                 } else if(*anIter.getBufferNext() == stUtf8_t('0')) {
-                    ///aText += "</i>"; // off
+                    aText += "</i>";
                 }
             } else if(*anIter.getBufferHere() == stUtf8_t('b')) {
                 // bold
                 if(       *anIter.getBufferNext() == stUtf8_t('1')) {
-                    ///aText += "<b>";  // on
+                    aText += "<b>";
                 } else if(*anIter.getBufferNext() == stUtf8_t('0')) {
-                    ///aText += "</b>"; // off
+                    aText += "</b>";
                 }
-            }// else
+            } else if(*anIter.getBufferHere() == stUtf8_t('u')) {
+                // underline
+                if(       *anIter.getBufferNext() == stUtf8_t('1')) {
+                    //aText += "<u>";
+                } else if(*anIter.getBufferNext() == stUtf8_t('0')) {
+                    //aText += "</u>";
+                }
+            } else if(*anIter.getBufferHere() == stUtf8_t('s')) {
+                // strikeout
+                if(       *anIter.getBufferNext() == stUtf8_t('1')) {
+                    //aText += "<s>";
+                } else if(*anIter.getBufferNext() == stUtf8_t('0')) {
+                    //aText += "</s>";
+                }
+            } else if(*anIter.getBufferHere() == stUtf8_t('f')) {
+                if(*anIter.getBufferNext() == stUtf8_t('s')) {
+                    // font size
+                } else if(*anIter.getBufferNext() == stUtf8_t('n')) {
+                    // font name
+                }
+            }
+            // else
 
             // search for trailing bracket
             while(*anIter != stUtf32_t('}') && *anIter != 0) {
@@ -216,6 +237,9 @@
             aStart = anIter.getIndex() + 1;
         }
     }
+    if(aStart != 0) {
+        aText += theText.subString(aStart, theText.Length);
+    }
     if(!aText.isEmpty()) {
         // replace only if text contains style codes
         theText = aText;
@@ -223,7 +247,8 @@
 }
 
 StHandle<StSubItem> StSubtitlesASS::parseEvent(const StString& theString,
-                                               const double    thePts) {
+                                               double thePts,
+                                               double theDuration) {
     if(!isValid() || !theString.isStartsWithIgnoreCase(HEADER_Dialog)) {
         return StHandle<StSubItem>();
     }
@@ -249,6 +274,9 @@
     parseStyle(aText);
 
     double aDuration = parseTime(aList->getValue(myIdPtsEnd)) - parseTime(aList->getValue(myIdPtsStart));
+    if(aDuration <= 0.0) {
+        aDuration = theDuration; // why ASS information is wrong here on current FFmpeg?
+    }
     aText.replaceFast(ST_CRLF_REDUNDANT, ST_CRLF_REPLACEMENT);
     aText.replaceFast(ST_ASS_NEWLINE,    ST_NEWLINE_REPLACEMENT);
     aText.replaceFast(ST_ASS_NEWLINE2,   ST_NEWLINE_REPLACEMENT);

sview-17_04.tar.gz/StMoviePlayer/StVideo/StSubtitlesASS.h -> sview-20_08.tar.gz/StMoviePlayer/StVideo/StSubtitlesASS.h Changed

sview-17_04.tar.gz/StMoviePlayer/StVideo/StVideo.cpp -> sview-20_08.tar.gz/StMoviePlayer/StVideo/StVideo.cpp Changed

@@ -20,7 +20,10 @@
 #include "../StMoviePlayerInfo.h"
 #include "../StMoviePlayerStrings.h"
 
+#include "../StImageViewer/StImagePluginInfo.h"
+
 #include <StStrings/StFormatTime.h>
+#include <StAV/StAVIOJniHttpContext.h>
 
 using namespace StMoviePlayerStrings;
 
@@ -33,8 +36,69 @@
         aStVideo->mainLoop();
         return SV_THREAD_RETURN 0;
     }
+
+#ifdef ST_AV_NEWCODECPAR
+    /**
+     * Format framerate value.
+     */
+    static StString formatFps(double theVal) {
+        //const uint64_t aVal = lrintf(theVal * 100.0);
+        const uint64_t aVal = uint64_t(theVal * 100.0 + 0.5);
+        char aBuff[256];
+        if(aVal == 0) {
+            stsprintf(aBuff, sizeof(aBuff), "%1.4f", theVal);
+        } else if(aVal % 100) {
+            stsprintf(aBuff, sizeof(aBuff), "%3.2f", theVal);
+        } else if(aVal % (100 * 1000)) {
+            stsprintf(aBuff, sizeof(aBuff), "%1.0f", theVal);
+        } else {
+            stsprintf(aBuff, sizeof(aBuff), "%1.0fk", theVal / 1000);
+        }
+        return aBuff;
+    }
+#endif
+
+    /**
+     * Format stream info.
+     */
+    static StString formatStreamInfo(const AVStream* theStream) {
+        AVCodecContext* aCodecCtx = stAV::getCodecCtx(theStream);
+        char aFrmtBuff[4096] = {};
+        avcodec_string(aFrmtBuff, sizeof(aFrmtBuff), aCodecCtx, 0);
+        StString aStreamInfo(aFrmtBuff);
+
+    #ifdef ST_AV_NEWCODECPAR
+        //aStreamInfo = aStreamInfo + ", " + theStream->codec_info_nb_frames + ", " + theStream->time_base.num + "/" + theStream->time_base.den;
+        if(theStream->sample_aspect_ratio.num && av_cmp_q(theStream->sample_aspect_ratio, theStream->codecpar->sample_aspect_ratio)) {
+            AVRational aDispAspectRatio;
+            av_reduce(&aDispAspectRatio.num, &aDispAspectRatio.den,
+                      theStream->codecpar->width  * int64_t(theStream->sample_aspect_ratio.num),
+                      theStream->codecpar->height * int64_t(theStream->sample_aspect_ratio.den),
+                      1024 * 1024);
+            aStreamInfo = aStreamInfo + ", SAR " + theStream->sample_aspect_ratio.num + ":" + theStream->sample_aspect_ratio.den
+                                       + " DAR " + aDispAspectRatio.num + ":" + aDispAspectRatio.den;
+        }
+
+        if(theStream->codecpar->codec_type == AVMEDIA_TYPE_VIDEO) {
+            if(theStream->avg_frame_rate.den != 0 && theStream->avg_frame_rate.num != 0) {
+                aStreamInfo += StString(", ") + formatFps(av_q2d(theStream->avg_frame_rate)) + " fps";
+            }
+            if(theStream->r_frame_rate.den != 0 && theStream->r_frame_rate.num != 0) {
+                aStreamInfo += StString(", ") + formatFps(av_q2d(theStream->r_frame_rate)) + " tbr";
+            }
+            if(theStream->time_base.den != 0 && theStream->time_base.num != 0) {
+                aStreamInfo += StString(", ") + formatFps(1 / av_q2d(theStream->time_base)) + " tbn";
+            }
+            if(aCodecCtx->time_base.den != 0 && aCodecCtx->time_base.num != 0) {
+                aStreamInfo += StString(", ") + formatFps(1 / av_q2d(aCodecCtx->time_base)) + " tbc";
+            }
+        }
+    #endif
+        return aStreamInfo;
+    }
 }
 
+const char* StVideo::ST_IMAGES_MIME_STRING = ST_IMAGE_PLUGIN_MIME_CHAR;
 const char* StVideo::ST_VIDEOS_MIME_STRING = ST_VIDEO_PLUGIN_MIME_CHAR;
 
 StVideo::StVideo(const std::string&                 theALDeviceName,
@@ -47,6 +111,7 @@
 : myMimesVideo(ST_VIDEOS_MIME_STRING),
   myMimesAudio(ST_AUDIOS_MIME_STRING),
   myMimesSubs(ST_SUBTIT_MIME_STRING),
+  myMimesImages(ST_IMAGES_MIME_STRING),
   myResMgr(theResMgr),
   myLangMap(theLangMap),
   mySlaveCtx(NULL),
@@ -252,7 +317,6 @@
     // open video file
     StString aFileName, aDummy;
     StFileNode::getFolderAndFile(theFileToLoad, aDummy, aFileName);
-    AVFormatContext* aFormatCtx = NULL;
 
     StHandle<StAVIOContext> anIOContext;
     if(StFileNode::isContentProtocolPath(theFileToLoad)) {
@@ -260,12 +324,26 @@
         if(aFileDescriptor != -1) {
             StHandle<StAVIOFileContext> aFileCtx = new StAVIOFileContext();
             if(aFileCtx->openFromDescriptor(aFileDescriptor, "rb")) {
-                aFormatCtx = avformat_alloc_context();
-                aFormatCtx->pb = aFileCtx->getAvioContext();
                 anIOContext = aFileCtx;
             }
         }
     }
+#if defined(__ANDROID__)
+    else if(theFileToLoad.isStartsWith(stCString("https://"))) {
+        static const bool hasHttpsProtocol = stAV::isEnabledInputProtocol("https");
+        if(!hasHttpsProtocol) {
+            StHandle<StAVIOJniHttpContext> aHttpCtx = new StAVIOJniHttpContext();
+            if(aHttpCtx->open(theFileToLoad)) {
+                anIOContext = aHttpCtx;
+            }
+        }
+    }
+#endif
+    AVFormatContext* aFormatCtx = NULL;
+    if(!anIOContext.isNull()) {
+        aFormatCtx = avformat_alloc_context();
+        aFormatCtx->pb = anIOContext->getAvioContext();
+    }
 
 #if(LIBAVFORMAT_VERSION_INT >= AV_VERSION_INT(53, 2, 0))
     int avErrCode = avformat_open_input(&aFormatCtx, theFileToLoad.toCString(), NULL, NULL);
@@ -333,10 +411,16 @@
 
     theInfo.Duration = stMax(theInfo.Duration, stAV::unitsToSeconds(aFormatCtx->duration));
     for(unsigned int aStreamId = 0; aStreamId < aFormatCtx->nb_streams; ++aStreamId) {
-        AVStream* aStream = aFormatCtx->streams[aStreamId];
+        AVStream*         aStream    = aFormatCtx->streams[aStreamId];
+        const AVMediaType aCodecType = stAV::getCodecType(aStream);
         theInfo.Duration = stMax(theInfo.Duration, stAV::unitsToSeconds(aStream, aStream->duration));
 
-        if(aStream->codec->codec_type == AVMEDIA_TYPE_VIDEO) {
+        StString aLang = stAV::meta::readLang(aStream);
+        if(aLang == "und") {
+            aLang.clear();
+        }
+
+        if(aCodecType == AVMEDIA_TYPE_VIDEO) {
             // video track
             if(!myVideoMaster->isInitialized()) {
                 myVideoMaster->init(aFormatCtx, aStreamId, aTitleString, theNewParams);
@@ -367,7 +451,7 @@
                 }
             } else if(!myVideoSlave->isInitialized()
                    && !stAV::isAttachedPicture(aStream)) {
-                myVideoSlave->init(aFormatCtx, aStreamId, "", theNewParams);
+                myVideoSlave->init(aFormatCtx, aStreamId, aTitleString, theNewParams);
                 if(myVideoSlave->isInitialized()) {
                     mySlaveCtx    = aFormatCtx;
                     mySlaveStream = aStreamId;
@@ -394,29 +478,19 @@
                     }
                 }
             }
-        } else if(aStream->codec->codec_type == AVMEDIA_TYPE_AUDIO) {
+        } else if(aCodecType == AVMEDIA_TYPE_AUDIO) {
             // audio track
-            AVCodecContext* aCodecCtx = aStream->codec;
             StString aCodecName;
-            AVCodec* aCodec = avcodec_find_decoder(aCodecCtx->codec_id);
+            AVCodec* aCodec = avcodec_find_decoder(stAV::getCodecId(aStream));
             if(aCodec != NULL) {
                 aCodecName = aCodec->name;
             }
 
+            AVCodecContext* aCodecCtx = stAV::getCodecCtx (aStream);
             StString aSampleFormat  = stAV::audio::getSampleFormatString (aCodecCtx);
             StString aSampleRate    = stAV::audio::getSampleRateString   (aCodecCtx);
             StString aChannelLayout = stAV::audio::getChannelLayoutString(aCodecCtx);
 
-            StString aLang;
-        #if(LIBAVUTIL_VERSION_INT >= AV_VERSION_INT(51, 5, 0))
-            stAV::meta::readTag(aStream, stCString("language"), aLang);
-        #else
-            aLang = aStream->language;
-        #endif
-            if(aLang == "und") {
-                aLang.clear();
-            }
-
             StString aStreamTitle = aCodecName;
             if(!aSampleRate.isEmpty()) {
                 aStreamTitle += StString(", ") + aSampleRate;
@@ -439,28 +513,17 @@
 
             if(!myAudio->isInitialized()
             && (aPrefLangAudio.isEmpty() || aLang == aPrefLangAudio)
-            &&  myAudio->init(aFormatCtx, aStreamId, "")) {
+            &&  myAudio->init(aFormatCtx, aStreamId, aTitleString)) {
                 theInfo.LoadedAudio = (int32_t )(theInfo.AudioList->size() - 1);
             }
-        } else if(aStream->codec->codec_type == AVMEDIA_TYPE_SUBTITLE) {
+        } else if(aCodecType == AVMEDIA_TYPE_SUBTITLE) {
             // subtitles track
-            AVCodecContext* aCodecCtx = aStream->codec;
             StString aCodecName("PLAIN");
-            AVCodec* aCodec = avcodec_find_decoder(aCodecCtx->codec_id);
+            AVCodec* aCodec = avcodec_find_decoder(stAV::getCodecId(aStream));
             if(aCodec != NULL) {
                 aCodecName = aCodec->name;
             }
 
-            StString aLang;
-        #if(LIBAVUTIL_VERSION_INT >= AV_VERSION_INT(51, 5, 0))
-            stAV::meta::readTag(aStream, stCString("language"), aLang);
-        #else
-            aLang = aStream->language;
-        #endif
-            if(aLang == "und") {
-                aLang.clear();
-            }
-
             StString aStreamTitle = aCodecName;
             if(!aLang.isEmpty()) {
                 aStreamTitle += StString(" (") + aLang + ")";
@@ -478,7 +541,7 @@
     && !theInfo.AudioList->isEmpty()) {
         for(unsigned int aStreamId = 0; aStreamId < aFormatCtx->nb_streams; ++aStreamId) {
             AVStream* aStream = aFormatCtx->streams[aStreamId];
-            if(aStream->codec->codec_type != AVMEDIA_TYPE_AUDIO) {
+            if(stAV::getCodecType(aStream) != AVMEDIA_TYPE_AUDIO) {
                 continue;
             }
 
@@ -489,7 +552,7 @@
             aLanguage = aStream->language;
         #endif
             if(aLanguage != aPrefLangAudio
-            && myAudio->init(aFormatCtx, aStreamId, "")) {
+            && myAudio->init(aFormatCtx, aStreamId, aTitleString)) {
                 theInfo.LoadedAudio = anAudioStreamId;
                 break;
             }
@@ -565,6 +628,33 @@
         }
     }
 
+    // read general information about streams
+    for(size_t aCtxIter = 0; aCtxIter < myCtxList.size(); ++aCtxIter) {
+        AVFormatContext* aFormatCtx = myCtxList[aCtxIter];
+
+        StString aFrmtInfo;
+        if(aFormatCtx->bit_rate != 0) {
+            aFrmtInfo += StString("bitrate: ") + (int64_t(aFormatCtx->bit_rate) / 1000) + " kb/s";
+        }
+        if(!aFrmtInfo.isEmpty()) {
+            StString aStreamInfoKey = StString("input ") + aCtxIter;
+            myFileInfoTmp->Info.add(StArgument(aStreamInfoKey, aFrmtInfo));
+        }
+
+        for(unsigned int aStreamId = 0; aStreamId < aFormatCtx->nb_streams; ++aStreamId) {
+            AVStream* aStream = aFormatCtx->streams[aStreamId];
+            StString aLang = stAV::meta::readLang(aStream);
+            if(aLang.isEmpty()) {
+                aLang = "und";
+            }
+
+            StString aStreamInfoKey = StString("steam ")
+                                    + (myCtxList.size() > 1 ? (StString() + aCtxIter + ":" + aStreamId) : (StString() + aStreamId))
+                                    + " [" + aLang + "]";
+            myFileInfoTmp->Info.add(StArgument(aStreamInfoKey, formatStreamInfo(aStream)));
+        }
+    }
+
     if(!myVideoMaster->isInitialized() && !myAudio->isInitialized()) {
         signals.onError(stCString("FFmpeg: Didn't found any video or audio streams"));
         return false;
@@ -678,6 +768,15 @@
         isSeekDone = doSeekStream(theFormatCtx, myVideoMaster->getId(), theSeekPts, toSeekBack);
     } else if(myVideoSlave->isInContext(theFormatCtx)) {
         isSeekDone = doSeekStream(theFormatCtx, myVideoSlave->getId(), theSeekPts, toSeekBack);
+    } else if(myAudio->isInContext(theFormatCtx)) {
+        //
+    } else if(mySubtitles->isInContext(theFormatCtx)) {
+        if(mySubtitles->getFileName().isEndsWithIgnoreCase(stCString(".srt"))) {
+            // workaround SRT seeking issues - make a heavy seek (usual size of SRT file is not greater than 200 KiB)
+            isSeekDone = doSeekStream(theFormatCtx, mySubtitles->getId(), 0.0, true);
+        } else {
+            isSeekDone = doSeekStream(theFormatCtx, mySubtitles->getId(), theSeekPts, toSeekBack);
+        }
     }
     if(!isSeekDone && myAudio->isInContext(theFormatCtx)) {
         // if no video stream or seeking was failed - try to seek Audio stream
@@ -690,7 +789,12 @@
         isSeekDone = av_seek_frame(theFormatCtx, -1, aSeekTarget, aFlags) >= 0;
         if(!isSeekDone) {
         #ifdef ST_DEBUG
-            ST_ERROR_LOG("Disaster! Seeking to " + theSeekPts + " [" + theFormatCtx->filename + "] has failed.");
+        #if(LIBAVFORMAT_VERSION_INT >= AV_VERSION_INT(58, 7, 100))
+            const char* aFileName = theFormatCtx->url;
+        #else
+            const char* aFileName = theFormatCtx->filename;
+        #endif
+            ST_ERROR_LOG("Disaster! Seeking to " + theSeekPts + " [" + aFileName + "] has failed.");
         #endif
         }
     }
@@ -718,8 +822,8 @@
 
     if(!isSeekDone) {
         ST_DEBUG_LOG("Error while seeking"
-                   + (aStream->codec->codec_type == AVMEDIA_TYPE_VIDEO ? " Video"
-                   : (aStream->codec->codec_type == AVMEDIA_TYPE_AUDIO ? " Audio" : " "))
+                   + (stAV::getCodecType(aStream) == AVMEDIA_TYPE_VIDEO ? " Video"
+                   : (stAV::getCodecType(aStream) == AVMEDIA_TYPE_AUDIO ? " Audio" : " "))
                    +  "stream to " + theSeekPts + "sec(" + (theSeekPts + stAV::unitsToSeconds(aStream, aStream->start_time)) + "sec)");
     }
     return isSeekDone;
@@ -747,6 +851,7 @@
         doFlush();
         if(myVideoMaster->isInitialized()) {
             const StString   aFileNameMaster = myVideoMaster->getFileName();
+            const StString   aFileNameSlave  = myVideoSlave ->getFileName();
             AVFormatContext* aCtxMaster      = myVideoMaster->getContext();
             const signed int aStreamIdMaster = myVideoMaster->getId();
             myVideoMaster->pushEnd();
@@ -770,7 +875,7 @@
             myVideoMaster->init(aCtxMaster, aStreamIdMaster, aFileNameMaster, myCurrParams);
             myVideoMaster->setSlave(NULL);
             if(toDecodeSlave) {
-                myVideoSlave->init(mySlaveCtx, mySlaveStream, "", myCurrParams);
+                myVideoSlave->init(mySlaveCtx, mySlaveStream, aFileNameSlave, myCurrParams);
                 myVideoMaster->setSlave(myVideoSlave);
             }
             myVideoMaster->pushStart();
@@ -820,6 +925,7 @@
 
     StArrayList<StAVPacket> anAVPackets(myCtxList.size());
     StArrayList<bool> aQueueIsFull(myCtxList.size());
+    StArrayList<bool> aQueueIsEmpty(myCtxList.size());
     myPlayCtxList.clear();
     size_t anEmptyQueues = 0;
     size_t aCtxId = 0;
@@ -835,6 +941,7 @@
         myPlayCtxList.add(aFormatCtx);
         anAVPackets.add(StAVPacket(myCurrParams));
         aQueueIsFull.add(false);
+        aQueueIsEmpty.add(false);
     }
 
     // reset target FPS
@@ -851,6 +958,23 @@
                 // read next packet
                 if(av_read_frame(aFormatCtx, aPacket.getAVpkt()) < 0) {
                     ++anEmptyQueues;
+                    if(!aQueueIsEmpty[aCtxId]) {
+                        aQueueIsEmpty[aCtxId] = true;
+                        // force decoding of last frame
+                        const StAVPacket aDummyLastPacket(myCurrParams, StAVPacket::LAST_PACKET);
+                        if(myVideoMaster->isInContext(aFormatCtx)) {
+                            myVideoMaster->push(aDummyLastPacket);
+                        }
+                        if(myVideoSlave->isInContext(aFormatCtx)) {
+                            myVideoSlave->push(aDummyLastPacket);
+                        }
+                        if(myAudio->isInContext(aFormatCtx)) {
+                            myAudio->push(aDummyLastPacket);
+                        }
+                        if(mySubtitles->isInContext(aFormatCtx)) {
+                            mySubtitles->push(aDummyLastPacket);
+                        }
+                    }
                     continue;
                 }
             }
@@ -949,9 +1073,9 @@
                 for(aCtxId = 0; aCtxId < myCtxList.size() && !myAudio->isInitialized(); ++aCtxId) {
                     aFormatCtx = myCtxList[aCtxId];
                     for(unsigned int aStreamId = 0; aStreamId < aFormatCtx->nb_streams; ++aStreamId) {
-                        if(aFormatCtx->streams[aStreamId]->codec->codec_type == AVMEDIA_TYPE_AUDIO) {
+                        if(stAV::getCodecType(aFormatCtx->streams[aStreamId]) == AVMEDIA_TYPE_AUDIO) {
                             if(aCounter == anActiveStreamId) {
-                                myAudio->init(aFormatCtx, aStreamId, "");
+                                myAudio->init(aFormatCtx, aStreamId, myFileList[aCtxId]);
                                 myAudio->pushStart();
                                 break;
                             }
@@ -1003,9 +1127,9 @@
                 for(aCtxId = 0; aCtxId < myCtxList.size() && !mySubtitles->isInitialized(); ++aCtxId) {
                     aFormatCtx = myCtxList[aCtxId];
                     for(unsigned int aStreamId = 0; aStreamId < aFormatCtx->nb_streams; ++aStreamId) {
-                        if(aFormatCtx->streams[aStreamId]->codec->codec_type == AVMEDIA_TYPE_SUBTITLE) {
+                        if(stAV::getCodecType(aFormatCtx->streams[aStreamId]) == AVMEDIA_TYPE_SUBTITLE) {
                             if(aCounter == anActiveStreamId) {
-                                mySubtitles->init(aFormatCtx, aStreamId, "");
+                                mySubtitles->init(aFormatCtx, aStreamId, myFileList[aCtxId]);
                                 mySubtitles->pushStart();
                                 break;
                             }
@@ -1058,6 +1182,7 @@
     #endif
 
         // All packets sent
+        bool isPendingPlayNext = false;
         if(anEmptyQueues == myPlayCtxList.size()) {
             bool areFlushed = false;
             // It seems FFmpeg fail to seek the stream after all packets were read...
@@ -1068,26 +1193,55 @@
                || !mySubtitles->isEmpty()   || !mySubtitles->isInDowntime()) {
                 StThread::sleep(10);
                 if(!areFlushed && (popPlayEvent(aSeekPts, toSeekBack) == ST_PLAYEVENT_NEXT)) {
+                    isPendingPlayNext = true;
                     doFlush();
                     if(myAudio->isInitialized()) {
                         myAudio->pushPlayEvent(ST_PLAYEVENT_SEEK, 0.0);
                     }
                     areFlushed = true;
+                    isPendingPlayNext = true;
                 }
             }
             // If video is played - always wait until audio played
-            if(myVideoMaster->isInitialized() && myAudio->isInitialized()) {
-                while(myAudio->stalIsAudioPlaying()) {
-                    StThread::sleep(10);
-                    if(!areFlushed && (popPlayEvent(aSeekPts, toSeekBack) == ST_PLAYEVENT_NEXT)) {
-                        doFlush();
-                        if(myAudio->isInitialized()) {
-                            myAudio->pushPlayEvent(ST_PLAYEVENT_SEEK, 0.0);
+            if(myVideoMaster->isInitialized()) {
+                if(myAudio->isInitialized()) {
+                    while(myAudio->stalIsAudioPlaying()) {
+                        StThread::sleep(10);
+                        if(!areFlushed && (popPlayEvent(aSeekPts, toSeekBack) == ST_PLAYEVENT_NEXT)) {
+                            isPendingPlayNext = true;
+                            doFlush();
+                            if(myAudio->isInitialized()) {
+                                myAudio->pushPlayEvent(ST_PLAYEVENT_SEEK, 0.0);
+                            }
+                            areFlushed = true;
+                            isPendingPlayNext = true;
+                            break;
+                        }
+                    }
+                } else if(myDuration < (double )params.SlideShowDelay->getValue()) {
+                    StTimer aDelayTimer;
+                    aDelayTimer.restart(myDuration * 1000.0);
+                    while(aDelayTimer.getElapsedTimeInSec() < (double )params.SlideShowDelay->getValue()) {
+                        StThread::sleep(10);
+                        if((popPlayEvent(aSeekPts, toSeekBack) == ST_PLAYEVENT_NEXT)) {
+                            isPendingPlayNext = true;
+                            break;
+                        }
+                        const bool isPaused = !isPlaying();
+                        if(isPaused) {
+                            aDelayTimer.pause();
+                        } else {
+                            aDelayTimer.resume();
                         }
-                        areFlushed = true;
                     }
                 }
             }
+            if(isPendingPlayNext) {
+                // resend event after it was pop out
+                pushPlayEvent(ST_PLAYEVENT_NEXT);
+                break;
+            }
+
             // end when any one in format context finished
             myCurrParams->Timestamp = 0.0f;
             break;
@@ -1100,7 +1254,7 @@
     if(myAudio->isInitialized())       myAudio->pushEnd();
     if(mySubtitles->isInitialized())   mySubtitles->pushEnd();
 
-    // what for queues receive 'end-packet'
+    // wait for queues receive 'end-packet'
     while(!myVideoMaster->isEmpty() || !myVideoMaster->isInDowntime()
        || !myAudio->isEmpty()       || !myAudio->isInDowntime()
        || !myVideoSlave->isEmpty()  || !myVideoSlave->isInDowntime()
@@ -1146,20 +1300,20 @@
         dataResult->initWrapper(dataLeft);
     }
 
-    StString title = myLangMap->getValue(StMoviePlayerStrings::DIALOG_SAVE_SNAPSHOT);
-    StMIMEList filter;
+    StOpenFileName anOpenInfo;
+    anOpenInfo.Title = myLangMap->getValue(StMoviePlayerStrings::DIALOG_SAVE_SNAPSHOT);
     StString saveExt;
     if(toSaveStereo) {
         switch(theImgType) {
             case StImageFile::ST_TYPE_PNG:
                 saveExt = "pns";
-                filter.add(StMIME("image/pns", saveExt,
-                                  "PNS - png  stereo image, lossless"));
+                anOpenInfo.Filter.add(StMIME("image/pns", saveExt,
+                                             "PNS - png  stereo image, lossless"));
                 break;
             case StImageFile::ST_TYPE_JPEG:
                 saveExt = "jps";
-                filter.add(StMIME("image/jps", saveExt,
-                                  "JPS - jpeg stereo image, lossy"));
+                anOpenInfo.Filter.add(StMIME("image/jps", saveExt,
+                                             "JPS - jpeg stereo image, lossy"));
                 break;
             default:
                 return false;
@@ -1168,13 +1322,13 @@
         switch(theImgType) {
             case StImageFile::ST_TYPE_PNG:
                 saveExt = "png";
-                filter.add(StMIME("image/png", saveExt,
-                                  "PNG image, lossless"));
+                anOpenInfo.Filter.add(StMIME("image/png", saveExt,
+                                             "PNG image, lossless"));
                 break;
             case StImageFile::ST_TYPE_JPEG:
                 saveExt = "jpg";
-                filter.add(StMIME("image/jpg", saveExt,
-                                  "JPEG image, lossy"));
+                anOpenInfo.Filter.add(StMIME("image/jpg", saveExt,
+                                             "JPEG image, lossy"));
                 break;
             default:
                 return false;
@@ -1182,7 +1336,8 @@
     }
 
     StString fileToSave;
-    if(StFileNode::openFileDialog(myCurrNode->getFolderPath(), title, filter, fileToSave, true)) {
+    anOpenInfo.Folder = myCurrNode->getFolderPath();
+    if(StFileNode::openFileDialog(fileToSave, anOpenInfo, true)) {
         if(StFileNode::getExtension(fileToSave) != saveExt) {
             fileToSave += StString('.') + saveExt;
         }
@@ -1252,6 +1407,7 @@
         // wait for initial message
         waitEvent();
         if(toQuit) {
+            close();
             myQuitEvent.set();
             return;
         }
@@ -1270,12 +1426,12 @@
 
         if(myVideoMaster->isInContext(myCtxList[0])) {
             myVideoTimer = new StVideoTimer(myVideoMaster, myAudio,
-                1000.0 * av_q2d(myCtxList[0]->streams[myVideoMaster->getId()]->codec->time_base));
+                1000.0 * av_q2d(stAV::getCodecCtx(myCtxList[0]->streams[myVideoMaster->getId()])->time_base));
             myVideoTimer->setAudioDelay(myAudioDelayMSec);
             myVideoTimer->setBenchmark(myIsBenchmark);
         } else if(myCtxList.size() > 1 && myVideoMaster->isInContext(myCtxList[1])) {
             myVideoTimer = new StVideoTimer(myVideoMaster, myAudio,
-                1000.0 * av_q2d(myCtxList[1]->streams[myVideoMaster->getId()]->codec->time_base));
+                1000.0 * av_q2d(stAV::getCodecCtx(myCtxList[1]->streams[myVideoMaster->getId()])->time_base));
             myVideoTimer->setAudioDelay(myAudioDelayMSec);
             myVideoTimer->setBenchmark(myIsBenchmark);
         } else {
@@ -1311,6 +1467,9 @@
                 myPlayList->walkToNext(false);
             }
             if(toQuit) {
+                // make sure to close AVIO contexts from the same working thread,
+                // because some of them can be attached to specific thread (like StAVIOJniHttpContext to JavaVM)
+                close();
                 myQuitEvent.set();
                 return;
             }

sview-17_04.tar.gz/StMoviePlayer/StVideo/StVideo.h -> sview-20_08.tar.gz/StMoviePlayer/StVideo/StVideo.h Changed

@@ -91,18 +91,15 @@
         public: //! @name public methods
 
     static const char* ST_VIDEOS_MIME_STRING;
+    static const char* ST_IMAGES_MIME_STRING;
 
-    ST_LOCAL const StMIMEList& getMimeListVideo() const {
-        return myMimesVideo;
-    }
+    ST_LOCAL const StMIMEList& getMimeListVideo() const { return myMimesVideo; }
 
-    ST_LOCAL const StMIMEList& getMimeListAudio() const {
-        return myMimesAudio;
-    }
+    ST_LOCAL const StMIMEList& getMimeListAudio() const { return myMimesAudio; }
 
-    ST_LOCAL const StMIMEList& getMimeListSubtitles() const {
-        return myMimesSubs;
-    }
+    ST_LOCAL const StMIMEList& getMimeListSubtitles() const { return myMimesSubs; }
+
+    ST_LOCAL const StMIMEList& getMimeListImages() const { return myMimesImages; }
 
     /**
      * Main constructor.
@@ -165,6 +162,13 @@
     }
 
     /**
+     * Set theater mode.
+     */
+    ST_LOCAL void setTheaterMode(bool theIsTheater) {
+        myVideoMaster->setTheaterMode(theIsTheater);
+    }
+
+    /**
      * Stick to panorama 360 mode.
      */
     ST_LOCAL void setStickPano360(bool theToStick) {
@@ -172,6 +176,11 @@
     }
 
     /**
+     * Set if JPS file should be read as Left/Right (TRUE) of as Right/Left (FALSE).
+     */
+    ST_LOCAL void setSwapJPS(bool theToSwap) { myVideoMaster->setSwapJPS(theToSwap); }
+
+    /**
      * Retrieve information about currently played file.
      */
     ST_LOCAL StHandle<StMovieInfo> getFileInfo(const StHandle<StStereoParams>& theParams) const;
@@ -264,6 +273,7 @@
         StHandle<StBoolParam>         UseOpenJpeg;     //!< use OpenJPEG (libopenjpeg) instead of built-in jpeg2000 decoder
         StHandle<StBoolParam>         ToSearchSubs;    //!< automatically search for additional subtitles/audio track files nearby video file
         StHandle<StBoolParamNamed>    ToTrackHeadAudio;//!< enable/disable head-tracking for audio listener
+        StHandle<StFloat32Param>      SlideShowDelay;  //!< slideshow delay
         StHandle<StParamActiveStream> activeAudio;     //!< active Audio stream
         StHandle<StParamActiveStream> activeSubtitles; //!< active Subtitles stream
 
@@ -368,6 +378,9 @@
      */
     ST_LOCAL void close();
 
+    /**
+     * Dispatch packets from format contexts to decoding queues.
+     */
     ST_LOCAL void packetsLoop();
 
     /**
@@ -432,6 +445,7 @@
     StMIMEList                    myMimesVideo;
     StMIMEList                    myMimesAudio;
     StMIMEList                    myMimesSubs;
+    StMIMEList                    myMimesImages;
     StHandle<StThread>            myThread;      //!< main loop thread
     StHandle<StResourceManager>   myResMgr;      //!< resource manager
     StHandle<StTranslations>      myLangMap;     //!< translations dictionary

sview-17_04.tar.gz/StMoviePlayer/StVideo/StVideoDxva2.cpp -> sview-20_08.tar.gz/StMoviePlayer/StVideo/StVideoDxva2.cpp Changed

@@ -131,7 +131,7 @@
     /**
      * Destroy decoder.
      */
-    virtual void decoderDestroy() ST_ATTR_OVERRIDE {
+    virtual void decoderDestroy(AVCodecContext* ) ST_ATTR_OVERRIDE {
         myPoolsTmp[0].release();
         myPoolsTmp[1].release();
         myPoolsTmp[2].release();
@@ -229,7 +229,7 @@
 };
 
 void StDxva2Context::release() {
-    decoderDestroy();
+    decoderDestroy(NULL);
     if(myDecoderService != NULL) {
         myDecoderService->Release();
         myDecoderService = NULL;
@@ -497,14 +497,14 @@
 bool StDxva2Context::decoderCreate(StVideoQueue&   theVideo,
                                    AVCodecContext* theCodecCtx) {
     const StSignal<void (const StCString& )>& onError = theVideo.signals.onError;
-    decoderDestroy();
+    decoderDestroy(theCodecCtx);
     theCodecCtx->hwaccel_context = NULL;
 
     uint32_t aNbGuids  = 0;
     GUID*    aGuidList = NULL;
     if(myDecoderService->GetDecoderDeviceGuids(&aNbGuids, &aGuidList) != S_OK) {
         onError(stCString("StVideoQueue: Failed to retrieve decoder DXVA2 device GUIDs"));
-        decoderDestroy();
+        decoderDestroy(theCodecCtx);
         return false;
     }
 
@@ -550,7 +550,7 @@
 
     if(::IsEqualGUID(aDeviceGuid, GUID_NULL)) {
         onError(stCString("StVideoQueue: No DXVA2 decoder device for codec found"));
-        decoderDestroy();
+        decoderDestroy(theCodecCtx);
         return false;
     }
 
@@ -565,7 +565,7 @@
     DXVA2_ConfigPictureDecode  aBestCfg = {{0}};
     if(myDecoderService->GetDecoderConfigurations(aDeviceGuid, &aDesc, NULL, &aNbConfigs, &aCfgList) != S_OK) {
         onError(stCString("StVideoQueue: Unable to retrieve DXVA2 decoder configurations"));
-        decoderDestroy();
+        decoderDestroy(theCodecCtx);
         return false;
     }
 
@@ -592,7 +592,7 @@
     ::CoTaskMemFree(aCfgList);
     if(aBestScore == 0) {
         onError(stCString("StVideoQueue: No valid DXVA2 decoder configuration available"));
-        decoderDestroy();
+        decoderDestroy(theCodecCtx);
         return false;
     }
 
@@ -628,7 +628,7 @@
     if(myD3dSurfaces == NULL
     || mySurfInfos   == NULL) {
         ST_ERROR_LOG(stCString("StVideoQueue: Unable to allocate surface arrays"));
-        decoderDestroy();
+        decoderDestroy(theCodecCtx);
         return false;
     }
 
@@ -640,7 +640,7 @@
                                                      myD3dSurfaces, NULL);
     if(anHRes != S_OK) {
         onError(StString("StVideoQueue: Failed to create ") + myNbSurfaces + " video surfaces");
-        decoderDestroy();
+        decoderDestroy(theCodecCtx);
         return false;
     }
 
@@ -649,7 +649,7 @@
                                                   myNbSurfaces, &myDxvaDecoder);
     if(anHRes != S_OK) {
         onError(stCString("StVideoQueue: Failed to create DXVA2 video decoder"));
-        decoderDestroy();
+        decoderDestroy(theCodecCtx);
         return false;
     }

sview-17_04.tar.gz/StMoviePlayer/StVideo/StVideoQueue.cpp -> sview-20_08.tar.gz/StMoviePlayer/StVideo/StVideoQueue.cpp Changed

@@ -1,5 +1,5 @@
 /**
- * Copyright © 2009-2017 Kirill Gavrilov <kirill@sview.ru>
+ * Copyright © 2009-2019 Kirill Gavrilov <kirill@sview.ru>
  *
  * StMoviePlayer program is free software: you can redistribute it and/or modify
  * it under the terms of the GNU General Public License as published by
@@ -28,16 +28,6 @@
 
 namespace {
 
-#if defined(__APPLE__) || defined(__ANDROID__)
-    /**
-     * Override pixel format.
-     */
-    AVPixelFormat stGetFormatYUV420P(AVCodecContext*      /*theCtx*/,
-                                     const AVPixelFormat* /*theFmt*/) {
-        return stAV::PIX_FMT::YUV420P;
-    }
-#endif
-
 #if(LIBAVCODEC_VERSION_INT < AV_VERSION_INT(55, 0, 0))
     /**
      * Release the frame buffer (old API).
@@ -70,7 +60,7 @@
         return avcodec_default_get_format(myCodecCtx, theFormats);
     }
 
-    for(const AVPixelFormat* aFormatIter = theFormats; *aFormatIter != -1; ++aFormatIter) {
+    for(const AVPixelFormat* aFormatIter = theFormats; *aFormatIter != stAV::PIX_FMT::NONE; ++aFormatIter) {
         /*const AVPixFmtDescriptor* aDesc = av_pix_fmt_desc_get(*aFormatIter);
         if(!(aDesc->flags & AV_PIX_FMT_FLAG_HWACCEL)) {
             return *aFormatIter;
@@ -84,6 +74,19 @@
             }
             return *aFormatIter;
         }
+    #elif defined(__APPLE__)
+        if(*aFormatIter == stAV::PIX_FMT::VIDEOTOOLBOX_VLD) {
+            if(!hwaccelInit()) {
+                myIsGpuFailed = true;
+                return avcodec_default_get_format(myCodecCtx, theFormats);
+            }
+            return *aFormatIter;
+        }
+    #elif defined(__ANDROID__)
+        if(*aFormatIter == AV_PIX_FMT_MEDIACODEC) {
+            // decoding into surface (like android.graphics.SurfaceTexture) is not yet support
+            return *aFormatIter;
+        }
     #endif
     }
 
@@ -104,6 +107,15 @@
             }
             isDone  = true;
         }
+    /*#elif defined(__APPLE__) // standard FFmpeg VideoToolbox wrapper is used - action is not needed
+        if(theFrame->format == stAV::PIX_FMT::VIDEOTOOLBOX_VLD) {
+            if(!myHWAccelCtx.isNull()) {
+                aResult = myHWAccelCtx->getFrameBuffer(*this, theFrame);
+            } else {
+                aResult = -1;
+            }
+            isDone  = true;
+        }*/
     #endif
         if(!isDone) {
             aResult = avcodec_default_get_buffer2(myCodecCtx, theFrame, theFlags);
@@ -134,7 +146,7 @@
     return aResult;
 }
 
-#if !defined(_WIN32)
+#if !defined(_WIN32) && !defined(__APPLE__)
 bool StVideoQueue::hwaccelInit() { return false; }
 #endif
 
@@ -156,10 +168,10 @@
   myTextureQueue(theTextureQueue),
   myHasDataState(false),
   myMaster(theMaster),
-#if defined(__APPLE__)
-  myCodecH264HW(avcodec_find_decoder_by_name("h264_vda")),
-#elif defined(__ANDROID__)
+#if defined(__ANDROID__)
   myCodecH264HW(avcodec_find_decoder_by_name("h264_mediacodec")),
+  myCodecHevcHW(avcodec_find_decoder_by_name("hevc_mediacodec")),
+  myCodecVp9HW (avcodec_find_decoder_by_name("vp9_mediacodec")),
 #endif
   myCodecOpenJpeg(avcodec_find_decoder_by_name("libopenjpeg")),
   myUseGpu(false),
@@ -187,7 +199,9 @@
   myStFormatByUser(StFormat_AUTO),
   myStFormatByName(StFormat_AUTO),
   myStFormatInStream(StFormat_AUTO),
-  myToStickPano360(false) {
+  myIsTheaterMode(false),
+  myToStickPano360(false),
+  myToSwapJps(false) {
 #ifdef ST_USE64PTR
     myFrame.Frame->opaque = (void* )stAV::NOPTS_VALUE;
 #else
@@ -256,10 +270,31 @@
                              const bool theToUseGpu) {
     // close previous codec
     if(myCodec != NULL) {
-        avcodec_close(myCodecCtx);
+        myCodec = NULL;
         fillCodecInfo(NULL);
+    #ifdef ST_AV_NEWCODECPAR
+        avcodec_free_context(&myCodecCtx);
+        myCodecCtx = avcodec_alloc_context3(NULL);
+        if(avcodec_parameters_to_context(myCodecCtx, myStream->codecpar) < 0) {
+            signals.onError(stCString("Internal error: unable to copy codec parameters"));
+            return false;
+        }
+    #else
+        avcodec_close(myCodecCtx);
+    #endif
     }
-    myCodec = NULL;
+
+    myCodecCtx->opaque         = this;
+    myCodecCtx->get_format     = stGetFrameFormat;
+#if(LIBAVCODEC_VERSION_INT >= AV_VERSION_INT(55, 0, 0))
+    if(check720in1080()) {
+        myCodecCtx->flags2 |= AV_CODEC_FLAG2_IGNORE_CROP;
+    }
+    myCodecCtx->get_buffer2    = stGetFrameBuffer2;
+#else
+    myCodecCtx->get_buffer     = stGetFrameBuffer1;
+    myCodecCtx->release_buffer = stReleaseFrameBuffer;
+#endif
 
     // configure the codec
     myCodecCtx->codec_id = theCodec->id;
@@ -268,7 +303,10 @@
     av_dict_set(&anOpts, "refcounted_frames", "1", 0);
 #endif
 
-    int aNbThreads = theToUseGpu ? 1 : StThread::countLogicalProcessors();
+    // attached pics are sparse, therefore we would not want to delay their decoding till EOF
+    int aNbThreads = theToUseGpu || isAttachedPicture()
+                   ? 1
+                   : StThread::countLogicalProcessors();
     myCodecCtx->thread_count = aNbThreads;
 #if(LIBAVCODEC_VERSION_INT < AV_VERSION_INT(52, 112, 0))
     avcodec_thread_init(myCodecCtx, aNbThreads);
@@ -293,71 +331,48 @@
                         const unsigned int theStreamId,
                         const StString&    theFileName,
                         const StHandle<StStereoParams>& theNewParams) {
-    if(!StAVPacketQueue::init(theFormatCtx, theStreamId, theFileName)
-    || myCodecCtx->codec_type != AVMEDIA_TYPE_VIDEO) {
+    if(!StAVPacketQueue::init(theFormatCtx, theStreamId, theFileName)) {
         signals.onError(stCString("FFmpeg: invalid stream"));
         deinit();
         return false;
     }
 
-    // detect 720in1080 streams with cropping information
-    const bool is720in1080 = (sizeX() == 1280) && (sizeY() == 720)
-                          && (getCodedSizeX() == 1920)
-                          && (getCodedSizeY() == 1080 || getCodedSizeY() == 1088);
-#if(LIBAVCODEC_VERSION_INT >= AV_VERSION_INT(55, 0, 0))
-    if(is720in1080) {
-        myCodecCtx->flags2 |= CODEC_FLAG2_IGNORE_CROP;
-    }
-#endif
-
-    // find the decoder for the video stream
-    myCodecCtx->opaque         = this;
-    myCodecCtx->get_format     = stGetFrameFormat;
-#if(LIBAVCODEC_VERSION_INT >= AV_VERSION_INT(55, 0, 0))
-    myCodecCtx->get_buffer2    = stGetFrameBuffer2;
-#else
-    myCodecCtx->get_buffer     = stGetFrameBuffer1;
-    myCodecCtx->release_buffer = stReleaseFrameBuffer;
-#endif
-
-    myCodecAuto = avcodec_find_decoder(myCodecCtx->codec_id);
-    if(myCodecAuto == NULL) {
-        signals.onError(stCString("FFmpeg: Video codec not found"));
-        deinit();
-        return false;
-    }
-
 #if defined(_WIN32)
-    myIsGpuFailed = myCodecCtx->codec_id != CodecIdMPEG2
-                 && myCodecCtx->codec_id != CodecIdH264
-                 && myCodecCtx->codec_id != CodecIdVC1
-                 && myCodecCtx->codec_id != CodecIdWMV3
-                 && myCodecCtx->codec_id != CodecIdVC1
-                 && myCodecCtx->codec_id != CodecIdHEVC;
+    myIsGpuFailed = myCodecAutoId != CodecIdMPEG2
+                 && myCodecAutoId != CodecIdH264
+                 && myCodecAutoId != CodecIdVC1
+                 && myCodecAutoId != CodecIdWMV3
+                 && myCodecAutoId != CodecIdHEVC;
+#elif defined(__APPLE__)
+    myIsGpuFailed = myCodecAutoId != CodecIdMPEG2
+                 && myCodecAutoId != CodecIdH264
+                 && myCodecAutoId != CodecIdHEVC;
 #endif
 
     bool isCodecOverridden = false;
     if(myUseOpenJpeg
-    && myCodecCtx->codec_id == CodecIdJpeg2K
+    && myCodecAutoId == CodecIdJpeg2K
     && myCodecOpenJpeg != NULL) {
         isCodecOverridden = initCodec(myCodecOpenJpeg, false);
     }
 
     // open VIDEO codec
-#if defined(__APPLE__) || defined(__ANDROID__)
+#if defined(__ANDROID__)
     AVCodec* aCodecGpu = NULL;
     if(myUseGpu
-    && StString(myCodecAuto->name).isEquals(stCString("h264"))
     && myCodecCtx->pix_fmt == stAV::PIX_FMT::YUV420P) {
-        aCodecGpu = myCodecH264HW;
+        const StString anAutoCodecName(myCodecAuto->name);
+        if(anAutoCodecName.isEquals(stCString("h264"))) {
+            aCodecGpu = myCodecH264HW;
+        } else if(anAutoCodecName.isEquals(stCString("hevc"))) {
+            aCodecGpu = myCodecHevcHW;
+        } else if(anAutoCodecName.isEquals(stCString("vp9"))) {
+            aCodecGpu = myCodecVp9HW;
+        }
     }
 
     if(aCodecGpu != NULL) {
-        myCodecCtx->get_format = stGetFormatYUV420P;
         isCodecOverridden = initCodec(aCodecGpu, true);
-        if(!isCodecOverridden) {
-            myCodecCtx->get_format = myGetFrmtInit;
-        }
     }
     if(!isCodecOverridden && !initCodec(myCodecAuto, false)) {
         signals.onError(stCString("FFmpeg: Could not open video codec"));
@@ -383,7 +398,7 @@
     myFrame.reset();
 
     // compute PAR
-    if(myStream->sample_aspect_ratio.num && av_cmp_q(myStream->sample_aspect_ratio, myStream->codec->sample_aspect_ratio)) {
+    if(myStream->sample_aspect_ratio.num && av_cmp_q(myStream->sample_aspect_ratio, myCodecCtx->sample_aspect_ratio)) {
         myPixelRatio = GLfloat(myStream->sample_aspect_ratio.num) / GLfloat(myStream->sample_aspect_ratio.den);
     } else {
         if(myCodecCtx->sample_aspect_ratio.num == 0 ||
@@ -422,6 +437,10 @@
         switch(aSpherical->projection) {
             case AV_SPHERICAL_EQUIRECTANGULAR: {
                 theNewParams->ViewingMode = StViewSurface_Sphere;
+                if(sizeX() == sizeY()) {
+                    // TODO - hemisphere information should be somewhere in the file
+                    //theNewParams->ViewingMode = StViewSurface_Hemisphere;
+                }
                 break;
             }
             case AV_SPHERICAL_CUBEMAP: {
@@ -429,6 +448,7 @@
                 //spherical->padding
                 break;
             }
+            //case AV_SPHERICAL_MESH: { theNewParams->ViewingMode = StViewSurface_CubemapEAC; break; }
             case AV_SPHERICAL_EQUIRECTANGULAR_TILE: {
                 // unsupported
                 //av_spherical_tile_bounds(aSpherical, par->width, par->height, &l, &t, &r, &b);
@@ -461,7 +481,7 @@
 #endif
 
     // stereoscopic mode tags
-    myStFormatInStream = is720in1080 ? StFormat_Tiled4x : StFormat_AUTO;
+    myStFormatInStream = check720in1080() ? StFormat_Tiled4x : StFormat_AUTO;
     if(stAV::meta::readTag(myFormatCtx, THE_SRC_MODE_KEY,     aValue)
     || stAV::meta::readTag(myStream,    THE_SRC_MODE_KEY,     aValue)
     || stAV::meta::readTag(myFormatCtx, THE_SRC_MODE_KEY_WMV, aValue)) {
@@ -479,7 +499,7 @@
 
     // detect information from file name
     bool isAnamorphByName = false;
-    myStFormatByName = st::formatFromName(myFileName, isAnamorphByName);
+    myStFormatByName = st::formatFromName(myFileName, myToSwapJps, isAnamorphByName);
     if(myStFormatInStream == StFormat_AUTO
     && isAnamorphByName) {
         if(myStFormatByName == StFormat_SideBySide_LR
@@ -512,17 +532,16 @@
     myFramesCounter = 1;
     myCachedFrame.nullify();
 
-    if(myCodecCtx  != NULL
-    && myCodecAuto != NULL) {
-        myCodecCtx->codec_id = myCodecAuto->id;
-    }
+#if !defined(ST_AV_NEWCODECPAR)
+    if(myCodecCtx != NULL) { myCodecCtx->codec_id = myCodecAutoId; }
+#endif
     StAVPacketQueue::deinit();
+    if(!myHWAccelCtx.isNull()) {
+        myHWAccelCtx->decoderDestroy(myCodecCtx);
+    }
     if(myCodecCtx != NULL) {
         myCodecCtx->hwaccel_context = NULL;
     }
-    if(!myHWAccelCtx.isNull()) {
-        myHWAccelCtx->decoderDestroy();
-    }
 }
 
 #ifdef ST_AV_OLDSYNC
@@ -551,20 +570,33 @@
     stAV::dimYUV  aDimsYUV;
     myFrame.getImageInfo(myCodecCtx, aFrameSizeX, aFrameSizeY, aPixFmt);
     myDataAdp.setBufferCounter(NULL);
-    if(aPixFmt == stAV::PIX_FMT::XYZ12) {
+    if(aPixFmt == stAV::PIX_FMT::XYZ12
+    && myTextureQueue->getDeviceCaps().isSupportedFormat(StImagePlane::ImgRGB48)) {
         myDataAdp.setColorModel(StImage::ImgColor_XYZ);
         myDataAdp.setColorScale(StImage::ImgScale_Full);
         myDataAdp.setPixelRatio(getPixelRatio());
         myDataAdp.changePlane(0).initWrapper(StImagePlane::ImgRGB48, myFrame.getPlane(0),
                                              size_t(aFrameSizeX), size_t(aFrameSizeY),
                                              myFrame.getLineSize(0));
-    } else if(aPixFmt == stAV::PIX_FMT::RGB24) {
+        return;
+    } else if(aPixFmt == stAV::PIX_FMT::RGB24
+           && myTextureQueue->getDeviceCaps().isSupportedFormat(StImagePlane::ImgRGB)) {
         myDataAdp.setColorModel(StImage::ImgColor_RGB);
         myDataAdp.setColorScale(StImage::ImgScale_Full);
         myDataAdp.setPixelRatio(getPixelRatio());
         myDataAdp.changePlane(0).initWrapper(StImagePlane::ImgRGB, myFrame.getPlane(0),
                                              size_t(aFrameSizeX), size_t(aFrameSizeY),
                                              myFrame.getLineSize(0));
+        return;
+    } else if(aPixFmt == stAV::PIX_FMT::RGBA32
+           && myTextureQueue->getDeviceCaps().isSupportedFormat(StImagePlane::ImgRGBA)) {
+        myDataAdp.setColorModel(StImage::ImgColor_RGBA);
+        myDataAdp.setColorScale(StImage::ImgScale_Full);
+        myDataAdp.setPixelRatio(getPixelRatio());
+        myDataAdp.changePlane(0).initWrapper(StImagePlane::ImgRGBA, myFrame.getPlane(0),
+                                             size_t(aFrameSizeX), size_t(aFrameSizeY),
+                                             myFrame.getLineSize(0));
+        return;
 #if(LIBAVCODEC_VERSION_INT >= AV_VERSION_INT(53, 5, 0))
     } else if(stAV::isFormatYUVPlanar(myFrame.Frame,
 #else
@@ -603,17 +635,25 @@
         } else if(aDimsYUV.bitsPerComp == 16) {
             aPlaneFrmt = StImagePlane::ImgGray16;
         }
-        myDataAdp.setColorModel(StImage::ImgColor_YUV);
-        myDataAdp.setPixelRatio(getPixelRatio());
-        myDataAdp.changePlane(0).initWrapper(aPlaneFrmt, myFrame.getPlane(0),
-                                             size_t(aDimsYUV.widthY), size_t(aDimsYUV.heightY), myFrame.getLineSize(0));
-        myDataAdp.changePlane(1).initWrapper(aPlaneFrmt, myFrame.getPlane(1),
-                                             size_t(aDimsYUV.widthU), size_t(aDimsYUV.heightU), myFrame.getLineSize(1));
-        myDataAdp.changePlane(2).initWrapper(aPlaneFrmt, myFrame.getPlane(2),
-                                             size_t(aDimsYUV.widthV), size_t(aDimsYUV.heightV), myFrame.getLineSize(2));
 
-        myFrameBufRef->moveReferenceFrom(myFrame.Frame);
-        myDataAdp.setBufferCounter(myFrameBufRef);
+        if(myTextureQueue->getDeviceCaps().isSupportedFormat(aPlaneFrmt)) {
+            myDataAdp.setColorModel(aDimsYUV.hasAlpha ? StImage::ImgColor_YUVA : StImage::ImgColor_YUV);
+            myDataAdp.setPixelRatio(getPixelRatio());
+            myDataAdp.changePlane(0).initWrapper(aPlaneFrmt, myFrame.getPlane(0),
+                                                 size_t(aDimsYUV.widthY), size_t(aDimsYUV.heightY), myFrame.getLineSize(0));
+            myDataAdp.changePlane(1).initWrapper(aPlaneFrmt, myFrame.getPlane(1),
+                                                 size_t(aDimsYUV.widthU), size_t(aDimsYUV.heightU), myFrame.getLineSize(1));
+            myDataAdp.changePlane(2).initWrapper(aPlaneFrmt, myFrame.getPlane(2),
+                                                 size_t(aDimsYUV.widthV), size_t(aDimsYUV.heightV), myFrame.getLineSize(2));
+            if(aDimsYUV.hasAlpha) {
+                myDataAdp.changePlane(3).initWrapper(aPlaneFrmt, myFrame.getPlane(3),
+                                                     size_t(aDimsYUV.widthY), size_t(aDimsYUV.heightY), myFrame.getLineSize(3));
+            }
+
+            myFrameBufRef->moveReferenceFrom(myFrame.Frame);
+            myDataAdp.setBufferCounter(myFrameBufRef);
+            return;
+        }
     } else if(aPixFmt == stAV::PIX_FMT::NV12) {
         aDimsYUV.isFullScale = false;
     #if(LIBAVCODEC_VERSION_INT >= AV_VERSION_INT(52, 29, 0))
@@ -632,7 +672,10 @@
 
         myFrameBufRef->moveReferenceFrom(myFrame.Frame);
         myDataAdp.setBufferCounter(myFrameBufRef);
-    } else if(!myToRgbIsBroken) {
+        return;
+    }
+
+    if(!myToRgbIsBroken) {
         if(myToRgbCtx    == NULL
         || myToRgbPixFmt != aPixFmt
         || size_t(aFrameSizeX) != myDataRGB.getSizeX()
@@ -656,16 +699,22 @@
                 signals.onError(stCString("FFmpeg: Failed to create SWScaler context"));
                 myToRgbIsBroken = true;
             } else {
-                // assign appropriate parts of RGB buffer to image planes in myFrameRGB
-                const size_t aBufferSize = avpicture_get_size(stAV::PIX_FMT::RGB24, aFrameSizeX, aFrameSizeY);
-                if(aBufferSize == 0
-                || !myDataRGB.initTrash(StImagePlane::ImgRGB, size_t(aFrameSizeX), size_t(aFrameSizeY),
-                                        aBufferSize / size_t(aFrameSizeY))) {
+                if(!myDataRGB.initTrash(StImagePlane::ImgRGB, size_t(aFrameSizeX), size_t(aFrameSizeY))) {
                     signals.onError(stCString("FFmpeg: Failed allocation of RGB frame (out of memory)"));
                     myToRgbIsBroken = true;
                 } else {
-                    avpicture_fill((AVPicture* )myFrameRGB.Frame, myDataRGB.changeData(), stAV::PIX_FMT::RGB24,
-                                   aFrameSizeX, aFrameSizeY);
+                    ST_DEBUG_LOG(" !!! Performance warning! Using SWScaler for " + stAV::PIX_FMT::getString(aPixFmt) + " pixel format.");
+                    {
+                        StMutexAuto aLock(myMutexInfo);
+                        myCodecStr += StString("\n[SWScaler] Software converter (from ") + stAV::PIX_FMT::getString(aPixFmt) + stCString(" into RGB)");
+                    }
+
+                    myFrameRGB.Frame->data[0]     = (uint8_t* )myDataRGB.changeData();
+                    myFrameRGB.Frame->linesize[0] = (int      )myDataRGB.getSizeRowBytes();
+                    for(int aPlaneIter = 1; aPlaneIter < AV_NUM_DATA_POINTERS; ++aPlaneIter) {
+                        myFrameRGB.Frame->data    [aPlaneIter] = NULL;
+                        myFrameRGB.Frame->linesize[aPlaneIter] = 0;
+                    }
                 }
             }
         }
@@ -722,9 +771,12 @@
         StPanorama aPano = st::probePanorama(theSrcFormat,
                                              theStParams->Src1SizeX, theStParams->Src1SizeY,
                                              theStParams->Src2SizeX, theStParams->Src2SizeY);
-        theStParams->ViewingMode = (aPano == StPanorama_Cubemap6_1 || aPano == StPanorama_Cubemap3_2)
-                                 ? StViewSurface_Cubemap
-                                 : StViewSurface_Sphere;
+        theStParams->ViewingMode = StStereoParams::getViewSurfaceForPanoramaSource(aPano, true);
+    }
+    if(myIsTheaterMode && theStParams->ViewingMode == StViewSurface_Plain) {
+        theStParams->ViewingMode = StViewSurface_Theater;
+    } else if(!myIsTheaterMode && theStParams->ViewingMode == StViewSurface_Theater) {
+        theStParams->ViewingMode = StViewSurface_Plain;
     }
 
     myTextureQueue->push(theSrcDataLeft, theSrcDataRight, theStParams, theSrcFormat, theCubemapFormat, theSrcPTS);
@@ -737,14 +789,10 @@
 }
 
 void StVideoQueue::decodeLoop() {
-    int isFrameFinished = 0;
     double anAverageDelaySec = 40.0;
     double aPrevPts  = 0.0;
-    double aSlavePts = 0.0;
     myFramePts = 0.0;
-    StImage* aSlaveData = NULL;
     StHandle<StAVPacket> aPacket;
-    StImage anEmptyImg;
     StString aTagValue;
     bool isStarted = false;
     for(;;) {
@@ -780,9 +828,25 @@
                 myVideoClock = 0.0;
                 myHasDataState.reset();
                 isStarted = true;
+                aPrevPts = 0.0;
+                myWasFlushed = true; // force displaying the first frame
+                continue;
+            }
+            case StAVPacket::DATA_PACKET: {
+                break;
+            }
+            case StAVPacket::LAST_PACKET: {
+            #if(LIBAVCODEC_VERSION_INT >= AV_VERSION_INT(57, 106, 102))
+                break; // redirect NULL packet to avcodec_send_packet()break;
+            #else
                 continue;
+            #endif
             }
             case StAVPacket::END_PACKET: {
+                // TODO at the end of the stream it might be needed calling
+                // avcodec_send_packet with NULL to initiate draining data followed by avcodec_receive_frame
+                // to recieve last frames.
+
                 if(!myMaster.isNull()) {
                     while(myHasDataState.check() && !myMaster->isInDowntime()) {
                         StThread::sleep(10);
@@ -815,233 +879,295 @@
             //
         }
 
-        // decode video frame
-    #if(LIBAVCODEC_VERSION_INT >= AV_VERSION_INT(52, 23, 0))
-        bool toTryGpu  = myUseGpu && !myIsGpuFailed;
-        avcodec_decode_video2(myCodecCtx, myFrame.Frame, &isFrameFinished, aPacket->getAVpkt());
-        bool isGpuUsed = myUseGpu && !myIsGpuFailed;
-        if(isGpuUsed != toTryGpu) {
-            if(!initCodec(myCodecAuto, isGpuUsed)) {
-                signals.onError(stCString("FFmpeg: Could not re-open video codec"));
-                deinit();
-                aPacket.nullify();
-                continue;
+        bool toSendPacket = true;
+        for(;;) {
+            if(!decodeFrame(aPacket, toSendPacket, isStarted, aTagValue, anAverageDelaySec, aPrevPts)) {
+                break;
             }
-            isFrameFinished = 0;
-            avcodec_decode_video2(myCodecCtx, myFrame.Frame, &isFrameFinished, aPacket->getAVpkt());
         }
-    #else
-        avcodec_decode_video(myCodecCtx, myFrame.Frame, &isFrameFinished,
-                             aPacket->getData(), aPacket->getSize());
-    #endif
-        if(isFrameFinished == 0) {
-            // need more packets to decode whole frame
-            aPacket.nullify();
-            continue;
+        aPacket.nullify();
+    }
+}
+
+bool StVideoQueue::decodeFrame(const StHandle<StAVPacket>& thePacket,
+                               bool& theToSendPacket,
+                               bool& theIsStarted,
+                               StString& theTagValue,
+                               double& theAverageDelaySec,
+                               double& thePrevPts) {
+    bool toTryMoreFrames = false;
+    (void )theToSendPacket;
+    const bool toTryGpu = myUseGpu && !myIsGpuFailed;
+#if(LIBAVCODEC_VERSION_INT >= AV_VERSION_INT(57, 106, 102))
+    if(theToSendPacket) {
+        theToSendPacket = false;
+        const int aRes = avcodec_send_packet(myCodecCtx, thePacket->getType() == StAVPacket::DATA_PACKET ? thePacket->getAVpkt() : NULL);
+        if(aRes == AVERROR(EAGAIN)) {
+            // special case used by some hardware decoders - new packet cannot be sent until decoded frame is retrieved
+            theToSendPacket = true;
+        } else if(aRes < 0 && aRes != AVERROR_EOF) {
+            return false;
         }
+    }
 
-        if(aPacket->isKeyFrame()) {
-            myFramesCounter = 1;
+    const int aRes2 = avcodec_receive_frame(myCodecCtx, myFrame.Frame);
+    const bool isGpuUsed = myUseGpu && !myIsGpuFailed;
+    if(isGpuUsed != toTryGpu) {
+        if(!initCodec(myCodecAuto, isGpuUsed)) {
+            signals.onError(stCString("FFmpeg: Could not re-open video codec"));
+            deinit();
+            return false;
         }
+        theToSendPacket = true;
+        return true;
+    }
 
-    #ifndef ST_AV_OLDSYNC
-        myVideoPktPts = av_frame_get_best_effort_timestamp(myFrame.Frame);
-        if(myVideoPktPts == stAV::NOPTS_VALUE) {
-            myVideoPktPts = 0;
+    if(aRes2 < 0) {
+        // polling - if packet was not sent and new frame is not yet ready, we need to try again and again...
+        if(theToSendPacket) {
+            StThread::sleep(10);
+        }
+        return theToSendPacket;
+    }
+    toTryMoreFrames = true;
+#elif(LIBAVCODEC_VERSION_INT >= AV_VERSION_INT(52, 23, 0))
+    int isFrameFinished = 0;
+    avcodec_decode_video2(myCodecCtx, myFrame.Frame, &isFrameFinished, thePacket->getAVpkt());
+    const bool isGpuUsed = myUseGpu && !myIsGpuFailed;
+    if(isGpuUsed != toTryGpu) {
+        if(!initCodec(myCodecAuto, isGpuUsed)) {
+            signals.onError(stCString("FFmpeg: Could not re-open video codec"));
+            deinit();
+            return false;
         }
+        return true;
+    }
+    if(isFrameFinished == 0) {
+        // need more packets to decode whole frame
+        return false;
+    }
+#else
+    int isFrameFinished = 0;
+    avcodec_decode_video(myCodecCtx, myFrame.Frame, &isFrameFinished,
+                         thePacket->getData(), thePacket->getSize());
+    if(isFrameFinished == 0) {
+        // need more packets to decode whole frame
+        return false;
+    }
+#endif
+    if(thePacket->isKeyFrame()) { // !theToSentPacket?
+        myFramesCounter = 1;
+    }
 
-        myFramePts  = double(myVideoPktPts) * av_q2d(myStream->time_base);
-        myFramePts -= myPtsStartBase; // normalize PTS
-    #else
-        // Save global pts to be stored in pFrame in first call
-        myVideoPktPts = aPacket->getPts();
+#ifndef ST_AV_OLDSYNC
+    myVideoPktPts = myFrame.getBestEffortTimestamp();
+    if(myVideoPktPts == stAV::NOPTS_VALUE) {
+        // TODO why best_effort_timestamp is invalid in case of h264_mediacodec?
+        myVideoPktPts = myFrame.Frame->pts;
+    }
+    if(myVideoPktPts == stAV::NOPTS_VALUE) {
+        myVideoPktPts = 0;
+    }
 
-        myFramePts = 0.0;
-        if(aPacket->getDts() != stAV::NOPTS_VALUE) {
-            myFramePts = double(aPacket->getDts());
-        } else {
-            int64_t aPktPtsSync = stAV::NOPTS_VALUE;
-        #ifdef ST_USE64PTR
-            aPktPtsSync = (int64_t )myFrame.Frame->opaque;
-        #else
-            AVFrameSideData* aSideDataSync = av_frame_get_side_data(myFrame.Frame, (AVFrameSideDataType )1000);
-            if(aSideDataSync != NULL) {
-                memcpy(&aPktPtsSync, &aSideDataSync->data, sizeof(myVideoPktPts));
-            }
-        #endif
-            if(aPktPtsSync != stAV::NOPTS_VALUE) {
-                myFramePts = double(aPktPtsSync);
-            }
-        }
-        myFramePts *= av_q2d(myStream->time_base);
-        myFramePts -= myPtsStartBase; // normalize PTS
+    myFramePts  = double(myVideoPktPts) * av_q2d(myStream->time_base);
+    myFramePts -= myPtsStartBase; // normalize PTS
+#else
+    // Save global pts to be stored in pFrame in first call
+    myVideoPktPts = thePacket->getPts();
 
-        syncVideo(myFrame.Frame, &myFramePts);
+    myFramePts = 0.0;
+    if(thePacket->getDts() != stAV::NOPTS_VALUE) {
+        myFramePts = double(thePacket->getDts());
+    } else {
+        int64_t aPktPtsSync = stAV::NOPTS_VALUE;
+    #ifdef ST_USE64PTR
+        aPktPtsSync = (int64_t )myFrame.Frame->opaque;
+    #else
+        AVFrameSideData* aSideDataSync = av_frame_get_side_data(myFrame.Frame, (AVFrameSideDataType )1000);
+        if(aSideDataSync != NULL) {
+            memcpy(&aPktPtsSync, &aSideDataSync->data, sizeof(myVideoPktPts));
+        }
     #endif
-
-        const double aDelay = myFramePts - aPrevPts;
-        if(aDelay > 0.0 && aDelay < 1.0) {
-            anAverageDelaySec = aDelay;
+        if(aPktPtsSync != stAV::NOPTS_VALUE) {
+            myFramePts = double(aPktPtsSync);
         }
-        aPrevPts = myFramePts;
-
-        // do we need to skip frames or not
-        static const double OVERR_LIMIT = 0.2;
-        static const double GREATER_LIMIT = 100.0;
-        if(myMaster.isNull()) {
-            const double anAudioClock = getAClock() + double(myAudioDelayMSec) * 0.001;
-            double diff = anAudioClock - myFramePts;
-            if(diff > OVERR_LIMIT && diff < GREATER_LIMIT) {
-                if(myAvDiscard != AVDISCARD_NONREF) {
-                    ST_DEBUG_LOG("skip frames: AVDISCARD_NONREF (on)"
-                        + " (aClock " + anAudioClock
-                        + " vClock " + myFramePts
-                        + " diff " + diff + ")"
-                    );
-                    myAvDiscard = AVDISCARD_NONREF;
-                    ///myCodecCtx->skip_frame = AVDISCARD_NONKEY;
-                    myCodecCtx->skip_frame = myAvDiscard;
-                    if(!mySlave.isNull()) {
-                        mySlave->myCodecCtx->skip_frame = myAvDiscard;
-                    }
+    }
+    myFramePts *= av_q2d(myStream->time_base);
+    myFramePts -= myPtsStartBase; // normalize PTS
+
+    syncVideo(myFrame.Frame, &myFramePts);
+#endif
+
+    const double aDelay = myFramePts - thePrevPts;
+    if(aDelay > 0.0 && aDelay < 1.0) {
+        theAverageDelaySec = aDelay;
+    }
+    thePrevPts = myFramePts;
+
+    // do we need to skip frames or not
+    static const double OVERR_LIMIT = 0.2;
+    static const double GREATER_LIMIT = 100.0;
+    if(myMaster.isNull()) {
+        const double anAudioClock = getAClock() + double(myAudioDelayMSec) * 0.001;
+        double diff = anAudioClock - myFramePts;
+        if(diff > OVERR_LIMIT && diff < GREATER_LIMIT) {
+            if(myAvDiscard != AVDISCARD_NONREF) {
+                ST_DEBUG_LOG("skip frames: AVDISCARD_NONREF (on)"
+                    + " (aClock " + anAudioClock
+                    + " vClock " + myFramePts
+                    + " diff " + diff + ")"
+                );
+                myAvDiscard = AVDISCARD_NONREF;
+                ///myCodecCtx->skip_frame = AVDISCARD_NONKEY;
+                myCodecCtx->skip_frame = myAvDiscard;
+                if(!mySlave.isNull()) {
+                    mySlave->myCodecCtx->skip_frame = myAvDiscard;
                 }
-            } else {
-                if(myAvDiscard != AVDISCARD_DEFAULT) {
-                    ST_DEBUG_LOG("skip frames: AVDISCARD_DEFAULT (off)");
-                    myAvDiscard = AVDISCARD_DEFAULT;
-                    myCodecCtx->skip_frame = myAvDiscard;
-                    if(!mySlave.isNull()) {
-                        mySlave->myCodecCtx->skip_frame = myAvDiscard;
-                    }
+            }
+        } else {
+            if(myAvDiscard != AVDISCARD_DEFAULT) {
+                ST_DEBUG_LOG("skip frames: AVDISCARD_DEFAULT (off)");
+                myAvDiscard = AVDISCARD_DEFAULT;
+                myCodecCtx->skip_frame = myAvDiscard;
+                if(!mySlave.isNull()) {
+                    mySlave->myCodecCtx->skip_frame = myAvDiscard;
                 }
             }
         }
+    }
 
-        // copy frame back from GPU to CPU memory
-        if(!myHWAccelCtx.isNull()) {
-            myHWAccelCtx->retrieveFrame(*this, myFrame.Frame);
-        }
+    // copy frame back from GPU to CPU memory
+    if(!myHWAccelCtx.isNull()) {
+        myHWAccelCtx->retrieveFrame(*this, myFrame.Frame);
+    }
 
-        // we currently allow to override source format stored in metadata
-    #ifdef ST_AV_NEWSTEREO
-        if(AVFrameSideData* aSideDataS3d = av_frame_get_side_data(myFrame.Frame, AV_FRAME_DATA_STEREO3D)) {
-            AVStereo3D* aStereo = (AVStereo3D* )aSideDataS3d->data;
-            myStFormatInStream = stAV::stereo3dAvToSt(aStereo->type);
-            if(aStereo->flags & AV_STEREO3D_FLAG_INVERT) {
-                myStFormatInStream = st::formatReversed(myStFormatInStream);
-            }
+    // we currently allow to override source format stored in metadata
+#ifdef ST_AV_NEWSTEREO
+    if(AVFrameSideData* aSideDataS3d = av_frame_get_side_data(myFrame.Frame, AV_FRAME_DATA_STEREO3D)) {
+        AVStereo3D* aStereo = (AVStereo3D* )aSideDataS3d->data;
+        myStFormatInStream = stAV::stereo3dAvToSt(aStereo->type);
+        if(aStereo->flags & AV_STEREO3D_FLAG_INVERT) {
+            myStFormatInStream = st::formatReversed(myStFormatInStream);
         }
-    #endif
-    #if(LIBAVUTIL_VERSION_INT >= AV_VERSION_INT(55, 0, 0))
-        if(const AVFrameSideData* aSideDataRot = av_frame_get_side_data(myFrame.Frame, AV_FRAME_DATA_DISPLAYMATRIX)) {
-            if(aSideDataRot->size >= int(9 * sizeof(int32_t))) {
-                const double aRotDeg = -av_display_rotation_get((const int32_t* )aSideDataRot->data);
-                if(!st::isNaN(aRotDeg)) {
-                    myRotateDeg = -int(aRotDeg - 360 * std::floor(aRotDeg / 360 + 0.9 / 360));
-                }
+    }
+#endif
+#if(LIBAVUTIL_VERSION_INT >= AV_VERSION_INT(55, 0, 0))
+    if(const AVFrameSideData* aSideDataRot = av_frame_get_side_data(myFrame.Frame, AV_FRAME_DATA_DISPLAYMATRIX)) {
+        if(aSideDataRot->size >= int(9 * sizeof(int32_t))) {
+            const double aRotDeg = -av_display_rotation_get((const int32_t* )aSideDataRot->data);
+            if(!st::isNaN(aRotDeg)) {
+                myRotateDeg = -int(aRotDeg - 360 * std::floor(aRotDeg / 360 + 0.9 / 360));
             }
         }
-    #endif
-        if(stAV::meta::readTag(myFrame.Frame, THE_SRC_MODE_KEY, aTagValue)) {
-            for(size_t aSrcId = 0;; ++aSrcId) {
-                const StFFmpegStereoFormat& aFlag = STEREOFLAGS[aSrcId];
-                if(aFlag.stID == StFormat_AUTO || aFlag.name == NULL) {
-                    break;
-                } else if(aTagValue == aFlag.name) {
-                    myStFormatInStream = aFlag.stID;
-                    //ST_DEBUG_LOG("  read srcFormat from tags= " + myStFormatInStream);
-                    break;
-                }
+    }
+#endif
+    if(stAV::meta::readTag(myFrame.Frame, THE_SRC_MODE_KEY, theTagValue)) {
+        for(size_t aSrcId = 0;; ++aSrcId) {
+            const StFFmpegStereoFormat& aFlag = STEREOFLAGS[aSrcId];
+            if(aFlag.stID == StFormat_AUTO || aFlag.name == NULL) {
+                break;
+            } else if(theTagValue == aFlag.name) {
+                myStFormatInStream = aFlag.stID;
+                //ST_DEBUG_LOG("  read srcFormat from tags= " + myStFormatInStream);
+                break;
             }
         }
-        // override source format stored in metadata
-        StFormat  aSrcFormat     = myStFormatByUser;
-        StCubemap aCubemapFormat = aPacket->getSource()->ViewingMode == StViewSurface_Cubemap ? StCubemap_Packed : StCubemap_OFF;
-        if(aSrcFormat == StFormat_AUTO) {
-            // prefer info stored in the stream itself
-            aSrcFormat = myStFormatInStream;
-        }
-        if(aSrcFormat == StFormat_AUTO) {
-            // try using format detected from file name
-            aSrcFormat = myStFormatByName;
-        }
-        /*if(aSrcFormat == StFormat_AUTO
-        && sizeY() != 0) {
-            // try detection based on aspect ratio
-            aSrcFormat = st::formatFromRatio(GLfloat(sizeX()) / GLfloat(sizeY()));
-        }*/
-
-        prepareFrame(aSrcFormat);
+    }
+    // override source format stored in metadata
+    StFormat  aSrcFormat     = myStFormatByUser;
+    StCubemap aCubemapFormat = StCubemap_OFF;
+    if(thePacket->getSource()->ViewingMode == StViewSurface_Cubemap) {
+        aCubemapFormat = StCubemap_Packed;
+    } else if(thePacket->getSource()->ViewingMode == StViewSurface_CubemapEAC) {
+        aCubemapFormat = StCubemap_PackedEAC;
+    }
 
-        if(!mySlave.isNull()) {
-            if(isStarted) {
-                StHandle<StStereoParams> aParams = aPacket->getSource();
-                if(!aParams.isNull()) {
-                    aParams->setSeparationNeutral(myHParallax);
-                    aParams->setZRotateZero((float )myRotateDeg);
-                }
-                isStarted = false;
+    if(aSrcFormat == StFormat_AUTO) {
+        // prefer info stored in the stream itself
+        aSrcFormat = myStFormatInStream;
+    }
+    if(aSrcFormat == StFormat_AUTO) {
+        // try using format detected from file name
+        aSrcFormat = myStFormatByName;
+    }
+    /*if(aSrcFormat == StFormat_AUTO
+    && sizeY() != 0) {
+        // try detection based on aspect ratio
+        aSrcFormat = st::formatFromRatio(GLfloat(sizeX()) / GLfloat(sizeY()));
+    }*/
+
+    prepareFrame(aSrcFormat);
+
+    if(!mySlave.isNull()) {
+        if(theIsStarted) {
+            StHandle<StStereoParams> aParams = thePacket->getSource();
+            if(!aParams.isNull()) {
+                aParams->setSeparationNeutral(myHParallax);
+                aParams->setZRotateZero((float )myRotateDeg);
             }
+            theIsStarted = false;
+        }
 
-            for(;;) {
-                // wait data from Slave
-                if(aSlaveData == NULL) {
-                    aSlaveData = mySlave->waitData(aSlavePts);
-                }
-                if(aSlaveData != NULL) {
-                    const double aPtsDiff = myFramePts - aSlavePts;
-                    if(aPtsDiff > 0.5 * anAverageDelaySec) {
-                        // wait for more recent frame from slave thread
+        StImage* aSlaveData = NULL;
+        double aSlavePts = 0.0;
+        for(;;) {
+            // wait data from Slave
+            if(aSlaveData == NULL) {
+                aSlaveData = mySlave->waitData(aSlavePts);
+            }
+            if(aSlaveData != NULL) {
+                const double aPtsDiff = myFramePts - aSlavePts;
+                if(aPtsDiff > 0.5 * theAverageDelaySec) {
+                    // wait for more recent frame from slave thread
+                    mySlave->unlockData();
+                    aSlaveData = NULL;
+                    StThread::sleep(10);
+                    continue;
+                } else if(aPtsDiff < -0.5 * theAverageDelaySec) {
+                    // too far...
+                    if(aPtsDiff < -6.0) {
+                        // result of seeking?
                         mySlave->unlockData();
                         aSlaveData = NULL;
-                        StThread::sleep(10);
-                        continue;
-                    } else if(aPtsDiff < -0.5 * anAverageDelaySec) {
-                        // too far...
-                        if(aPtsDiff < -6.0) {
-                            // result of seeking?
-                            mySlave->unlockData();
-                            aSlaveData = NULL;
-                        }
-                        break;
                     }
+                    break;
+                }
 
-                    pushFrame(myDataAdp, *aSlaveData, aPacket->getSource(), StFormat_SeparateFrames, aCubemapFormat, myFramePts);
+                pushFrame(myDataAdp, *aSlaveData, thePacket->getSource(), StFormat_SeparateFrames, aCubemapFormat, myFramePts);
 
-                    aSlaveData = NULL;
-                    mySlave->unlockData();
-                } else {
-                    pushFrame(myDataAdp, anEmptyImg, aPacket->getSource(), aSrcFormat, aCubemapFormat, myFramePts);
-                }
-                break;
+                aSlaveData = NULL;
+                mySlave->unlockData();
+            } else {
+                pushFrame(myDataAdp, myEmptyImage, thePacket->getSource(), aSrcFormat, aCubemapFormat, myFramePts);
             }
-        } else if(!myMaster.isNull()) {
-            // push data to Master
-            myHasDataState.set();
-        } else {
-            if(isStarted) {
-                StHandle<StStereoParams> aParams = aPacket->getSource();
-                if(!aParams.isNull()) {
-                    aParams->setSeparationNeutral(myHParallax);
-                    aParams->setZRotateZero((float )myRotateDeg);
-                }
-                isStarted = false;
+            break;
+        }
+    } else if(!myMaster.isNull()) {
+        // push data to Master
+        myHasDataState.set();
+    } else {
+        if(theIsStarted) {
+            StHandle<StStereoParams> aParams = thePacket->getSource();
+            if(!aParams.isNull()) {
+                aParams->setSeparationNeutral(myHParallax);
+                aParams->setZRotateZero((float )myRotateDeg);
             }
+            theIsStarted = false;
+        }
 
-            // simple one-stream case
-            if(aSrcFormat == StFormat_FrameSequence) {
-                if(isOddNumber(myFramesCounter)) {
-                    myCachedFrame.fill(myDataAdp, false);
-                } else {
-                    pushFrame(myCachedFrame, myDataAdp, aPacket->getSource(), StFormat_FrameSequence, aCubemapFormat, myFramePts);
-                }
-                ++myFramesCounter;
+        // simple one-stream case
+        if(aSrcFormat == StFormat_FrameSequence) {
+            if(isOddNumber(myFramesCounter)) {
+                myCachedFrame.fill(myDataAdp, false);
             } else {
-                pushFrame(myDataAdp, anEmptyImg, aPacket->getSource(), aSrcFormat, aCubemapFormat, myFramePts);
+                pushFrame(myCachedFrame, myDataAdp, thePacket->getSource(), StFormat_FrameSequence, aCubemapFormat, myFramePts);
             }
+            ++myFramesCounter;
+        } else {
+            pushFrame(myDataAdp, myEmptyImage, thePacket->getSource(), aSrcFormat, aCubemapFormat, myFramePts);
         }
-
-        myFrame.reset();
-        aPacket.nullify(); // and now packet finished
     }
+
+    myFrame.reset();
+    return toTryMoreFrames;
 }

sview-17_04.tar.gz/StMoviePlayer/StVideo/StVideoQueue.h -> sview-20_08.tar.gz/StMoviePlayer/StVideo/StVideoQueue.h Changed

@@ -1,5 +1,5 @@
 /**
- * Copyright © 2009-2017 Kirill Gavrilov <kirill@sview.ru>
+ * Copyright © 2009-2019 Kirill Gavrilov <kirill@sview.ru>
  *
  * StMoviePlayer program is free software: you can redistribute it and/or modify
  * it under the terms of the GNU General Public License as published by
@@ -59,7 +59,7 @@
     /**
      * Release decoder.
      */
-    virtual void decoderDestroy() = 0;
+    virtual void decoderDestroy(AVCodecContext* theCodecCtx) = 0;
 
     /**
      * AVFrame initialization callback.
@@ -198,17 +198,34 @@
     }
 
     /**
+     * Set theater mode.
+     */
+    ST_LOCAL void setTheaterMode(bool theIsTheater) {
+        myIsTheaterMode = theIsTheater;
+    }
+
+    /**
      * Stick to panorama 360 mode.
      */
     ST_LOCAL void setStickPano360(bool theToStick) {
         myToStickPano360 = theToStick;
     }
 
+    /**
+     * Set if JPS file should be read as Left/Right (TRUE) of as Right/Left (FALSE).
+     */
+    ST_LOCAL void setSwapJPS(bool theToSwap) { myToSwapJps = theToSwap; }
+
     ST_LOCAL StVideoQueue(const StHandle<StGLTextureQueue>& theTextureQueue,
                           const StHandle<StVideoQueue>&     theMaster = StHandle<StVideoQueue>());
     ST_LOCAL virtual ~StVideoQueue();
 
     /**
+     * Return codec type.
+     */
+    ST_LOCAL virtual AVMediaType getCodecType() const ST_ATTR_OVERRIDE { return AVMEDIA_TYPE_VIDEO; }
+
+    /**
      * Initialization function.
      * @param theFormatCtx pointer to video format context
      * @param theStreamId  stream id in video format context
@@ -342,6 +359,22 @@
 private:
 
     /**
+     * Detect 720in1080 streams with cropping information
+     */
+    ST_LOCAL bool check720in1080() const {
+        return (sizeX() == 1280) && (sizeY() == 720)
+            && (getCodedSizeX() == 1920)
+            && (getCodedSizeY() == 1080 || getCodedSizeY() == 1088);
+    }
+
+    ST_LOCAL bool decodeFrame(const StHandle<StAVPacket>& thePacket,
+                              bool& theToSendPacket,
+                              bool& theIsStarted,
+                              StString& theTagValue,
+                              double& theAverageDelaySec,
+                              double& thePrevPts);
+
+    /**
      * Initialize adapter over AVframe or perform to RGB conversion.
      */
     ST_LOCAL void prepareFrame(const StFormat theSrcFormat);
@@ -364,8 +397,10 @@
     StHandle<StVideoQueue>     mySlave;           //!< handle to Slave  decoding thread
 
     StHandle<StHWAccelContext> myHWAccelCtx;
-#if defined(__APPLE__) || defined(__ANDROID__)
-    AVCodec*                   myCodecH264HW;     //!< h264 decoder using dedicated hardware (VDA codec on OS X; Android Media Codec)
+#if defined(__ANDROID__)
+    AVCodec*                   myCodecH264HW;     //!< h264 decoder using dedicated hardware (Android Media Codec)
+    AVCodec*                   myCodecHevcHW;     //!< hevc decoder using dedicated hardware
+    AVCodec*                   myCodecVp9HW;      //!< vp9  decoder using dedicated hardware
 #endif
     AVCodec*                   myCodecOpenJpeg;   //!< libopenjpeg decoder
     bool                       myUseGpu;          //!< activate decoding on GPU when possible
@@ -398,12 +433,15 @@
 
     int64_t                    myFramesCounter;
     StImage                    myCachedFrame;
+    StImage                    myEmptyImage;
     bool                       myWasFlushed;
 
     volatile StFormat          myStFormatByUser;  //!< source format specified by user
     volatile StFormat          myStFormatByName;  //!< source format detected from file name
     volatile StFormat          myStFormatInStream;//!< source format information retrieved from stream
+    volatile bool              myIsTheaterMode;   //!< flag indicating theater mode
     volatile bool              myToStickPano360;  //!< stick to panorama 360 mode
+    volatile bool              myToSwapJps;       //!< read JPS as Left/Right instead of Right/Left
 
 };

sview-17_04.tar.gz/StMoviePlayer/StVideo/StVideoTimer.cpp -> sview-20_08.tar.gz/StMoviePlayer/StVideo/StVideoTimer.cpp Changed

sview-20_08.tar.gz/StMoviePlayer/StVideo/StVideoToolbox.cpp Added

@@ -0,0 +1,248 @@
+/**
+ * Copyright © 2020 Kirill Gavrilov <kirill@sview.ru>
+ *
+ * StMoviePlayer 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.
+ *
+ * StMoviePlayer 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/>.
+ */
+
+#include "StVideoQueue.h"
+
+#if defined(__APPLE__)
+
+#include <StAV/StAVPacket.h>
+#include <StAV/StAVFrame.h>
+#include <StAV/StAVBufferPool.h>
+#include <StLibrary.h>
+
+#include <vector>
+
+#include <CoreServices/CoreServices.h>
+
+extern "C" {
+  #include <libavcodec/videotoolbox.h>
+  #include <libavutil/buffer.h>
+  #include <libavutil/imgutils.h>
+};
+
+/**
+ * VideoToolbox HWAccel context.
+ */
+class StVideoToolboxContext : public StHWAccelContext {
+
+        public:
+
+    /**
+     * Empty constructor.
+     */
+    StVideoToolboxContext()
+    : myFrameTmp(NULL),
+      myHasDevice(false){
+        //
+    }
+
+    /**
+     * Destructor.
+     */
+    virtual ~StVideoToolboxContext() {
+        release();
+    }
+
+    /**
+     * Release context.
+     */
+    void release();
+
+    /**
+     * Return true if VideoToolbox has been successfully initialized.
+     */
+    virtual bool isValid() const ST_ATTR_OVERRIDE { return myHasDevice; }
+
+    /**
+     * Create context.
+     */
+    virtual bool create(StVideoQueue& theVideo) ST_ATTR_OVERRIDE;
+
+    /**
+     * Destroy decoder.
+     */
+    virtual void decoderDestroy(AVCodecContext* theCodecCtx) ST_ATTR_OVERRIDE {
+        myPoolsTmp[0].release();
+        myPoolsTmp[1].release();
+        myPoolsTmp[2].release();
+        myPoolsTmp[3].release();
+        if(theCodecCtx != NULL && myHasDevice) {
+            av_videotoolbox_default_free(theCodecCtx);
+        }
+        myHasDevice = false;
+    }
+
+    /**
+     * Create decoder.
+     */
+    virtual bool decoderCreate(StVideoQueue&   theVideo,
+                               AVCodecContext* theCodecCtx) ST_ATTR_OVERRIDE {
+        const StSignal<void (const StCString& )>& onError = theVideo.signals.onError;
+        decoderDestroy(theCodecCtx);
+
+        const int anAvErr = av_videotoolbox_default_init(theCodecCtx);
+        if(anAvErr < 0) {
+            onError(stCString("StVideoQueue: Error creating Videotoolbox decoder"));
+            return false;
+        }
+        myHasDevice = true;
+        return true;
+    }
+
+    /**
+     * AVFrame initialization callback.
+     */
+    virtual int getFrameBuffer(StVideoQueue& ,
+                               AVFrame* ) ST_ATTR_OVERRIDE {
+        return -1; // method is unused
+    }
+
+    /**
+     * Fetch decoded results into specified frame.
+     */
+    virtual bool retrieveFrame(StVideoQueue& theVideo,
+                               AVFrame* theFrame) ST_ATTR_OVERRIDE;
+
+        private:
+
+    StAVBufferPool myPoolsTmp[4];
+    AVFrame*       myFrameTmp;
+    bool           myHasDevice;
+
+};
+
+void StVideoToolboxContext::release() {
+    decoderDestroy(NULL);
+    av_frame_free(&myFrameTmp);
+}
+
+bool StVideoToolboxContext::create(StVideoQueue& ) {
+    myFrameTmp = av_frame_alloc();
+    if(myFrameTmp == NULL) {
+        release();
+        return false;
+    }
+    return true;
+}
+
+bool StVideoToolboxContext::retrieveFrame(StVideoQueue& ,
+                                          AVFrame* theFrame) {
+    if(!isValid()
+     || theFrame->format != stAV::PIX_FMT::VIDEOTOOLBOX_VLD) {
+        return false;
+    }
+
+    av_frame_unref(myFrameTmp);
+
+    CVPixelBufferRef aPixBuf = (CVPixelBufferRef )theFrame->data[3];
+    const OSType aPixBufFormat = CVPixelBufferGetPixelFormatType(aPixBuf);
+    switch(aPixBufFormat) {
+        case kCVPixelFormatType_420YpCbCr8Planar: myFrameTmp->format = AV_PIX_FMT_YUV420P; break;
+        case kCVPixelFormatType_422YpCbCr8:       myFrameTmp->format = AV_PIX_FMT_UYVY422; break;
+        case kCVPixelFormatType_32BGRA:           myFrameTmp->format = AV_PIX_FMT_BGRA; break;
+        case kCVPixelFormatType_420YpCbCr8BiPlanarVideoRange:
+        case kCVPixelFormatType_420YpCbCr8BiPlanarFullRange: myFrameTmp->format = AV_PIX_FMT_NV12; break;
+        case kCVPixelFormatType_420YpCbCr10BiPlanarVideoRange:
+        case kCVPixelFormatType_420YpCbCr10BiPlanarFullRange: myFrameTmp->format = AV_PIX_FMT_P010; break;
+        default: {
+            ST_ERROR_LOG("StVideoToolboxContext: unsupported pixel format " + int(aPixBufFormat));
+            return false;
+        }
+    }
+
+    CVReturn err = CVPixelBufferLockBaseAddress(aPixBuf, kCVPixelBufferLock_ReadOnly);
+    if(err != kCVReturnSuccess) {
+        ST_ERROR_LOG("StVideoToolboxContext: Error locking the pixel buffer");
+        return false;
+    }
+
+    myFrameTmp->width  = theFrame->width;
+    myFrameTmp->height = theFrame->height;
+    size_t aDataSize[4] = { 0 };
+
+    uint8_t*   aData[4] = { 0 };
+    int    aLineSize[4] = { 0 };
+    const int aNbPlanes = CVPixelBufferIsPlanar(aPixBuf) ? CVPixelBufferGetPlaneCount(aPixBuf) : 1;
+    if(CVPixelBufferIsPlanar(aPixBuf)) {
+        for(int aPlaneIter = 0; aPlaneIter < aNbPlanes; ++aPlaneIter) {
+            aData[aPlaneIter] = (uint8_t* )CVPixelBufferGetBaseAddressOfPlane(aPixBuf, aPlaneIter);
+            aLineSize[aPlaneIter] = CVPixelBufferGetBytesPerRowOfPlane(aPixBuf, aPlaneIter);
+
+            const int aTmpStride = aLineSize[aPlaneIter]; //(int )getAligned(CVPixelBufferGetWidthOfPlane(aPixBuf, aPlaneIter) * bytesPerPixel, 32);
+            myFrameTmp->linesize[aPlaneIter] = aTmpStride;
+            aDataSize[aPlaneIter] = size_t(aTmpStride) * size_t(CVPixelBufferGetHeightOfPlane(aPixBuf, aPlaneIter));
+        }
+    } else {
+        aData[0] = (uint8_t* )CVPixelBufferGetBaseAddress(aPixBuf);
+        aLineSize[0] = CVPixelBufferGetBytesPerRow(aPixBuf);
+
+        const int aTmpStride = aLineSize[0]; //(int )getAligned(CVPixelBufferGetWidth(aPixBuf) * bytesPerPixel, 32);
+        myFrameTmp->linesize[0] = aTmpStride;
+        aDataSize[0] = size_t(aTmpStride) * size_t(CVPixelBufferGetHeight(aPixBuf));
+    }
+
+    for(int aPlaneIter = 0; aPlaneIter < aNbPlanes; ++aPlaneIter) {
+        myFrameTmp->buf[aPlaneIter] = myPoolsTmp[aPlaneIter].init(aDataSize[aPlaneIter]) ? myPoolsTmp[aPlaneIter].getBuffer() : NULL;
+        if(myFrameTmp->buf[aPlaneIter] == NULL) {
+            ST_ERROR_LOG("StVideoToolboxContext: unable to allocate frame buffers");
+            av_frame_unref(myFrameTmp);
+            CVPixelBufferUnlockBaseAddress(aPixBuf, kCVPixelBufferLock_ReadOnly);
+            return false;
+        }
+        myFrameTmp->data[aPlaneIter] = myFrameTmp->buf[aPlaneIter]->data;
+    }
+    //int anAvErrBuf = av_frame_get_buffer(myFrameTmp, 0);
+    //if(anAvErrBuf < 0) { return false; }
+
+    av_image_copy(myFrameTmp->data, myFrameTmp->linesize,
+                  (const uint8_t** )aData, aLineSize, (AVPixelFormat )myFrameTmp->format,
+                  theFrame->width, theFrame->height);
+
+    const int anAvErr = av_frame_copy_props(myFrameTmp, theFrame);
+    CVPixelBufferUnlockBaseAddress(aPixBuf, kCVPixelBufferLock_ReadOnly);
+    if(anAvErr < 0) {
+        ST_ERROR_LOG("StVideoToolboxContext: Error copying frame properties");
+        av_frame_unref(myFrameTmp);
+        return false;
+    }
+
+    av_frame_unref   (theFrame);
+    av_frame_move_ref(theFrame, myFrameTmp);
+    return true;
+}
+
+bool StVideoQueue::hwaccelInit() {
+    if(myCodecCtx->codec_id == AV_CODEC_ID_NONE) {
+        return false;
+    }
+
+    if(myHWAccelCtx.isNull()) {
+        myHWAccelCtx = new StVideoToolboxContext();
+        if(!myHWAccelCtx->create(*this)) {
+            return false;
+        }
+    }
+
+    if(!myHWAccelCtx->decoderCreate(*this, myCodecCtx)) {
+        return false;
+    }
+    fillCodecInfo(myCodecCtx->codec, " (VideoToolbox)");
+    return true;
+}
+
+#endif // __APPLE__

sview-17_04.tar.gz/StMoviePlayer/lang/chinese/StMoviePlayer.lng -> sview-20_08.tar.gz/StMoviePlayer/lang/chinese/StMoviePlayer.lng Changed

@@ -62,6 +62,7 @@
 1260=接近
 1261=线性
 1262=混纺交织
+?1263=Trilinear
 1270=重置默认
 1271=亮度
 1272=饱和度
@@ -70,10 +71,13 @@
 1281=球面
 1282=圆筒
 ?1283=Cubemap
+?1284=Hemisphere
 ?1285=Track orientation
 ?1286=Track orientation (poor)
 ?1287=Orient audio
 ?1288=Stick at panorama 360°
+?1293=Equiangular cubemap
+?1294=Theater
 1300=音频
 1301=无
 1302=音/视频 延迟
@@ -93,9 +97,11 @@
 ?1359=Bottom
 ?1360=Plain text
 ?1361=Lite HTML
+?1370=Apply stereo format
 1400=改变设备
 1401=关于插件…
 1402=FPS控制
+?1404=Exclusive Fullscreen mode
 1420=同时
 1421=显示表
 1422=减少CPU的使用
@@ -131,6 +137,7 @@
 ?1705=On one click windowed mode
 ?1710=Hide system navigation bar
 ?1711=Open last played file on startup
+?1712=Swap JPS/PNS views order
 2000=选择视频文件打开
 2001=选择左视频文件打开
 2002=选择右视频文件打开
@@ -139,6 +146,8 @@
 2005=文件删除
 2006=确定完全移除吗?
 2007=激活解码器:
+?2008=Choose audio file to attach
+?2009=Choose subtitles file to attach
 2010=选择保存快照位置
 2011=什么也没有保存!
 2012=快照不为空!
@@ -253,3 +262,4 @@
 ?6055=X Rotation - up
 ?6056=X Rotation - down
 ?6057=Enable/disable panorama mode
+?6058=Show/hide GUI

sview-17_04.tar.gz/StMoviePlayer/lang/czech/StMoviePlayer.lng -> sview-20_08.tar.gz/StMoviePlayer/lang/czech/StMoviePlayer.lng Changed

@@ -63,6 +63,7 @@
 1260=Nevyhlazovat
 1261=Lineární
 1262=Odstranit prokládání
+?1263=Trilinear
 1270=Resetovat nastavení
 1271=Jas
 1272=Sytost
@@ -71,10 +72,13 @@
 1281=Koule
 1282=Válec
 ?1283=Cubemap
+?1284=Hemisphere
 ?1285=Track orientation
 ?1286=Track orientation (poor)
 ?1287=Orient audio
 ?1288=Stick at panorama 360°
+?1293=Equiangular cubemap
+?1294=Theater
 1300=Zvuk
 1301=Vypnout zvuk
 1302=Zpoždění zvuku
@@ -94,9 +98,11 @@
 ?1359=Bottom
 1360=Plain text
 1361=Lite HTML
+?1370=Apply stereo format
 1400=Vybrat zařízení
 1401=O modulu…
 1402=FPS nastavení
+?1404=Exclusive Fullscreen mode
 1420=Vertikální synchronizace
 1421=Zobrazovat snímkování (fps)
 1422=Omezit využití CPU
@@ -132,6 +138,7 @@
 ?1705=On one click windowed mode
 ?1710=Hide system navigation bar
 ?1711=Open last played file on startup
+?1712=Swap JPS/PNS views order
 2000=Otevřít video
 2001=Otevřít video s LEVOU stopou
 2002=Otevřít video s PRAVOU stopou
@@ -140,6 +147,8 @@
 2005=Vymazat soubor
 2006=Skutečně chcete hodit soubor do koše?
 2007=Aktivní dekódery
+?2008=Choose audio file to attach
+?2009=Choose subtitles file to attach
 2010=Zvolte místo pro uložení obrázku
 2011=Nic není otevřeno!
 2012=Obraz není možné uložit!
@@ -254,3 +263,4 @@
 ?6055=X Rotation - up
 ?6056=X Rotation - down
 ?6057=Enable/disable panorama mode
+?6058=Show/hide GUI

sview-17_04.tar.gz/StMoviePlayer/lang/english/StMoviePlayer.lng -> sview-20_08.tar.gz/StMoviePlayer/lang/english/StMoviePlayer.lng Changed

@@ -62,6 +62,7 @@
 1260=Nearest
 1261=Linear
 1262=Blend Deinterlace
+?1263=Trilinear
 1270=Reset to defaults
 1271=Brightness
 1272=Saturation
@@ -70,10 +71,13 @@
 1281=Sphere
 1282=Cylinder
 1283=Cubemap
+1284=Hemisphere
 1285=Track orientation
 1286=Track orientation (poor)
 1287=Orient audio
 1288=Stick at panorama 360°
+1293=Equiangular cubemap
+1294=Theater
 1300=Audio
 1301=None
 1302=Audio/Video delay
@@ -93,9 +97,11 @@
 1359=Bottom
 1360=Plain text
 1361=Lite HTML
+1370=Apply stereo format
 1400=Change device
 1401=About Plugin...
 1402=FPS Control
+1404=Exclusive Fullscreen mode
 1420=VSync
 1421=Show Meter
 1422=Reduce CPU usage
@@ -131,6 +137,7 @@
 1705=On one click in windowed mode
 1710=Hide system navigation bar
 1711=Open last played file on startup
+1712=Swap JPS/PNS views order
 2000=Choose the video file to open
 2001=Choose LEFT video file to open
 2002=Choose RIGHT video file to open
@@ -139,6 +146,8 @@
 2005=File deletion
 2006=Do you really want to completely remove this file?
 2007=Active decoders:
+2008=Choose audio file to attach
+2009=Choose subtitles file to attach
 2010=Choose location to save snapshot
 2011=Nothing to save!
 2012=Snapshot not available!
@@ -253,3 +262,4 @@
 6055=X Rotation - up
 6056=X Rotation - down
 6057=Enable/disable panorama mode
+6058=Show/hide GUI

sview-17_04.tar.gz/StMoviePlayer/lang/french/StMoviePlayer.lng -> sview-20_08.tar.gz/StMoviePlayer/lang/french/StMoviePlayer.lng Changed

@@ -62,6 +62,7 @@
 1260=Plus proche
 1261=Lineaire
 1262=Blend Deinterlace
+1263=Trilinéaire
 1270=Rétablir par défaut
 1271=Brightness
 1272=Saturation
@@ -70,10 +71,13 @@
 1281=Sphère
 1282=Cylindre
 1283=Cubemap
+1284=Hémisphère
 ?1285=Track orientation
 ?1286=Track orientation (poor)
 ?1287=Orient audio
 ?1288=Stick at panorama 360°
+?1293=Equiangular cubemap
+1294=Théâtre
 1300=Audio
 1301=Aucun
 1302=Audio/Video delay
@@ -93,9 +97,11 @@
 1359=Au fond
 ?1360=Plain text
 ?1361=Lite HTML
+?1370=Apply stereo format
 1400=Changer la sortie
 1401=A propos du Plugin...
 1402=Contrôle de I/S
+?1404=Exclusive Fullscreen mode
 1420=Synchro Vert.
 1421=Voir I/S
 1422=Réduire l'utilisation de CPU
@@ -131,6 +137,7 @@
 ?1705=On one click windowed mode
 ?1710=Hide system navigation bar
 ?1711=Open last played file on startup
+1712=JPS/PNS échange de vues pour
 2000=Choix du fichier vidéo à ouvrir
 2001=Choix du fichier vidéo Gauche à ouvrir
 2002=Choix du fichier vidéo Droite à ouvrir
@@ -139,6 +146,8 @@
 ?2005=File deletion
 ?2006=Do you really want to completely remove this file?
 ?2007=Active decoders:
+2008=Choix du fichier audio à joindre
+2009=Choix du fichier sous-titres à joindre
 2010=Emplacement de la capture écran
 2011=Rien à enregistrer!
 2012=Capture non disponible!
@@ -253,3 +262,4 @@
 ?6055=X Rotation - up
 ?6056=X Rotation - down
 6057=Activer / désactiver le mode panorama
+6058=Masquer l'interface

sview-17_04.tar.gz/StMoviePlayer/lang/german/StMoviePlayer.lng -> sview-20_08.tar.gz/StMoviePlayer/lang/german/StMoviePlayer.lng Changed

@@ -62,6 +62,7 @@
 1260=Nearest
 1261=Linear
 1262=Blend Deinterlace
+1263=Trilinear
 1270=Auf Standardwerte zurücksetzen
 1271=Helligkeit
 1272=Sättigung
@@ -70,10 +71,13 @@
 1281=Kugel
 1282=Zylinder
 1283=Cubemap
+1284=Hemisphäre
 ?1285=Track orientation
 ?1286=Track orientation (poor)
 ?1287=Orient audio
 ?1288=Stick at panorama 360°
+?1293=Equiangular cubemap
+1294=Theater
 1300=Audio
 1301=keiner
 1302=Audio/Video Verzögerung
@@ -93,9 +97,11 @@
 1359=Boden
 1360=Plain text
 1361=Lite HTML
+1370=Stereoformat anwenden
 1400=Gerät ändern
 1401=Über Plugin...
 1402=FPS Kontrolle
+1404=Exklusiver Vollbildmodus
 1420=VSync
 1421=Zeige Meter
 1422=Reduce CPU usage
@@ -131,6 +137,7 @@
 ?1705=Only when windowed
 1710=Navigationsleiste ausblenden
 ?1711=Open last played file on startup
+1712=JPS/PNS-Ansichten, um zu tauschen
 2000=Wählen die Videodatei zu öffnen
 2001=Wählen die linke Videodatei zu öffnen
 2002=Wählen die rechte Videodatei zu öffnen
@@ -139,6 +146,8 @@
 2005=Löschen von Dateien
 ?2006=Do you really want to completely remove this file?
 ?2007=Active decoders:
+2008=Wählen die anzuhängende Audiodatei
+2009=Wählen die anzuhängende Untertiteldatei
 2010=Wählen einen Speicherort für Videoschnappschuss
 2011=Nichts zu speichern!
 2012=Schnappschuss ist nicht verfügbar!
@@ -253,3 +262,4 @@
 6055=X-Drehung - nach oben
 6056=X-Drehung - nach unten
 6057=Aktivieren / Deaktivieren der Panorama-Modus
+6058=GUI ausblenden

sview-17_04.tar.gz/StMoviePlayer/lang/korean/StMoviePlayer.lng -> sview-20_08.tar.gz/StMoviePlayer/lang/korean/StMoviePlayer.lng Changed

@@ -63,6 +63,7 @@
 ?1260=Nearest
 ?1261=Linear
 ?1262=Blend Deinterlace
+?1263=Trilinear
 1270=초기값 리셋
 1271=밝기
 ?1272=Saturation
@@ -71,10 +72,13 @@
 ?1281=Sphere
 ?1282=Cylinder
 ?1283=Cubemap
+?1284=Hemisphere
 ?1285=Track orientation
 ?1286=Track orientation (poor)
 ?1287=Orient audio
 ?1288=Stick at panorama 360°
+?1293=Equiangular cubemap
+?1294=Theater
 ?1300=Audio
 1301=없음
 1302=오디오/비디오 지연시간
@@ -94,9 +98,11 @@
 ?1359=Bottom
 ?1360=Plain text
 ?1361=Lite HTML
+?1370=Apply stereo format
 1400=장치 변경
 ?1401=About Plugin...
 ?1402=FPS 제어
+?1404=Exclusive Fullscreen mode
 ?1420=VSync
 ?1421=Show Meter
 1422=CPU 부하 감소
@@ -132,6 +138,7 @@
 ?1705=On one click windowed mode
 ?1710=Hide system navigation bar
 ?1711=Open last played file on startup
+?1712=Swap JPS/PNS views order
 2000=재생할 비디오 파일을 선택하시오
 2001=좌안 비디오 파일을 선택하시오
 2002=우안 비디오 파일을 선택하시오
@@ -140,6 +147,8 @@
 ?2005=File deletion
 ?2006=Do you really want to completely remove this file?
 ?2007=Active decoders:
+?2008=Choose audio file to attach
+?2009=Choose subtitles file to attach
 2010=스냅샷을 저장할 위치를 선택하시오
 2011=저장할 수 없음!
 2012=스냅샷 없음!
@@ -254,3 +263,4 @@
 ?6055=X Rotation - up
 ?6056=X Rotation - down
 ?6057=Enable/disable panorama mode
+?6058=Show/hide GUI

sview-17_04.tar.gz/StMoviePlayer/lang/russian/StMoviePlayer.lng -> sview-20_08.tar.gz/StMoviePlayer/lang/russian/StMoviePlayer.lng Changed

@@ -63,6 +63,7 @@
 1260=Без сглаживания
 1261=Линейное
 1262=Blend Deinterlace
+1263=Трилинейное
 1270=Сбросить настройки
 1271=Яркость
 1272=Насыщенность
@@ -71,10 +72,13 @@
 1281=Сфера
 1282=Цилиндр
 1283=Куб
+1284=Полусфера
 1285=Отслеживать ориентацию
 1286=Отслеживать ориентацию (poor)
 1287=Ориентировать звук
 1288=Закрепить панорамный режим 360°
+?1293=Equiangular cubemap
+1294=Киноэкран
 1300=Аудио
 1301=Без звука
 1302=Задержка звука
@@ -89,6 +93,7 @@
 1400=Выбрать устройство
 1401=О модуле...
 1402=FPS Control
+1404=Эксклюзивный полноэкранный режим
 1420=Верт. синхронизация
 1421=Отображать FPS
 1422=Ограничить использование CPU
@@ -121,6 +126,7 @@
 1359=Снизу
 1360=Plain text
 1361=Lite HTML
+1370=Применить стереоформат
 1590=Мелко
 1591=Нормально
 1592=Крупно
@@ -132,6 +138,7 @@
 1705=Только в оконном режиме
 1710=Скрыть панель навигации
 1711=Открывать последний файл при старте
+1712=Поменять ракурсы местами в JPS/PNS
 2000=Выберите видеофайл
 2001=Выберите видеофайл с ЛЕВЫМ ракурсом
 2002=Выберите видеофайл с ПРАВЫМ ракурсом
@@ -140,6 +147,8 @@
 2005=Удаление файла
 2006=Вы действительно хотите\n<b>удалить файл</b> минуя корзину?
 2007=Активные декодеры:
+2008=Выберите аудиофайл
+2009=Выберите файл субтитров
 2010=Выберите путь для сохранения картинки
 2011=Ничего не открыто!
 2012=Изображение недоступно для сохранения!
@@ -254,3 +263,4 @@
 6055=X наклон - наверх
 6056=X наклон - вниз
 6057=Включить/выключить панорамный режим
+6058=Скрыть интерфейс

sview-20_08.tar.gz/StMoviePlayer/lang/spanish Added

sview-20_08.tar.gz/StMoviePlayer/lang/spanish/StMoviePlayer.lng Added

@@ -0,0 +1,264 @@
+# Spanish translation file for StMoviePlayer
+--------
+1002=Cambiar izquierdo/derecho
+1003=Revertir cambio izquierdo/derecho
+1004=Formato estereoscópico:
+1015=Abrir otra película
+1020=Reproducir/Pausa
+1021=Mostrar/Ocultar lista de reproducción
+1022=Reproducir archivo anterior
+1023=Reproducir archivo siguiente
+1029=Cambiar entre\npantalla completa/ventana
+1100=Medios
+1101=Abrir película...
+1102=Guardar instantánea...
+1103=Formato estereoscópico
+1170=Información del archivo
+1104=Dispositivo de audio
+1105=Mezclar
+1106=Archivos recientes
+1107=Decodificación de vídeo en GPU
+1108=UI Web
+1109=Salir
+1110=Desde un archivo
+1111=Archivos izquierdo+derecho
+1130=Fuente
+1131=Mono
+1132=Vista cruzada
+1133=Par paralelo
+1134=Sobre/bajo (D/I)
+1135=Sobre/bajo (I/D)
+1136=Entrelazado
+1137=Anaglifo rojo/cian
+1138=Anaglifo verde/rojo+azul
+1139=Anaglifo amarillo/azul
+1140=Fotograma-secuencial
+1141=2x720p en 1080p en mosaico
+1142=2 canales
+1160=Borrar historial
+1180=Apagar
+1181=Iniciar una vez
+1182=Iniciar siempre
+1185=Mostrar errores
+1186=¡No se puede iniciar la UI Web en el puerto {0}!
+1200=Ver
+1201=Salida estéreo
+1202=Pantalla completa
+1203=Restablecer
+1204=Cambiar izquierdo/derecho
+1205=Relación de visualización
+1206=Filtro más suave
+1207=Ajustar imagen
+1208=Panorámica
+1210=Estéreo
+1211=Vista izquierda
+1212=Vista derecha
+1213=Par paralelo
+1214=Vista cruzada
+1250=Fuente
+1251=Conservar al reiniciar
+1252=Corregir anamórfico 1080p/720p
+1260=Más cercano
+1261=Lineal
+1262=Mezclar entrelazado
+?1263=Trilineal
+1270=Restablecer predeterminados
+1271=Brillo
+1272=Saturación
+1273=Gamma
+1280=Plano
+1281=Esfera
+1282=Cilindro
+1283=Cubemap
+1284=Hemisferio
+1285=Orientación de pista
+1286=Orientación de pista (deficiente)
+1287=Orientar audio
+1288=Mantener en panorámica de 360°
+?1293=Equiangular cubemap
+1294=Teatro
+1300=Audio
+1301=Ninguna
+1302=Retraso de audio/vídeo
+1303=Adjuntar de archivo
+1320=Sincronización de audio/vídeo
+1321=Introduce un valor positivo si el audio está adelantado al vídeo, y negativo para lo contrario.
+1322=Retraso de audio:
+1323=segundo(s)
+1350=Subtítulos
+1351=Ninguno
+1353=Adjuntar de archivo
+1354=Tamaño de fuente
+1355=Paralaje
+1356=Interpretador de texto
+1357=Posición
+1358=Superior
+1359=Inferior
+1360=Texto sin formato
+1361=Lite HTML
+1370=Aplicar formato estéreo
+1400=Cambiar dispositivo
+1401=Acerca del complemento...
+1402=Control de FPS
+1404=Modo de pantalla completa exclusiva
+1420=Sincronización vertical
+1421=Mostrar medidor
+1422=Reducir uso de CPU
+1500=Ayuda
+1501=Acerca de...
+1502=Buscar actualizaciones
+1503=Texto de la licencia
+1504=Idioma (Language)
+1505=Bloquear suspensión
+1506=Consejos para el usuario
+1507=Características experimentales
+1508=Acerca del sistema
+1509=Escala de la interfaz
+1510=Teclas de acceso rápido
+1511=Ajustes
+1520=Ahora
+1521=Cada día
+1522=Cada semana
+1523=Cada año
+1524=Nunca
+1550=Nunca
+1551=Siempre
+1552=Durante la reproducción
+1553=En pantalla completa
+1590=Pequeño
+1591=Normal
+1592=Grande
+1593=Forzar HiDPI 2X
+1701=Salir de sView con escape
+1702=No salir
+1703=Con un clic
+1704=Con doble clic
+1705=Con un clic en modo ventana
+1710=Ocultar la barra de navegación del sistema
+1711=Abrir el último archivo reproducido al iniciar
+1712=JPS/PNS ve intercambio orden
+2000=Elije el archivo de vídeo para abrir
+2001=Elige el archivo de vídeo IZQUIERDO para abrir
+2002=Elije derecho archivo de vídeo DERECHO para abrir
+2003=Información del archivo
+2004=La información del archivo no está disponible
+2005=Eliminación de archivo
+2006=¿Realmente deseas eliminar completamente este archivo?
+2007=Descodificadores activos:
+2008=Elije el archivo de audio para añadir
+2009=Elije el archivo de subtítulos para añadir
+2010=Elije la ubicación para guardar la instantánea
+2011=¡Nada para guardar!
+2012=¡Instantánea no disponible!
+2013=Asignar nueva tecla de acceso rápido para la acción\n<i>{0}</i>
+2014=En conflicto con: <i>{0}</i>
+3000=sView - Reproductor de películas
+3001=versión
+3002=El reproductor de películas te permite reproducir un vídeo estereoscópico.\n © {0} Kirill Gavrilov <{1}>\nSitio oficial: {2}\n\nEste programa se distribuye bajo licencia GPL 3.0
+3003=Hay disponible una nueva versión de sView en el sitio oficial: www.sview.ru.\nPor favor, actualiza el programa.
+3004=Información del sistema
+4000=Cerrar
+4001=Cancelar
+4005=Restablecer
+4006=Guardar
+4007=Eliminar
+4008=Predeterminado
+4009=Predeterminados
+4010=Asignar
+5000=[izquierdo]
+5001=[derecho]
+5002=Nombre de archivo(s)
+5003=Dimensiones del vídeo
+5004=Tiempo de carga
+5005=ms
+5006=Relación de pixeles
+5007=Formato de píxel
+5008=(no almacenado en los metadatos)
+5009=(no coincide con los metadatos)
+5010=Duración
+5011=(no almacenado en los metadatos,\npero detectado en el nombre de archivo)
+5300=Título
+5301=Compositor
+5302=Artista
+5303=Artista del álbum
+5304=Álbum
+5305=Disco
+5306=Núm. de discos
+5307=Género
+5308=Comentario
+5309=Notas
+5310=Descripción
+5311=Editor
+5312=Derechos de autor
+5313=Codificador
+5314=Ingeniero
+5315=Fuente
+5316=Fecha de creación
+5317=Fecha
+5318=Año
+5319=Idioma
+5320=Pista
+5321=Núm. de pistas
+5322=Ganancia de la pista
+5323=Pico de la pista
+5324=Ganancia del álbum
+5325=Pico del álbum
+6000=Salir del programa
+6001=Cambiar entre pantalla completa/ventana
+6002=Mostrar/ocultar medidor de FPS
+6003=Formato estéreo: Automático
+6004=Formato estéreo: Mono
+6005=Formato estéreo: Sobre/bajo
+6006=Formato estéreo: En paralelo
+6007=Mostrar información del archivo
+6008=Lista de reproducción: Ir al primer elemento
+6009=Lista de reproducción: Ir al último elemento
+6010=Lista de reproducción: Ir al anterior elemento
+6011=Lista de reproducción: Ir al siguiente elemento
+6012=Lista de reproducción: Ir al anterior elemento [2]
+6013=Lista de reproducción: Ir al siguiente elemento [2]
+6014=Reproducir/pausar
+6015=Detener reproducción
+6016=Atrás 5 segundos
+6017=Adelante 5 segundos
+6018=Mostrar cuadro de diálogo para abrir archivo
+6019=Guardar instantánea
+6020=Eliminar el archivo del sistema de archivos
+6021=Silenciar/reactivar audio
+6022=Bajar volumen del audio
+6023=Subir volumen del audio
+6024=Anterior pista de audio
+6025=Siguiente pista de audio
+6026=Anterior pista de subtítulos
+6027=Siguiente pista de subtítulos
+6028=Copiar el texto de los subtítulos mostrados
+6029=Abrir URL del portapapeles
+6030=Mostrar/Ocultar lista de reproducción
+6031=Restablecer el ajuste de la imagen
+6032=Restablecer la posición de la imagen
+6033=Cambiar izquierdo/derecho
+6034=Corrección gamma: disminuir
+6035=Corrección gamma: aumentar
+6036=Separación DX: disminuir
+6037=Separación DX: aumentar
+6038=Separación DY: disminuir
+6039=Separación DY: aumentar
+6040=Separación angular: disminuir
+6041=Separación angular: aumentar
+6042=Rotar 90° a la izquierda
+6043=Rotar 90° a la derecha
+6044=Rotar a la izquierda
+6045=Rotar a la derecha
+6046=Activar/Desactivar modo panorámico
+6047=Barrido: navegar hacia la izquierda
+6048=Barrido: navegar hacia la derecha
+6049=Barrido: navegar hacia arriba
+6050=Barrido: navegar hacia abajo
+6051=Escala: aumentar
+6052=Escala: reducir
+6053=Rotación Y: izquierda
+6054=Rotación Y: derecha
+6055=Rotación X: arriba
+6056=Rotación X: abajo
+6057=Activar/Desactivar modo panorámico
+6058=Mostrar/ocultar GUI

sview-17_04.tar.gz/StOutAnaglyph/StOutAnaglyph.cpp -> sview-20_08.tar.gz/StOutAnaglyph/StOutAnaglyph.cpp Changed

sview-17_04.tar.gz/StOutAnaglyph/StOutAnaglyph.rc -> sview-20_08.tar.gz/StOutAnaglyph/StOutAnaglyph.rc Changed

sview-20_08.tar.gz/StOutAnaglyph/lang/spanish Added

sview-20_08.tar.gz/StOutAnaglyph/lang/spanish/StOutAnaglyph.lng Added

sview-17_04.tar.gz/StOutDistorted/StOutDistorted.cpp -> sview-20_08.tar.gz/StOutDistorted/StOutDistorted.cpp Changed

@@ -1,6 +1,6 @@
 /**
  * StOutDistorted, class providing stereoscopic output in anamorph side by side format using StCore toolkit.
- * Copyright © 2013-2017 Kirill Gavrilov <kirill@sview.ru>
+ * Copyright © 2013-2020 Kirill Gavrilov <kirill@sview.ru>
  *
  * Distributed under the Boost Software License, Version 1.0.
  * See accompanying file license-boost.txt or copy at
@@ -19,6 +19,7 @@
 #include <StGL/StGLArbFbo.h>
 #include <StGLCore/StGLCore20.h>
 #include <StGLMesh/StGLTextureQuad.h>
+#include <StGLStereo/StGLProjCamera.h>
 #include <StSettings/StSettings.h>
 #include <StSettings/StTranslations.h>
 #include <StSettings/StEnumParam.h>
@@ -32,13 +33,6 @@
     #ifdef _MSC_VER
         #pragma comment(lib, "openvr_api.lib")
     #endif
-#elif defined(ST_HAVE_LIBOVR)
-    #include <OVR.h>
-    #include <OVR_CAPI_GL.h>
-
-    #ifdef _MSC_VER
-        #pragma comment(lib, "LibOVR.lib")
-    #endif
 #endif
 
 namespace {
@@ -217,7 +211,7 @@
 void StOutDistorted::updateAbout() {
     myAbout = myAboutTitle + '\n' + myAboutVerString + " " + StVersionInfo::getSDKVersionString() + "\n \n"
             + (!myAboutVrDevice.isEmpty() ? ("Connected hardware: " + myAboutVrDevice + "\n \n") : "")
-            + myAboutDescr.format("2013-2017", "kirill@sview.ru", "www.sview.ru");
+            + myAboutDescr.format("2013-2020", "kirill@sview.ru", "www.sview.ru");
 #ifdef ST_HAVE_OPENVR
     myAbout = myAbout + "\n \n"
             + "This software uses OpenVR library:\n"
@@ -244,18 +238,15 @@
   myVrMarginsBottom(0.35),
   myVrMarginsLeft(0.33),
   myVrMarginsRight(0.33),
-  myVrRendSizeX(0),
-  myVrRendSizeY(0),
+  myVrFrequency(0),
+  myVrAspectRatio(1.0f),
+  myVrFieldOfView(-1.0f),
+  myVrIOD(0.0f),
   myVrTrackOrient(false),
   myVrToDrawMsg(false),
 #ifdef ST_HAVE_OPENVR
   myVrHmd(NULL),
   myVrTrackedPoses(new vr::TrackedDevicePose_t[vr::k_unMaxTrackedDeviceCount]),
-#elif defined(ST_HAVE_LIBOVR)
-  myVrHmd(NULL),
-  myOvrSwapTexture(NULL),
-  myOvrMirrorTexture(NULL),
-  myOvrMirrorFbo(0),
 #endif
   myToShowCursor(true),
   myToCompressMem(myInstancesNb.increment() > 1),
@@ -264,10 +255,6 @@
   myCanHdmiPack(false),
   myIsHdmiPack(false),
   myIsForcedFboUsage(false) {
-#ifdef ST_HAVE_LIBOVR
-    myOvrSwapFbo[0] = 0;
-    myOvrSwapFbo[1] = 0;
-#endif
     const StSearchMonitors& aMonitors = StWindow::getMonitors();
 
     // detect connected displays
@@ -298,13 +285,6 @@
     if(vr::VR_IsHmdPresent()) {
         aSupportOpenVr = ST_DEVICE_SUPPORT_PREFER;
     }
-#elif defined(ST_HAVE_LIBOVR)
-    const ovrResult anOvrRes = ovr_Initialize(NULL);
-    if(!OVR_SUCCESS(anOvrRes)) {
-        ST_ERROR_LOG("StOutDistorted, OVR initialization has failed!");
-    } else {
-        aSupportOpenVr = ST_DEVICE_SUPPORT_HIGHT;
-    }
 #endif
 
     // devices list
@@ -374,28 +354,6 @@
             vr::VR_Shutdown();
             myVrHmd = NULL;
         }
-    #elif defined(ST_HAVE_LIBOVR)
-        if(myOvrSwapFbo[0] != 0) {
-            myContext->arbFbo->glDeleteFramebuffers(2, myOvrSwapFbo);
-            myOvrSwapFbo[0] = 0;
-            myOvrSwapFbo[1] = 0;
-        }
-        if(myOvrSwapTexture != NULL) {
-            ovr_DestroySwapTextureSet(myVrHmd, myOvrSwapTexture);
-            myOvrSwapTexture = NULL;
-        }
-        if(myOvrMirrorFbo != 0) {
-            myContext->arbFbo->glDeleteFramebuffers(1, &myOvrMirrorFbo);
-            myOvrMirrorFbo = NULL;
-        }
-        if(myOvrMirrorTexture != NULL) {
-            ovr_DestroyMirrorTexture(myVrHmd, &myOvrMirrorTexture->Texture);
-            myOvrMirrorTexture = NULL;
-        }
-        if(myVrHmd != NULL) {
-            ovr_Destroy(myVrHmd);
-            myVrHmd = NULL;
-        }
     #endif
 
         myProgramFlat->release(*myContext);
@@ -437,8 +395,6 @@
 
 #ifdef ST_HAVE_OPENVR
     delete[] myVrTrackedPoses;
-#elif defined(ST_HAVE_LIBOVR)
-    ovr_Shutdown();
 #endif
 }
 
@@ -460,6 +416,8 @@
     myContext = StWindow::getContext();
     myContext->setMessagesQueue(myMsgQueue);
     myIsBroken = false;
+    myVrFrequency = 0;
+    myVrFieldOfView = -1.0f;
     if(!myContext->isGlGreaterEqual(2, 0)) {
         myMsgQueue->pushError(stCString("OpenGL 2.0 is required by Distorted Output"));
         myIsBroken = true;
@@ -538,78 +496,17 @@
         const StString aVrManuf   = getVrTrackedDeviceString(myVrHmd, vr::k_unTrackedDeviceIndex_Hmd, vr::Prop_ManufacturerName_String);
         const StString aVrDriver  = getVrTrackedDeviceString(myVrHmd, vr::k_unTrackedDeviceIndex_Hmd, vr::Prop_TrackingSystemName_String);
         const StString aVrDisplay = getVrTrackedDeviceString(myVrHmd, vr::k_unTrackedDeviceIndex_Hmd, vr::Prop_SerialNumber_String);
+        myVrFrequency = myVrHmd->GetFloatTrackedDeviceProperty(vr::k_unTrackedDeviceIndex_Hmd, vr::Prop_DisplayFrequency_Float);
+        updateVRProjectionFrustums();
 
-        uint32_t aRenderSizeX = 0;
-        uint32_t aRenderSizeY = 0;
+        uint32_t aRenderSizeX = 0, aRenderSizeY = 0;
         myVrHmd->GetRecommendedRenderTargetSize(&aRenderSizeX, &aRenderSizeY);
         myAboutVrDevice = aVrManuf + " " + aVrDriver + "\n"
-                        + aVrDisplay + " [" + aRenderSizeX + "x" + aRenderSizeY + "]";
-        myVrRendSizeX = int(aRenderSizeX);
-        myVrRendSizeY = int(aRenderSizeY);
+                        + aVrDisplay + " [" + aRenderSizeX + "x" + aRenderSizeY + "@" + myVrFrequency + "]";
+        myVrRendSize.x() = int(aRenderSizeX);
+        myVrRendSize.y() = int(aRenderSizeY);
         updateAbout();
     }
-
-#elif defined(ST_HAVE_LIBOVR)
-    if(myDevice == DEVICE_HMD) {
-        ovrGraphicsLuid aLuid;
-        const ovrResult anOvrRes = ovr_Create(&myVrHmd, &aLuid);
-        if(myVrHmd == NULL
-        || !OVR_SUCCESS(anOvrRes)) {
-            myMsgQueue->pushError(stCString("StOutDistorted, Oculus Rift is not connected!"));
-            myVrHmd = NULL;
-            return true;
-        }
-    }
-
-    if(myVrHmd != NULL) {
-        ovrHmdDesc anHmdDesc = ovr_GetHmdDesc(myVrHmd);
-        ovrSizei aWinSize = { anHmdDesc.Resolution.w / 2, anHmdDesc.Resolution.h / 2 };
-
-        ST_DEBUG_LOG("libOVR Resolution: " + anHmdDesc.Resolution.w + "x" + anHmdDesc.Resolution.h);
-        if(isMovable()) {
-            StRect<int32_t> aRect = StWindow::getPlacement();
-            aRect.right()  = aRect.left() + aWinSize.w;
-            aRect.bottom() = aRect.top()  + aWinSize.h;
-            StWindow::setPlacement(aRect, false);
-        }
-
-        ovrResult anOvrRes = ovr_CreateMirrorTextureGL(myVrHmd, GL_SRGB8_ALPHA8, aWinSize.w, aWinSize.h, (ovrTexture** )&myOvrMirrorTexture);
-        if(!OVR_SUCCESS(anOvrRes)) {
-            myMsgQueue->pushError(stCString("StOutDistorted, Failed to create mirror texture!"));
-            myIsBroken = true;
-            return true;
-        }
-
-        const GLuint anFboReadBack = myContext->stglFramebufferRead();
-        myContext->arbFbo->glGenFramebuffers(1, &myOvrMirrorFbo);
-        myContext->stglBindFramebufferRead(myOvrMirrorFbo);
-        myContext->arbFbo->glFramebufferTexture2D(GL_READ_FRAMEBUFFER, GL_COLOR_ATTACHMENT0, GL_TEXTURE_2D, myOvrMirrorTexture->OGL.TexId, 0);
-        myContext->stglBindFramebufferRead(anFboReadBack);
-
-        ovrSizei anEyeSizes[2] = {
-            ovr_GetFovTextureSize(myVrHmd, ovrEye_Left,  anHmdDesc.DefaultEyeFov[ovrEye_Left],  1),
-            ovr_GetFovTextureSize(myVrHmd, ovrEye_Right, anHmdDesc.DefaultEyeFov[ovrEye_Right], 1)
-        };
-        myVrRendSizeX = stMax(anEyeSizes[0].w, anEyeSizes[1].w);
-        myVrRendSizeY = stMax(anEyeSizes[0].h, anEyeSizes[1].h);
-        anOvrRes = ovr_CreateSwapTextureSetGL(myVrHmd, GL_SRGB8_ALPHA8, myVrRendSizeX * 2, myVrRendSizeY, &myOvrSwapTexture);
-        if(!OVR_SUCCESS(anOvrRes)
-         || myOvrSwapTexture->TextureCount < 2) {
-            myMsgQueue->pushError(stCString("StOutDistorted, Failed to create swap texture!"));
-            myIsBroken = true;
-            return true;
-        }
-
-        myOvrSwapTexture->CurrentIndex = 0;
-        myContext->arbFbo->glGenFramebuffers(2, myOvrSwapFbo);
-        myContext->stglBindFramebufferRead(myOvrSwapFbo[0]);
-        myContext->arbFbo->glFramebufferTexture2D(GL_READ_FRAMEBUFFER, GL_COLOR_ATTACHMENT0, GL_TEXTURE_2D,
-                                                  ((ovrGLTexture* )&myOvrSwapTexture->Textures[0])->OGL.TexId, 0);
-        myContext->stglBindFramebufferRead(myOvrSwapFbo[1]);
-        myContext->arbFbo->glFramebufferTexture2D(GL_READ_FRAMEBUFFER, GL_COLOR_ATTACHMENT0, GL_TEXTURE_2D,
-                                                  ((ovrGLTexture* )&myOvrSwapTexture->Textures[1])->OGL.TexId, 0);
-        myContext->stglBindFramebufferRead(anFboReadBack);
-    }
 #endif
 
     if(myDevice == DEVICE_HMD) {
@@ -638,6 +535,37 @@
     return true;
 }
 
+void StOutDistorted::updateVRProjectionFrustums() {
+#ifdef ST_HAVE_OPENVR
+    StRect<float> aFrustL, aFrustR;
+    myVrHmd->GetProjectionRaw(vr::Eye_Left,  &aFrustL.left(), &aFrustL.right(), &aFrustL.top(), &aFrustL.bottom());
+    myVrHmd->GetProjectionRaw(vr::Eye_Right, &aFrustR.left(), &aFrustR.right(), &aFrustR.top(), &aFrustR.bottom());
+    myVrFrustumL = aFrustL;
+    myVrFrustumR = aFrustR;
+    std::swap(myVrFrustumL.top(), myVrFrustumL.bottom());
+    std::swap(myVrFrustumR.top(), myVrFrustumR.bottom());
+
+    const StVec2<double> aTanHalfFov(StVec4<float>(-aFrustL.left(), aFrustL.right(),  -aFrustR.left(), aFrustR.right()).maxComp(),
+                                     StVec4<float>(-aFrustL.top(),  aFrustL.bottom(), -aFrustR.top(),  aFrustR.bottom()).maxComp());
+    myVrAspectRatio = float(aTanHalfFov.x() / aTanHalfFov.y());
+    myVrFieldOfView = float(2.0 * std::atan(aTanHalfFov.y()) * 180.0 / M_PI);
+
+    // Intra-ocular Distance can be changed in runtime
+    //const vr::HmdMatrix34_t aLeftToHead  = myContext->System->GetEyeToHeadTransform (vr::Eye_Left);
+    //const vr::HmdMatrix34_t aRightToHead = myContext->System->GetEyeToHeadTransform (vr::Eye_Right);
+    //myVrIOD = aRightToHead.m[0][3] - aLeftToHead.m[0][3];
+    myVrIOD = myVrHmd->GetFloatTrackedDeviceProperty(vr::k_unTrackedDeviceIndex_Hmd, vr::Prop_UserIpdMeters_Float);
+#else
+  (void )myVrIOD;
+#endif
+}
+
+float StOutDistorted::getMaximumTargetFps() const {
+    return myVrFrequency > 24
+         ? myVrFrequency
+         : StWindow::getMaximumTargetFps();
+}
+
 void StOutDistorted::processEvents() {
     StWindow::processEvents();
 
@@ -694,20 +622,27 @@
         return;
     }
 
-    const float aLensDisp = getLensDist() * 0.5f;
-    double aGlLeft  = -1.0;
-    double aGlTop   =  1.0;
-    double aGlSizeX =  2.0;
-    double aGlSizeY =  2.0;
+    double aGlLeft  = -1.0, aGlTop   = 1.0;
+    double aGlSizeX =  2.0, aGlSizeY = 2.0;
+    float aLensDisp = theView == ST_DRAW_LEFT ? getLensDist() : -getLensDist();
     if(isHmdOutput()) {
         aGlLeft  = -1.0 + myVrMarginsLeft * 2.0;
         aGlTop   =  1.0 - myVrMarginsTop  * 2.0;
         aGlSizeX =  2.0 - (myVrMarginsLeft + myVrMarginsRight) * 2.0;
         aGlSizeY =  2.0 - (myVrMarginsTop + myVrMarginsBottom) * 2.0;
+
+        StGLProjCamera aProjCam;
+        aProjCam.setPerspective(true);
+        //aProjCam.setFOVy(myVrFieldOfView);
+        aProjCam.resize(myVrAspectRatio);
+        aProjCam.setCustomProjection(myVrFrustumL, myVrFrustumR);
+        aProjCam.setView(theView);
+
+        const StGLVec4 aTestProj = aProjCam.getProjMatrix() * StGLVec4(0, 0, aProjCam.getZScreen(), 1.0f);
+        aLensDisp = aTestProj.x() / aTestProj.w();
     }
 
     // compute cursor position
-    StArray<StGLVec4> aVerts(4);
     const float aCurLeft = float(aGlLeft + theCursorPos.x() * aGlSizeX);
     const float aCurTop  = float(aGlTop  - theCursorPos.y() * aGlSizeY);
     if(isHmdOutput()) {
@@ -735,17 +670,12 @@
                 break;
         }
     }
-    if(theView == ST_DRAW_LEFT) {
-        aVerts[0] = StGLVec4( 2.0f * aLensDisp + aCurLeft + aCurWidth, aCurTop - aCurHeight, 0.0f, 1.0f);
-        aVerts[1] = StGLVec4( 2.0f * aLensDisp + aCurLeft + aCurWidth, aCurTop,              0.0f, 1.0f);
-        aVerts[2] = StGLVec4( 2.0f * aLensDisp + aCurLeft,             aCurTop - aCurHeight, 0.0f, 1.0f);
-        aVerts[3] = StGLVec4( 2.0f * aLensDisp + aCurLeft,             aCurTop,              0.0f, 1.0f);
-    } else {
-        aVerts[0] = StGLVec4(-2.0f * aLensDisp + aCurLeft + aCurWidth, aCurTop - aCurHeight, 0.0f, 1.0f);
-        aVerts[1] = StGLVec4(-2.0f * aLensDisp + aCurLeft + aCurWidth, aCurTop,              0.0f, 1.0f);
-        aVerts[2] = StGLVec4(-2.0f * aLensDisp + aCurLeft,             aCurTop - aCurHeight, 0.0f, 1.0f);
-        aVerts[3] = StGLVec4(-2.0f * aLensDisp + aCurLeft,             aCurTop,              0.0f, 1.0f);
-    }
+
+    StArray<StGLVec4> aVerts(4);
+    aVerts[0] = StGLVec4(aLensDisp + aCurLeft + aCurWidth, aCurTop - aCurHeight, 0.0f, 1.0f);
+    aVerts[1] = StGLVec4(aLensDisp + aCurLeft + aCurWidth, aCurTop,              0.0f, 1.0f);
+    aVerts[2] = StGLVec4(aLensDisp + aCurLeft,             aCurTop - aCurHeight, 0.0f, 1.0f);
+    aVerts[3] = StGLVec4(aLensDisp + aCurLeft,             aCurTop,              0.0f, 1.0f);
     myCurVertsBuf.init(*myContext, aVerts);
 
     myContext->core20fwd->glBlendFunc(GL_SRC_ALPHA, GL_ONE_MINUS_SRC_ALPHA);
@@ -767,7 +697,7 @@
 }
 
 bool StOutDistorted::hasOrientationSensor() const {
-#if defined(ST_HAVE_OPENVR) || defined(ST_HAVE_LIBOVR)
+#if defined(ST_HAVE_OPENVR)
     if(myVrHmd != NULL) {
         return true;
     }
@@ -776,7 +706,7 @@
 }
 
 bool StOutDistorted::toTrackOrientation() const {
-#if defined(ST_HAVE_OPENVR) || defined(ST_HAVE_LIBOVR)
+#if defined(ST_HAVE_OPENVR)
     if(myVrHmd != NULL) {
         return myVrTrackOrient;
     }
@@ -785,7 +715,7 @@
 }
 
 void StOutDistorted::setTrackOrientation(const bool theToTrack) {
-#if defined(ST_HAVE_OPENVR) || defined(ST_HAVE_LIBOVR)
+#if defined(ST_HAVE_OPENVR)
     if(myVrHmd != NULL) {
         myVrTrackOrient = theToTrack;
         return;
@@ -799,7 +729,7 @@
 StQuaternion<double> StOutDistorted::getDeviceOrientation() const {
     if(myVrTrackOrient
     && !myIsBroken) {
-    #if defined(ST_HAVE_OPENVR) || defined(ST_HAVE_LIBOVR)
+    #if defined(ST_HAVE_OPENVR)
         if(myVrHmd != NULL) {
             return myVrOrient;
         }
@@ -808,16 +738,35 @@
     return StWindow::getDeviceOrientation();
 }
 
+bool StOutDistorted::getCustomProjection(StRectF_t& theLeft, StRectF_t& theRight) const {
+    if(!isHmdOutput()) {
+        return false;
+    }
+
+    theLeft  = myVrFrustumL;
+    theRight = myVrFrustumR;
+    return true;
+}
+
+StGLBoxPx StOutDistorted::stglViewport(const int theWinEnum) const {
+    if(!isHmdOutput()) {
+        return StWindow::stglViewport(theWinEnum);
+    }
+
+    StGLBoxPx aBox;
+    aBox.x() = aBox.y() = 0;
+    aBox.width()  = myVrRendSize.x();
+    aBox.height() = myVrRendSize.y();
+    return aBox;
+}
+
 StMarginsI StOutDistorted::getMargins() const {
     if(isHmdOutput()) {
-        const StGLBoxPx aViewPort = StWindow::stglViewport(ST_WIN_MASTER);
-        const int aSizeX = aViewPort.width();
-        const int aSizeY = aViewPort.height();
         StMarginsI aMargins;
-        aMargins.left   = int(double(aSizeX) * myVrMarginsLeft);
-        aMargins.right  = int(double(aSizeX) * myVrMarginsRight);
-        aMargins.top    = int(double(aSizeY) * myVrMarginsTop);
-        aMargins.bottom = int(double(aSizeY) * myVrMarginsBottom);
+        aMargins.left   = int(double(myVrRendSize.x()) * myVrMarginsLeft);
+        aMargins.right  = int(double(myVrRendSize.x()) * myVrMarginsRight);
+        aMargins.top    = int(double(myVrRendSize.y()) * myVrMarginsTop);
+        aMargins.bottom = int(double(myVrRendSize.y()) * myVrMarginsBottom);
         return aMargins;
     }
     return StMarginsI();
@@ -832,9 +781,8 @@
         return StWindow::getScaleFactor();
     }
 
-    // within direct rendering mode HMD is not visible to the system and thus is not registered as StMonitor,
-    // therefore we need to override scale factor here to avoid incorrect scaling
-    return 0.8f;
+    // TODO this is calibrated for HTC Vive; applying to HMDs with another FOV might give bad results
+    return float(myVrRendSize.x()) / 1280.0f;
 }
 
 void StOutDistorted::checkHdmiPack() {
@@ -880,12 +828,18 @@
         return;
     }
 
-    if(!myFrBuffer->initLazy(*myContext, GL_RGBA8, myVrRendSizeX, myVrRendSizeY, StWindow::hasDepthBuffer())) {
-        myIsBroken = true;
-        myMsgQueue->pushError(stCString("OpenVR output - critical error:\nFrame Buffer Object resize failed!"));
-        vr::VR_Shutdown();
-        myVrHmd = NULL;
-        return;
+    // force resizing instead of lazy resize as we do not pass texture bounds
+    const vr::VRTextureBounds_t* aTexBounds = NULL;
+    if(!myFrBuffer->isValid()
+     || myFrBuffer->getSizeX() != myVrRendSize.x()
+     || myFrBuffer->getSizeY() != myVrRendSize.y()) {
+        if(!myFrBuffer->init(*myContext, GL_RGBA8, myVrRendSize.x(), myVrRendSize.y(), StWindow::hasDepthBuffer())) {
+            myIsBroken = true;
+            myMsgQueue->pushError(stCString("OpenVR output - critical error:\nFrame Buffer Object resize failed!"));
+            vr::VR_Shutdown();
+            myVrHmd = NULL;
+            return;
+        }
     }
 
     // draw into virtual frame buffers (textures)
@@ -896,7 +850,7 @@
         stglDrawCursor(aCursorPos, ST_DRAW_LEFT);
 
         vr::Texture_t aVRTexture = { (void* )(size_t )myFrBuffer->getTextureColor()->getTextureId(),  vr::TextureType_OpenGL, vr::ColorSpace_Gamma };
-        const vr::EVRCompositorError aVRError = vr::VRCompositor()->Submit(vr::Eye_Left, &aVRTexture);
+        const vr::EVRCompositorError aVRError = vr::VRCompositor()->Submit(vr::Eye_Left, &aVRTexture, aTexBounds);
         if(aVRError != vr::VRCompositorError_None) {
             //myMsgQueue->pushError(getVRCompositorError(aVRError));
             ST_ERROR_LOG(getVRCompositorError(aVRError));
@@ -936,8 +890,10 @@
                     aRotMat[aCol][aRow] = aHeadPos.m[aCol][aRow];
                 }
             }
+
             myVrOrient.setMatrix(aRotMat);
-	      }
+            updateVRProjectionFrustums();
+        }
     }
 
     // real screen buffer
@@ -958,91 +914,6 @@
             myVrMsgTimer.stop();
         }
     }
-#elif defined(ST_HAVE_LIBOVR)
-    const StGLBoxPx  aVPBoth    = StWindow::stglViewport(ST_WIN_ALL);
-    const StPointD_t aCursorPos = getMousePos();
-    if(myVrHmd == NULL
-    || myIsBroken) {
-        return;
-    }
-
-    ovrHmdDesc anHmdDesc = ovr_GetHmdDesc(myVrHmd);
-    ovrEyeRenderDesc anEyeRenderDesc[2] = {
-        ovr_GetRenderDesc(myVrHmd, ovrEye_Left,  anHmdDesc.DefaultEyeFov[0]),
-        ovr_GetRenderDesc(myVrHmd, ovrEye_Right, anHmdDesc.DefaultEyeFov[1])
-    };
-    ovrViewScaleDesc aViewScaleDesc;
-    aViewScaleDesc.HmdSpaceToWorldScaleInMeters = 1.0f;
-    aViewScaleDesc.HmdToEyeViewOffset[0] = anEyeRenderDesc[0].HmdToEyeViewOffset;
-    aViewScaleDesc.HmdToEyeViewOffset[1] = anEyeRenderDesc[1].HmdToEyeViewOffset;
-
-    const StGLBoxPx aViewPortL = {{ 0, 0,
-                                    myVrRendSizeX, myVrRendSizeY }};
-    const StGLBoxPx aViewPortR = {{ myVrRendSizeX, 0,
-                                    myVrRendSizeX, myVrRendSizeY }};
-
-    ovrLayerEyeFov aLayerFov;
-    aLayerFov.Header.Type       = ovrLayerType_EyeFov;
-    aLayerFov.Header.Flags      = ovrLayerFlag_TextureOriginAtBottomLeft;
-    aLayerFov.ColorTexture[0]   = myOvrSwapTexture;
-    aLayerFov.ColorTexture[1]   = NULL;
-    aLayerFov.Viewport[0].Pos.x = aViewPortL.x();
-    aLayerFov.Viewport[0].Pos.y = aViewPortL.y();
-    aLayerFov.Viewport[0].Size.w= aViewPortL.width();
-    aLayerFov.Viewport[0].Size.h= aViewPortL.height();
-    aLayerFov.Viewport[1].Pos.x = aViewPortR.x();
-    aLayerFov.Viewport[1].Pos.y = aViewPortR.y();
-    aLayerFov.Viewport[1].Size.w= aViewPortR.width();
-    aLayerFov.Viewport[1].Size.h= aViewPortR.height();
-    aLayerFov.Fov[0]            = anHmdDesc.DefaultEyeFov[0];
-    aLayerFov.Fov[1]            = anHmdDesc.DefaultEyeFov[1];
-    aLayerFov.SensorSampleTime  = ovr_GetTimeInSeconds();
-    const double aPredictedTime = ovr_GetPredictedDisplayTime(myVrHmd, 0);
-    ovrTrackingState anHmdState = ovr_GetTrackingState(myVrHmd, aPredictedTime, ovrTrue);
-    ovr_CalcEyePoses(anHmdState.HeadPose.ThePose, aViewScaleDesc.HmdToEyeViewOffset, aLayerFov.RenderPose);
-    myVrOrient = StQuaternion<double>((double )aLayerFov.RenderPose[0].Orientation.x,
-                                      (double )aLayerFov.RenderPose[0].Orientation.y,
-                                      (double )aLayerFov.RenderPose[0].Orientation.z,
-                                      (double )aLayerFov.RenderPose[0].Orientation.w);
-
-    // draw Left View into virtual frame buffer
-    myContext->stglResizeViewport(aViewPortL);
-    myContext->stglSetScissorRect(aViewPortL, false);
-    myContext->stglBindFramebuffer(myOvrSwapFbo[myOvrSwapTexture->CurrentIndex]);
-    StWindow::signals.onRedraw(ST_DRAW_LEFT);
-    stglDrawCursor(aCursorPos, ST_DRAW_LEFT);
-
-    // draw Right View into virtual frame buffer
-    myContext->stglResizeViewport(aViewPortR);
-    myContext->stglSetScissorRect(aViewPortR, false);
-    StWindow::signals.onRedraw(ST_DRAW_RIGHT);
-    stglDrawCursor(aCursorPos, ST_DRAW_RIGHT);
-    myContext->stglBindFramebuffer(StGLFrameBuffer::NO_FRAMEBUFFER);
-
-    ovrLayerHeader* aLayers = &aLayerFov.Header;
-    ovrResult anOvrRes = ovr_SubmitFrame(myVrHmd, 0, &aViewScaleDesc, &aLayers, 1);
-    myOvrSwapTexture->CurrentIndex = myOvrSwapTexture->CurrentIndex == 0 ? 1 : 0;
-    if(!OVR_SUCCESS(anOvrRes)) {
-        myMsgQueue->pushError(stCString("StOutDistorted, Failed to submit swap texture!"));
-        myIsBroken = true;
-    }
-
-    myContext->stglResizeViewport(aVPBoth);
-    myContext->stglResetScissorRect();
-    myContext->core20fwd->glClear(GL_COLOR_BUFFER_BIT | GL_DEPTH_BUFFER_BIT);
-
-    myContext->stglBindFramebufferRead(myOvrMirrorFbo);
-    myContext->stglBindFramebufferDraw(StGLFrameBuffer::NO_FRAMEBUFFER);
-    GLint aSrcSizeX = myOvrMirrorTexture->OGL.Header.TextureSize.w;
-    GLint aSrcSizeY = myOvrMirrorTexture->OGL.Header.TextureSize.h;
-    myContext->arbFbo->glBlitFramebuffer(0, aSrcSizeY, aSrcSizeX, 0,
-                                         0, 0, aVPBoth.width(), aVPBoth.height(),
-                                         GL_COLOR_BUFFER_BIT, GL_NEAREST);
-    myContext->stglBindFramebufferRead(StGLFrameBuffer::NO_FRAMEBUFFER);
-
-    myFPSControl.sleepToTarget(); // decrease FPS to target by thread sleeps
-    StWindow::stglSwap(ST_WIN_ALL);
-    ++myFPSControl;
 #endif
 }
 
@@ -1060,9 +931,8 @@
 
     double aForcedAspect = -1.0;
     if(isHmdOutput()) {
-        if(myVrRendSizeX != 0 && myVrRendSizeY != 0) {
-            aForcedAspect = double(myVrRendSizeX) / double(myVrRendSizeY);
-        }
+        //if(myVrRendSize.x() != 0 && myVrRendSize.y() != 0) { aForcedAspect = double(myVrRendSize.x()) / double(myVrRendSize.y()); }
+        aForcedAspect = myVrAspectRatio;
     }
 
     StWinSplit aWinSplit = StWinSlave_splitOff;
@@ -1117,7 +987,7 @@
         return;
     }
 
-#if defined(ST_HAVE_OPENVR) || defined(ST_HAVE_LIBOVR)
+#if defined(ST_HAVE_OPENVR)
     if(myVrHmd != NULL
     && !myIsBroken) {
         stglDrawVR();

sview-17_04.tar.gz/StOutDistorted/StOutDistorted.h -> sview-20_08.tar.gz/StOutDistorted/StOutDistorted.h Changed

@@ -1,6 +1,6 @@
 /**
  * StOutDistorted, class providing stereoscopic output in anamorph side by side format using StCore toolkit.
- * Copyright © 2013-2017 Kirill Gavrilov <kirill@sview.ru>
+ * Copyright © 2013-2020 Kirill Gavrilov <kirill@sview.ru>
  *
  * Distributed under the Boost Software License, Version 1.0.
  * See accompanying file license-boost.txt or copy at
@@ -28,10 +28,6 @@
     struct TrackedDevicePose_t;
 }
 
-typedef struct ovrHmdStruct* ovrSession;
-typedef union ovrGLTexture_s ovrGLTexture;
-typedef struct ovrSwapTextureSet_ ovrSwapTextureSet;
-
 /**
  * This class implements stereoscopic rendering on displays
  * which require software distortion correction.
@@ -131,10 +127,15 @@
     ST_CPPEXPORT virtual void stglDraw() ST_ATTR_OVERRIDE;
 
     /**
+    * Get viewport for specified subwindow.
+    */
+    ST_CPPEXPORT virtual StGLBoxPx stglViewport(const int theWinEnum) const ST_ATTR_OVERRIDE;
+
+    /**
      * Show/Hide mouse cursor.
      * @param theToShow true to show cursor
      */
-    ST_CPPEXPORT virtual void showCursor(const bool theToShow);
+    ST_CPPEXPORT virtual void showCursor(const bool theToShow) ST_ATTR_OVERRIDE;
 
     /**
      * Return true if device has orientation sensor.
@@ -157,6 +158,11 @@
     ST_CPPEXPORT virtual StQuaternion<double> getDeviceOrientation() const ST_ATTR_OVERRIDE;
 
     /**
+     * Return custom stereo projection frustums.
+     */
+    ST_CPPEXPORT virtual bool getCustomProjection(StRectF_t& theLeft, StRectF_t& theRight) const ST_ATTR_OVERRIDE;
+
+    /**
      * Return margins for working area.
      */
     ST_CPPEXPORT virtual StMarginsI getMargins() const ST_ATTR_OVERRIDE;
@@ -173,6 +179,11 @@
      */
     ST_LOCAL virtual void doChangeLanguage() ST_ATTR_OVERRIDE { updateStrings(); }
 
+    /**
+     * Return HMD framerate.
+     */
+    ST_LOCAL virtual float getMaximumTargetFps() const ST_ATTR_OVERRIDE;
+
         private:
 
     /**
@@ -214,6 +225,11 @@
             && myDevice == DEVICE_HMD;
     }
 
+    /**
+     * Retrieve active head position.
+     */
+    ST_LOCAL void updateVRProjectionFrustums();
+
         private:
 
     static StAtomic<int32_t> myInstancesNb; //!< shared counter for all instances
@@ -287,8 +303,13 @@
     double                    myVrMarginsBottom;
     double                    myVrMarginsLeft;
     double                    myVrMarginsRight;
-    int                       myVrRendSizeX;     //!< FBO width  for rendering into VR (can be greater then actual HMD resolution to compensate distortion)
-    int                       myVrRendSizeY;     //!< FBO height for rendering into VR
+    StRectF_t                 myVrFrustumL;      //!< projection frustum for the left eye
+    StRectF_t                 myVrFrustumR;      //!< projection frustum for the right eye
+    StVec2<int>               myVrRendSize;      //!< FBO width x height for rendering into VR (can be greater then actual HMD resolution to compensate distortion)
+    float                     myVrFrequency;     //!< display frequency
+    float                     myVrAspectRatio;   //!< aspect ratio
+    float                     myVrFieldOfView;   //!< field of view
+    float                     myVrIOD;           //!< intra-ocular distance in meters
     bool                      myVrTrackOrient;   //!< track orientation flag
     bool                      myVrToDrawMsg;
     StHandle<StGLTextureQuad> myVrFullscreenMsg;
@@ -296,12 +317,6 @@
 #ifdef ST_HAVE_OPENVR
     vr::IVRSystem*            myVrHmd;           //!< OpenVR session object
     vr::TrackedDevicePose_t*  myVrTrackedPoses;  //!< array of tracked devices poses
-#elif defined(ST_HAVE_LIBOVR)
-    ovrSession                myVrHmd;
-    ovrSwapTextureSet*        myOvrSwapTexture;
-    GLuint                    myOvrSwapFbo[2];
-    ovrGLTexture*             myOvrMirrorTexture;
-    GLuint                    myOvrMirrorFbo;
 #endif
 
     bool                      myToShowCursor;    //!< cursor visibility flag

sview-17_04.tar.gz/StOutDistorted/StOutDistorted.rc -> sview-20_08.tar.gz/StOutDistorted/StOutDistorted.rc Changed

sview-20_08.tar.gz/StOutDistorted/lang/spanish Added

sview-20_08.tar.gz/StOutDistorted/lang/spanish/StOutDistorted.lng Added

sview-17_04.tar.gz/StOutDual/StOutDual.cpp -> sview-20_08.tar.gz/StOutDual/StOutDual.cpp Changed

sview-17_04.tar.gz/StOutDual/StOutDual.rc -> sview-20_08.tar.gz/StOutDual/StOutDual.rc Changed

sview-20_08.tar.gz/StOutDual/lang/spanish Added

sview-20_08.tar.gz/StOutDual/lang/spanish/StOutDual.lng Added

sview-17_04.tar.gz/StOutIZ3D/StOutIZ3D.cpp -> sview-20_08.tar.gz/StOutIZ3D/StOutIZ3D.cpp Changed

sview-17_04.tar.gz/StOutIZ3D/StOutIZ3D.rc -> sview-20_08.tar.gz/StOutIZ3D/StOutIZ3D.rc Changed

sview-20_08.tar.gz/StOutIZ3D/lang/spanish Added

sview-20_08.tar.gz/StOutIZ3D/lang/spanish/StOutIZ3D.lng Added

sview-17_04.tar.gz/StOutInterlace/StOutInterlace.cpp -> sview-20_08.tar.gz/StOutInterlace/StOutInterlace.cpp Changed

@@ -20,6 +20,8 @@
 #include <StImage/StImagePlane.h>
 #include <StVersion.h>
 
+#include <fstream>
+
 namespace {
 
     static const char ST_OUT_PLUGIN_NAME[] = "StOutInterlace";
@@ -35,24 +37,40 @@
     struct StMonInterlacedInfo_t {
         const stUtf8_t* pnpid;
         bool            isReversed;
+        bool            isRowInterlaced;
     };
 
     /**
      * Database of known interlaced monitors.
      */
     static const StMonInterlacedInfo_t THE_KNOWN_MONITORS[] = {
-        {"ZMT1900", false}, // Zalman Trimon M190S
-        {"ZMT2200", false}, // Zalman Trimon M220W
-        {"ENV2373", true }, // Envision
-        {"HIT8002", false}, // Hyundai W220S D-Sub
-        {"HIT8D02", false}, // Hyundai W220S DVID
-        {"HIT7003", false}, // Hyundai W240S D-Sub
-        {"HIT7D03", false}, // Hyundai W240S D-Sub
-      //{"ACI23C2", false}, // ASUS VG23AH
-        {"ACI27C2", false}, // ASUS VG27AH
-        {       "", false}  // NULL-terminate array
+        {"ZMT1900", false, true}, // Zalman Trimon M190S
+        {"ZMT2200", false, true}, // Zalman Trimon M220W
+        {"ENV2373", true , true}, // Envision
+        {"HIT8002", false, true}, // Hyundai W220S D-Sub
+        {"HIT8D02", false, true}, // Hyundai W220S DVID
+        {"HIT7003", false, true}, // Hyundai W240S D-Sub
+        {"HIT7D03", false, true}, // Hyundai W240S D-Sub
+        {"ACI23D3", false, true}, // ASUS VG23AH
+        {"ACI27C2", false, true}, // ASUS VG27AH
+        //
+        {"ST@COL0", false, false}, // Android devices with parallel barrier (column-interleaved)
+        {       "", false, false}  // NULL-terminate array
     };
 
+#if defined(__ANDROID__)
+    // Truly / Freevi / Commander  activation
+    namespace mi3d_tn {
+        static const char* CTRL_FILE = "/dev/mi3d_tn_ctrl";
+        enum {
+            SET_TN_OFF           =  16,
+            SET_VERTICAL_TN_ON   =  32,
+            SET_HORIZONTAL_TN_ON =  64,
+            GET_TN_STATUS        = 128,
+        };
+    }
+#endif
+
     // translation resources
     enum {
         STTR_HINTERLACE_NAME    = 1000,
@@ -87,6 +105,24 @@
     static const StGLVarLocation ST_VATTRIB_VERTEX(0);
     static const StGLVarLocation ST_VATTRIB_TCOORD(1);
 
+    inline bool isInterlacedMonitor(const StMonitor& theMon,
+                                    bool&            theIsReversed,
+                                    bool&            theIsRowInterlaced) {
+        if(theMon.getPnPId().getSize() != 7) {
+            return false;
+        }
+        for(size_t anIter = 0;; ++anIter) {
+            const StMonInterlacedInfo_t& aMon = THE_KNOWN_MONITORS[anIter];
+            if(aMon.pnpid[0] == '\0') {
+                return false;
+            } else if(stAreEqual(aMon.pnpid, theMon.getPnPId().toCString(), 7)) {
+                theIsReversed      = aMon.isReversed;
+                theIsRowInterlaced = aMon.isRowInterlaced;
+                return true;
+            }
+        }
+    }
+
 }
 
 StProgramFB::StProgramFB(const StString& theTitle)
@@ -116,27 +152,12 @@
 
 StAtomic<int32_t> StOutInterlace::myInstancesNb(0);
 
-inline bool isInterlacedMonitor(const StMonitor& theMon,
-                                bool&            theIsReversed) {
-    if(theMon.getPnPId().getSize() != 7) {
-        return false;
-    }
-    for(size_t anIter = 0;; ++anIter) {
-        const StMonInterlacedInfo_t& aMon = THE_KNOWN_MONITORS[anIter];
-        if(aMon.pnpid[0] == '\0') {
-            return false;
-        } else if(stAreEqual(aMon.pnpid, theMon.getPnPId().toCString(), 7)) {
-            theIsReversed = aMon.isReversed;
-            return true;
-        }
-    }
-}
-
-StHandle<StMonitor> StOutInterlace::getHInterlaceMonitor(const StArrayList<StMonitor>& theMonitors,
-                                                         bool& theIsReversed) {
+StHandle<StMonitor> StOutInterlace::getInterlacedMonitor(const StArrayList<StMonitor>& theMonitors,
+                                                         bool& theIsReversed,
+                                                         bool& theIsRowInterlaced) {
     for(size_t aMonIter = 0; aMonIter < theMonitors.size(); ++aMonIter) {
         const StMonitor& aMon = theMonitors[aMonIter];
-        if(isInterlacedMonitor(aMon, theIsReversed)) {
+        if(isInterlacedMonitor(aMon, theIsReversed, theIsRowInterlaced)) {
             return new StMonitor(aMon);
         }
     }
@@ -153,11 +174,12 @@
 
 const char* StOutInterlace::getDeviceId() const {
     switch(myDevice) {
-        case DEVICE_COL_INTERLACED:    return "Col";
-        case DEVICE_CHESSBOARD:        return "Chess";
-        case DEVICE_ROW_INTERLACED_ED: return "RowED";
+        case DEVICE_COL_INTERLACED:      return "Col";
+        case DEVICE_COL_INTERLACED_MI3D: return "ColMI3D";
+        case DEVICE_CHESSBOARD:          return "Chess";
+        case DEVICE_ROW_INTERLACED_ED:   return "RowED";
         case DEVICE_ROW_INTERLACED:
-        default:                       return "Row";
+        default:                         return "Row";
     }
 }
 
@@ -166,6 +188,8 @@
         myDevice = DEVICE_ROW_INTERLACED;
     } else if(theDevice == "Col") {
         myDevice = DEVICE_COL_INTERLACED;
+    } else if(theDevice == "ColMI3D") {
+        myDevice = DEVICE_COL_INTERLACED_MI3D;
     } else if(theDevice == "Chess") {
         myDevice = DEVICE_CHESSBOARD;
     } else if(theDevice == "RowED") {
@@ -176,6 +200,9 @@
 
 void StOutInterlace::getDevices(StOutDevicesList& theList) const {
     for(size_t anIter = 0; anIter < myDevices.size(); ++anIter) {
+        if(myDevices[anIter]->Priority == ST_DEVICE_SUPPORT_IGNORE) {
+            continue;
+        }
         theList.add(myDevices[anIter]);
     }
 }
@@ -194,12 +221,13 @@
     myDevices[DEVICE_ROW_INTERLACED]   ->Desc = aLangMap.changeValueId(STTR_HINTERLACE_DESC,    "Row interlaced displays: Zalman, Hyundai,...");
     myDevices[DEVICE_COL_INTERLACED]   ->Name = aLangMap.changeValueId(STTR_VINTERLACE_NAME,    "Column Interlaced");
     myDevices[DEVICE_COL_INTERLACED]   ->Desc = aLangMap.changeValueId(STTR_VINTERLACE_DESC,    "Column interlaced displays");
-#if !defined(__ANDROID__)
     myDevices[DEVICE_CHESSBOARD]       ->Name = aLangMap.changeValueId(STTR_CHESSBOARD_NAME,    "DLP TV (chessboard)");
     myDevices[DEVICE_CHESSBOARD]       ->Desc = aLangMap.changeValueId(STTR_CHESSBOARD_DESC,    "DLP TV (chessboard)");
     myDevices[DEVICE_ROW_INTERLACED_ED]->Name = aLangMap.changeValueId(STTR_HINTERLACE_ED_NAME, "Interlaced ED");
     myDevices[DEVICE_ROW_INTERLACED_ED]->Desc = aLangMap.changeValueId(STTR_HINTERLACE_ED_DESC, "EDimensional in interlaced mode");
-#endif
+    myDevices[DEVICE_COL_INTERLACED_MI3D]->Name = "Interlaced [MI3D]";
+    myDevices[DEVICE_COL_INTERLACED_MI3D]->Desc = "Interlaced display with parallel barrier";
+
     params.ToReverse->setName(aLangMap.changeValueId(STTR_PARAMETER_REVERSE,  "Reverse Order"));
     params.BindToMon->setName(aLangMap.changeValueId(STTR_PARAMETER_BIND_MON, "Bind To Supported Monitor"));
     params.ToUseMask->setName(aLangMap.changeValueId(STTR_PARAMETER_USE_MASK, "Use texture mask (compatibility)"));
@@ -210,7 +238,7 @@
     StString& aDescr     = aLangMap.changeValueId(STTR_PLUGIN_DESCRIPTION,
         "(C) {0} Kirill Gavrilov <{1}>\nOfficial site: {2}\n\nThis library is distributed under LGPL3.0");
     myAbout = aTitle + '\n' + aVerString + " " + StVersionInfo::getSDKVersionString() + "\n \n"
-            + aDescr.format("2009-2017", "kirill@sview.ru", "www.sview.ru");
+            + aDescr.format("2009-2020", "kirill@sview.ru", "www.sview.ru");
 }
 
 StOutInterlace::StOutInterlace(const StHandle<StResourceManager>& theResMgr,
@@ -222,6 +250,7 @@
   myTexMaskDevice(DEVICE_AUTO),
   myTexMaskReversed(false),
   myDevice(DEVICE_AUTO),
+  myBarrierState(BarrierState_Unknown),
   myEDTimer(true),
   myEDIntelaceOn(new StGLProgram("ED Interlace On")),
   myEDOff(new StGLProgram("ED Interlace Off")),
@@ -249,11 +278,13 @@
     myGlPrograms[DEVICE_COL_INTERLACED]       = new StProgramFB("Column Interlace");
     myGlPrograms[DEVICE_CHESSBOARD]           = new StProgramFB("Chessboard");
     myGlPrograms[DEVICE_ROW_INTERLACED_ED]    = myGlPrograms[DEVICE_ROW_INTERLACED];
+    myGlPrograms[DEVICE_COL_INTERLACED_MI3D]  = myGlPrograms[DEVICE_COL_INTERLACED];
 
-    myGlProgramsRev[DEVICE_ROW_INTERLACED]    = new StProgramFB("Row Interlace Inversed");
-    myGlProgramsRev[DEVICE_COL_INTERLACED]    = new StProgramFB("Column Interlace Inversed");
-    myGlProgramsRev[DEVICE_CHESSBOARD]        = new StProgramFB("Chessboard Inversed");
-    myGlProgramsRev[DEVICE_ROW_INTERLACED_ED] = myGlProgramsRev[DEVICE_ROW_INTERLACED];
+    myGlProgramsRev[DEVICE_ROW_INTERLACED]      = new StProgramFB("Row Interlace Inversed");
+    myGlProgramsRev[DEVICE_COL_INTERLACED]      = new StProgramFB("Column Interlace Inversed");
+    myGlProgramsRev[DEVICE_CHESSBOARD]          = new StProgramFB("Chessboard Inversed");
+    myGlProgramsRev[DEVICE_ROW_INTERLACED_ED]   = myGlProgramsRev[DEVICE_ROW_INTERLACED];
+    myGlProgramsRev[DEVICE_COL_INTERLACED_MI3D] = myGlProgramsRev[DEVICE_COL_INTERLACED];
 
     myGlProgramMask = new StProgramFB("Interlace Mask");
 
@@ -272,27 +303,56 @@
     aDevCol->Name     = stCString("Column Interlaced");
     myDevices.add(aDevCol);
 
-#if !defined(__ANDROID__)
     StHandle<StOutDevice> aDevChess = new StOutDevice();
     aDevChess->PluginId = ST_OUT_PLUGIN_NAME;
     aDevChess->DeviceId = stCString("Chess");
+#if defined(__ANDROID__)
+    aDevChess->Priority = ST_DEVICE_SUPPORT_IGNORE;
+#else
     aDevChess->Priority = ST_DEVICE_SUPPORT_NONE;
+#endif
     aDevChess->Name     = stCString("DLP TV (chessboard)");
     myDevices.add(aDevChess);
 
     StHandle<StOutDevice> aDevED = new StOutDevice();
     aDevED->PluginId = ST_OUT_PLUGIN_NAME;
     aDevED->DeviceId = stCString("RowED");
+#if defined(__ANDROID__)
+    aDevED->Priority = ST_DEVICE_SUPPORT_IGNORE;
+#else
     aDevED->Priority = ST_DEVICE_SUPPORT_NONE;
+#endif
     aDevED->Name     = stCString("Interlaced ED");
     myDevices.add(aDevED);
+
+    StHandle<StOutDevice> aDevMI3D = new StOutDevice();
+    aDevMI3D->PluginId = ST_OUT_PLUGIN_NAME;
+    aDevMI3D->DeviceId = stCString("ColMI3D");
+    aDevMI3D->Priority = ST_DEVICE_SUPPORT_IGNORE;
+#if defined(__ANDROID__)
+    {
+        std::fstream aCtrlFile;
+        aCtrlFile.open(mi3d_tn::CTRL_FILE, std::ios_base::in);
+        if(aCtrlFile.is_open()) {
+            aCtrlFile.close();
+            aDevMI3D->Priority = ST_DEVICE_SUPPORT_PREFER;
+            setBarrierState(BarrierState_Off);
+        }
+    }
 #endif
+    aDevMI3D->Name = stCString("Interlaced [MI3D]");
+    myDevices.add(aDevMI3D);
 
     // detect connected displays
-    bool isDummyReversed= false;
-    StHandle<StMonitor> aMonInterlaced = StOutInterlace::getHInterlaceMonitor(aMonitors, isDummyReversed);
+    bool isDummyReversed = false;
+    bool isRowInterlaced = false;
+    StHandle<StMonitor> aMonInterlaced = getInterlacedMonitor(aMonitors, isDummyReversed, isRowInterlaced);
     if(!aMonInterlaced.isNull()) {
-        aDevRow->Priority = ST_DEVICE_SUPPORT_PREFER;
+        if(isRowInterlaced) {
+            aDevRow->Priority = ST_DEVICE_SUPPORT_PREFER;
+        } else {
+            aDevCol->Priority = ST_DEVICE_SUPPORT_PREFER;
+        }
     }
 
     // options
@@ -316,7 +376,7 @@
         StMonitor aMonitor = aMonitors[aRect.center()];
         if(params.BindToMon->getValue()
         && !aMonInterlaced.isNull()
-        && !isInterlacedMonitor(aMonitor, isDummyReversed)) {
+        && !isInterlacedMonitor(aMonitor, isDummyReversed, isRowInterlaced)) {
             aMonitor = *aMonInterlaced;
         }
         if(isLoadedPosition) {
@@ -340,12 +400,14 @@
     if(!aMonInterlaced.isNull()) {
         myIsMonReversed = false;
         StMonitor aMonitor = aMonitors[StWindow::getPlacement().center()];
-        isInterlacedMonitor(aMonitor, myIsMonReversed);
+        isInterlacedMonitor(aMonitor, myIsMonReversed, isRowInterlaced);
     }
 
     // load device settings
     mySettings->loadInt32(ST_SETTING_DEVICE_ID, myDevice);
-    if(myDevice == DEVICE_AUTO) {
+    if(myDevice == DEVICE_AUTO
+    || myDevice >= (int )myDevices.size()
+    || myDevices[myDevice]->Priority == ST_DEVICE_SUPPORT_IGNORE) {
         myDevice = DEVICE_ROW_INTERLACED;
     }
 
@@ -387,6 +449,35 @@
     releaseResources();
 }
 
+void StOutInterlace::setBarrierState(BarrierState theBarrierState) {
+    if(myBarrierState == theBarrierState) {
+        return;
+    }
+
+    myBarrierState = theBarrierState;
+#if defined(__ANDROID__)
+    unsigned char aValue = mi3d_tn::SET_TN_OFF;
+    switch(myBarrierState) {
+        case BarrierState_Unknown:
+        case BarrierState_Off:
+            aValue = mi3d_tn::SET_TN_OFF;
+            break;
+        case BarrierState_Landscape:
+            aValue = mi3d_tn::SET_VERTICAL_TN_ON;
+            break;
+        case BarrierState_Portrait:
+            aValue = mi3d_tn::SET_HORIZONTAL_TN_ON;
+            break;
+    }
+    std::fstream aCtrlFile;
+    aCtrlFile.open(mi3d_tn::CTRL_FILE);
+    if(aCtrlFile.is_open()) {
+        aCtrlFile << aValue;
+        aCtrlFile.close();
+    }
+#endif
+}
+
 void StOutInterlace::close() {
     StWindow::params.VSyncMode->signals.onChanged -= stSlot(this, &StOutInterlace::doSwitchVSync);
     beforeClose();
@@ -414,6 +505,7 @@
             StThread::sleep(10);
         }
     }
+    setBarrierState(BarrierState_Off);
 }
 
 void StOutInterlace::show() {
@@ -553,15 +645,21 @@
     // discard mask texture
     StGLFragmentShader aShaderMask(myGlProgramMask->getTitle());
     StGLAutoRelease aTmp8(*myContext, aShaderMask);
-    if(!aShaderMask.init(*myContext,
-                         "uniform sampler2D uTexture;\n"
-                         "uniform sampler2D uMaskTexture;\n"
-                         "varying vec2 fTexCoord;\n"
-                         "void main(void) {\n"
-                         "  float aMask = texture2D(uMaskTexture, fTexCoord).a;\n"
-                         "  if(aMask < 0.5) { discard; }\n"
-                         "  gl_FragColor = texture2D(uTexture, fTexCoord);\n"
-                         "}\n")) {
+
+    const char* FRAGMENT_GET_ALPHA = myContext->arbTexRG
+                                   ? "#define stTextureAlpha(theSampler, theCoords) texture2D(theSampler, theCoords).r\n"
+                                   : "#define stTextureAlpha(theSampler, theCoords) texture2D(theSampler, theCoords).a\n";
+    const StString aMaskProgram = StString() + FRAGMENT_GET_ALPHA
+     + "uniform sampler2D uTexture;\n"
+       "uniform sampler2D uMaskTexture;\n"
+       "varying vec2 fTexCoord;\n"
+       "void main(void) {\n"
+       "  float aMask = stTextureAlpha(uMaskTexture, fTexCoord);\n"
+       "  if(aMask < 0.5) { discard; }\n"
+       "  gl_FragColor = texture2D(uTexture, fTexCoord);\n"
+       "}\n";
+
+    if(!aShaderMask.init(*myContext, aMaskProgram.toCString())) {
         myMsgQueue->pushError(aShadersError);
         myIsBroken = true;
         return true;
@@ -644,7 +742,8 @@
     // note that this enumeration is not enough to handle rotation direction,
     // which is required to automatically swap lines/columns order)
     myIsMonPortrait = aMon.getOrientation() == StMonitor::Orientation_Portrait;
-    isInterlacedMonitor(aMon, myIsMonReversed);
+    bool isRowInterlaced;
+    isInterlacedMonitor(aMon, myIsMonReversed, isRowInterlaced);
 }
 
 void StOutInterlace::processEvents() {
@@ -713,6 +812,7 @@
                     }
                     break;
                 }
+                case DEVICE_COL_INTERLACED_MI3D:
                 case DEVICE_COL_INTERLACED: {
                     if(theToReverse) {
                         *aPixel = (aColIter % 2 == 0) ? 255 : 0;
@@ -738,6 +838,11 @@
         }
     }
 
+    const GLint aTexFormat = myContext->arbTexRG ? GL_R8 : GL_ALPHA;
+    if(myTextureMask->getTextureFormat() != aTexFormat) {
+        myTextureMask->setTextureFormat(aTexFormat);
+    }
+
     if(!myTextureMask->init(*myContext, anImage)) {
         myMsgQueue->pushError(stCString("Interlace output - critical error:\nMask texture resize failed!"));
         myIsBroken = true;
@@ -808,6 +913,16 @@
     myContext->stglResizeViewport(aVPort);
     StWindow::signals.onRedraw(ST_DRAW_LEFT);
 
+    if(myIsFirstDraw) {
+        myIsFirstDraw = false;
+
+        // fall-back on known problematic devices
+        const StString aGlRenderer((const char* )myContext->core11fwd->glGetString(GL_RENDERER));
+        if(aGlRenderer.isContains(stCString("PowerVR Rogue G6200"))) {
+            params.ToUseMask->setValue(true);
+        }
+    }
+
     if(!StWindow::isStereoOutput() || myIsBroken) {
         if(myToCompressMem) {
             myFrmBuffer->release(*myContext);
@@ -827,6 +942,8 @@
                 }
             }
             stglDrawEDCodes();
+        } else if(myDevice == DEVICE_COL_INTERLACED_MI3D) {
+            setBarrierState(BarrierState_Off);
         }
 
         // decrease FPS to target by thread sleeps
@@ -836,16 +953,6 @@
         return;
     }
 
-    if(myIsFirstDraw) {
-        myIsFirstDraw = false;
-
-        // fall-back on known problematic devices
-        const StString aGlRenderer((const char* )myContext->core11fwd->glGetString(GL_RENDERER));
-        if(aGlRenderer.isContains(stCString("PowerVR Rogue G6200"))) {
-            params.ToUseMask->setValue(true);
-        }
-    }
-
     // reverse L/R according to window position
     bool isPixelReverse = false;
     const StRectI_t aWinRect = StWindow::getPlacement();
@@ -866,7 +973,9 @@
     int aDevice = myDevice;
 
     // handle portrait orientation
-    if(myIsMonPortrait) {
+    if(myDevice == DEVICE_COL_INTERLACED_MI3D) {
+        aDevice = DEVICE_COL_INTERLACED;
+    } else if(myIsMonPortrait) {
         switch(myDevice) {
             case DEVICE_ROW_INTERLACED:
                 aDevice = DEVICE_COL_INTERLACED;
@@ -892,6 +1001,7 @@
         switch(aDevice) {
             case DEVICE_CHESSBOARD:
             case DEVICE_COL_INTERLACED:
+            case DEVICE_COL_INTERLACED_MI3D:
                 isPixelReverse = !isPixelReverse; break;
         }
     }
@@ -977,6 +1087,8 @@
             }
         }
         stglDrawEDCodes();
+    } else if(myDevice == DEVICE_COL_INTERLACED_MI3D) {
+        setBarrierState(myIsMonPortrait ? BarrierState_Portrait : BarrierState_Landscape);
     }
 
     // decrease FPS to target by thread sleeps
@@ -1003,12 +1115,13 @@
     const StSearchMonitors& aMonitors = StWindow::getMonitors();
     StRectI_t aRect = StWindow::getPlacement();
     StMonitor aMon  = aMonitors[aRect.center()];
-    if(isInterlacedMonitor(aMon, myIsMonReversed)
+    bool isRowInterlaced = false;
+    if(isInterlacedMonitor(aMon, myIsMonReversed, isRowInterlaced)
     || !isMovable()) {
         return;
     }
 
-    StHandle<StMonitor> anInterlacedMon = StOutInterlace::getHInterlaceMonitor(aMonitors, myIsMonReversed);
+    StHandle<StMonitor> anInterlacedMon = getInterlacedMonitor(aMonitors, myIsMonReversed, isRowInterlaced);
     if(anInterlacedMon.isNull()) {
         return;
     }

sview-17_04.tar.gz/StOutInterlace/StOutInterlace.h -> sview-20_08.tar.gz/StOutInterlace/StOutInterlace.h Changed

@@ -118,19 +118,24 @@
         private:
 
     enum {
-        DEVICE_AUTO              =-1,
-        DEVICE_ROW_INTERLACED    = 0, //!< interlace (horizontal 1xPixel lines, full color from R or L)
-        DEVICE_COL_INTERLACED    = 1, //!< interlace (vertical 1xPixel lines, full color from R or L)
-        DEVICE_CHESSBOARD        = 2, //!< 1xPixel chessboard (some DLP devices)
-        DEVICE_ROW_INTERLACED_ED = 3, //!< interlace (horizontal 1xPixel lines) + EDimensional onscreen codes
+        DEVICE_AUTO                =-1,
+        DEVICE_ROW_INTERLACED      = 0, //!< interlace (horizontal 1xPixel lines, full color from R or L)
+        DEVICE_COL_INTERLACED      = 1, //!< interlace (vertical 1xPixel lines, full color from R or L)
+        DEVICE_CHESSBOARD          = 2, //!< 1xPixel chessboard (some DLP devices)
+        DEVICE_ROW_INTERLACED_ED   = 3, //!< interlace (horizontal 1xPixel lines) + EDimensional onscreen codes
+        DEVICE_COL_INTERLACED_MI3D = 4, //!< interlace with barrier
 
         DEVICE_NB,
     };
 
         private:
 
-    ST_LOCAL static StHandle<StMonitor> getHInterlaceMonitor(const StArrayList<StMonitor>& theMonitors,
-                                                             bool& theIsReversed);
+    /**
+     * Look for interlaced monitors within the given list.
+     */
+    ST_LOCAL static StHandle<StMonitor> getInterlacedMonitor(const StArrayList<StMonitor>& theMonitors,
+                                                             bool& theIsReversed,
+                                                             bool& theIsRowInterlaced);
 
     ST_LOCAL void stglDrawEDCodes();
 
@@ -181,6 +186,21 @@
 
     } params;
 
+    /**
+     * Parallax barrier state.
+     */
+    enum BarrierState {
+        BarrierState_Unknown = -1,
+        BarrierState_Off     = 0,
+        BarrierState_Landscape,
+        BarrierState_Portrait,
+    };
+
+    /**
+     * Initialize parallax barrier state.
+     */
+    void setBarrierState(BarrierState theBarrierState);
+
         private:
 
     StOutDevicesList          myDevices;
@@ -200,6 +220,7 @@
     StGLVertexBuffer          myQuadTexCoordBuf;
     int                       myDevice;
     StHandle<StMonitor>       myMonitor;                  //!< current monitor
+    BarrierState              myBarrierState;
 
     StRectI_t                 myWinRect;
     StRectI_t                 myEDRect;

sview-17_04.tar.gz/StOutInterlace/StOutInterlace.rc -> sview-20_08.tar.gz/StOutInterlace/StOutInterlace.rc Changed

sview-20_08.tar.gz/StOutInterlace/lang/spanish Added

sview-20_08.tar.gz/StOutInterlace/lang/spanish/StOutInterlace.lng Added

sview-17_04.tar.gz/StOutPageFlip/StDXNVWindow.cpp -> sview-20_08.tar.gz/StOutPageFlip/StDXNVWindow.cpp Changed

@@ -112,19 +112,22 @@
                                       LPARAM theParamL) {
     // we do stupid checks here...
     if(myStWin->isFullScreen() && myStWin->isStereoOutput()) {
-        if(theMsg == WM_MOUSEWHEEL) {
-            int zDelta = GET_WHEEL_DELTA_WPARAM(theParamW);
+        if(theMsg == WM_MOUSEWHEEL
+        || theMsg == WM_MOUSEHWHEEL) {
+            const bool  isVert   = (theMsg == WM_MOUSEWHEEL);
+            const int   aZDelta  = GET_WHEEL_DELTA_WPARAM(theParamW);
+            const int   aNbSteps = (aZDelta > 0) ? 1 : -1;
+            const float aDeltaSt = float(aZDelta) / float(WHEEL_DELTA);
             const StPointD_t aPnt = myStWin->getMousePos();
             StEvent anEvent;
-            anEvent.Type = stEvent_Scroll;
-            anEvent.Scroll.Time   = 0.0; //getEventTime(myEvent.time);
-            anEvent.Scroll.PointX = aPnt.x();
-            anEvent.Scroll.PointY = aPnt.y();
-            anEvent.Scroll.StepsX = 0;
-            anEvent.Scroll.StepsY = (zDelta > 0) ? 1 : -1;
-            anEvent.Scroll.DeltaX = 0.0;
-            anEvent.Scroll.DeltaY = 10.0f * anEvent.Scroll.StepsY;
-            anEvent.Scroll.IsFromMultiTouch = false;
+            anEvent.Scroll.init(0.0, //getEventTime(myEvent.time);
+                                aPnt.x(),
+                                aPnt.y(),
+                                !isVert ? aDeltaSt : 0.0f,
+                                 isVert ? aDeltaSt : 0.0f,
+                                false);
+            anEvent.Scroll.StepsX = !isVert ? aNbSteps : 0;
+            anEvent.Scroll.StepsY =  isVert ? aNbSteps : 0;
             myStWin->post(anEvent);
         }

sview-17_04.tar.gz/StOutPageFlip/StOutPageFlip.cpp -> sview-20_08.tar.gz/StOutPageFlip/StOutPageFlip.cpp Changed

@@ -357,7 +357,7 @@
 
 static StMonitor getHigestFreqMonitor(const StSearchMonitors& theMonitors) {
     size_t hfreqMon = 0;
-    int hfreqMax = 0;
+    float hfreqMax = 0;
     for(size_t aMonIter = 0; aMonIter < theMonitors.size(); ++aMonIter) {
         const StMonitor& aMon = theMonitors[aMonIter];
         if(aMon.getFreqMax() > hfreqMax) {
@@ -484,7 +484,7 @@
     StString& aDescr     = myLangMap.changeValueId(STTR_PLUGIN_DESCRIPTION,
         "(C) {0} Kirill Gavrilov <{1}>\nOfficial site: {2}\n\nThis library is distributed under LGPL3.0");
     myAbout = aTitle + '\n' + aVerString + " " + StVersionInfo::getSDKVersionString() + "\n \n"
-            + aDescr.format("2007-2017", "kirill@sview.ru", "www.sview.ru");
+            + aDescr.format("2007-2020", "kirill@sview.ru", "www.sview.ru");
 }
 
 StOutPageFlip::StOutPageFlip(const StHandle<StResourceManager>& theResMgr,
@@ -617,7 +617,7 @@
     // read windowed placement
     StWindow::hide();
     if(isMovable()) {
-        StWindow::setFullScreen(false);
+        setFullScreen(false);
     }
 }
 
@@ -742,7 +742,7 @@
             // Direct3D device will fail to Reset if GL fullscreen device is active
             // so we switch out main GL window into windowed state temporarily
             // (we need to wait some time to ensure system perform needed movements)
-            StWindow::setFullScreen(false);
+            setFullScreen(false);
             StWindow::hide();
             ++myOutD3d.ActivateStep;
             return;
@@ -754,7 +754,7 @@
         if(myOutD3d.ActivateStep == 1) {
             // at second step switch out main GL window back to fullscreen
             myOutD3d.ActivateStep = 0;
-            StWindow::setFullScreen(true);
+            setFullScreen(true);
             StWindow::hide();
 
             if(myOutD3d.WglDxBuffer.isNull()
@@ -853,6 +853,9 @@
 
     // request Quad Buffer
     StWindow::setAttribute(StWinAttr_GlQuadStereo, params.QuadBuffer->getValue() == QUADBUFFER_HARD_OPENGL);
+    if (params.QuadBuffer->getValue() == QUADBUFFER_SOFT) {
+        StWindow::setAttribute(StWinAttr_ExclusiveFullScreen, true);
+    }
     if(!StWindow::create()) {
         return false;
     }

sview-17_04.tar.gz/StOutPageFlip/StOutPageFlip.rc -> sview-20_08.tar.gz/StOutPageFlip/StOutPageFlip.rc Changed

sview-17_04.tar.gz/StOutPageFlip/StOutPageFlipExt.cpp -> sview-20_08.tar.gz/StOutPageFlip/StOutPageFlipExt.cpp Changed

sview-17_04.tar.gz/StOutPageFlip/StOutPageFlipExt.h -> sview-20_08.tar.gz/StOutPageFlip/StOutPageFlipExt.h Changed

sview-17_04.tar.gz/StOutPageFlip/StQuadBufferCheck.cpp -> sview-20_08.tar.gz/StOutPageFlip/StQuadBufferCheck.cpp Changed

sview-20_08.tar.gz/StOutPageFlip/lang/spanish Added

sview-20_08.tar.gz/StOutPageFlip/lang/spanish/StOutPageFlip.lng Added

sview-17_04.tar.gz/StShared/StAVFrame.cpp -> sview-20_08.tar.gz/StShared/StAVFrame.cpp Changed

sview-17_04.tar.gz/StShared/StAVIOContext.cpp -> sview-20_08.tar.gz/StShared/StAVIOContext.cpp Changed

sview-20_08.tar.gz/StShared/StAVIOJniHttpContext.cpp Added

@@ -0,0 +1,415 @@
+/**
+ * Copyright © 2019 Kirill Gavrilov <kirill@sview.ru>
+ *
+ * Distributed under the Boost Software License, Version 1.0.
+ * See accompanying file license-boost.txt or copy at
+ * http://www.boost.org/LICENSE_1_0.txt
+ */
+
+#include <StAV/StAVIOJniHttpContext.h>
+
+#include <StStrings/StLogger.h>
+
+extern "C" {
+    #include <libavutil/error.h>
+};
+
+#if defined(__ANDROID__)
+    extern "C" {
+        #include <libavcodec/jni.h>
+    };
+    #include <android/window.h>
+    #include <jni.h>
+
+/**
+ * java.net.URLConnection wrapper.
+ */
+struct StAVIOJniHttpContext::FunctionTable {
+
+    /**
+     * Create java.nio.channels.ReadableByteChannel by opening java.net.URLConnection to specified URL.
+     * @param theJEnv   [in] attached JavaVM environment
+     * @param theUrl    [in] URL to open
+     * @param theOffset [in] file offset
+     * @param theContentLen [out] file length
+     * @return local reference to java.nio.channels.ReadableByteChannel
+     */
+    jobject createNewChannel(StJNIEnv& theJEnv,
+                             const StString& theUrl,
+                             int64_t theOffset,
+                             int64_t& theContentLen) {
+        theJEnv->ExceptionClear();
+        jobject aJInputStream = createInputStream(theJEnv, theUrl, theOffset, theContentLen);
+        if(aJInputStream == NULL) {
+            return NULL;
+        }
+        jobject aJReadChannel = theJEnv->CallStaticObjectMethod(myNioChannels_Class, myNioChannels_newChannel, aJInputStream);
+        theJEnv->DeleteLocalRef(aJInputStream);
+        return aJReadChannel;
+    }
+
+    /**
+     * Read portion of data from opened channel.
+     * @sa int java.nio.channels.ReadableByteChannel::read(java.nio.ByteBuffer theBuffer).
+     * @param theJEnv    [in] attached JavaVM environment
+     * @param theChannel [in] opened channel java.nio.channels.ReadableByteChannel
+     * @param theBuf    [out] buffer to fill
+     * @param theBufSize [in] buffer length
+     * @return amount of bytes read from channel or -1 on error/EOF; could be also 0 bytes.
+     */
+    int readChannelIntoBuffer(StJNIEnv& theJEnv,
+                              jobject theChannel,
+                              uint8_t* theBuf,
+                              int theBufSize) {
+        theJEnv->ExceptionClear();
+        jobject aJBuffer = theJEnv->NewDirectByteBuffer(theBuf, theBufSize);
+        if(aJBuffer == NULL) {
+            return -1;
+        }
+
+        int aNbReadBytes = theJEnv->CallIntMethod(theChannel, myNioReadableByteChannel_read, aJBuffer);
+        theJEnv->DeleteLocalRef(aJBuffer);
+        if(theJEnv->ExceptionCheck()) {
+            theJEnv->ExceptionClear();
+            return -1;
+        }
+        return aNbReadBytes;
+    }
+
+    /**
+     * Load functions.
+     */
+    bool load(StJNIEnv& theJEnv) {
+        if(!myjava_net_URL.load(theJEnv)) {
+            return false;
+        }
+
+        jclass aClass = theJEnv->FindClass("java/net/URLConnection");
+        if(aClass == NULL) {
+            ST_ERROR_LOG("Unable to find java.net.URLConnection class");
+            return false;
+        }
+
+        myconnect = theJEnv->GetMethodID(aClass, "connect", "()V");
+        mysetRequestProperty = theJEnv->GetMethodID(aClass, "setRequestProperty", "(Ljava/lang/String;Ljava/lang/String;)V");
+        mygetInputStream = theJEnv->GetMethodID(aClass, "getInputStream", "()Ljava/io/InputStream;");
+        mygetContentLength = theJEnv->GetMethodID(aClass, "getContentLength", "()I");
+        mygetContentLengthLong = theJEnv->GetMethodID(aClass, "getContentLengthLong", "()J");
+        if(myconnect == NULL || mysetRequestProperty == NULL || mygetInputStream == NULL || mygetContentLength == NULL) {
+            ST_ERROR_LOG("Unable to find java.net.URLConnection class methods");
+            return false;
+        }
+
+        myNioChannels_Class      = theJEnv->FindClass("java/nio/channels/Channels");
+        myNioChannels_newChannel = theJEnv->GetStaticMethodID(myNioChannels_Class, "newChannel",
+                                                              "(Ljava/io/InputStream;)Ljava/nio/channels/ReadableByteChannel;");
+        if(myNioChannels_Class == NULL
+        || myNioChannels_newChannel == NULL) {
+            ST_ERROR_LOG("Unable to find java.nio.channels.Channels class");
+            return false;
+        }
+        myNioChannels_Class = (jclass )theJEnv->NewGlobalRef(myNioChannels_Class);
+
+        jclass aNioReadableByteChannel_Class = theJEnv->FindClass("java/nio/channels/ReadableByteChannel");
+        myNioReadableByteChannel_read = aNioReadableByteChannel_Class != NULL
+                                      ? theJEnv->GetMethodID(aNioReadableByteChannel_Class, "read", "(Ljava/nio/ByteBuffer;)I")
+                                      : NULL;
+        if(myNioReadableByteChannel_read == NULL) {
+            ST_ERROR_LOG("Unable to find java.nio.channels.ReadableByteChannel class");
+            return false;
+        }
+        return true;
+    }
+
+    /**
+     * Release global references (to Java classes).
+     */
+    void release(StJNIEnv& theJEnv) {
+        myjava_net_URL.release(theJEnv);
+        if(myNioChannels_Class != NULL) {
+            theJEnv->DeleteGlobalRef(myNioChannels_Class);
+            myNioChannels_Class = NULL;
+        }
+    }
+
+        private:
+
+    /**
+     * Create java.io.InputStream by opening java.net.URLConnection to specified URL.
+     * @param theJEnv   [in] attached JavaVM environment
+     * @param theUrl    [in] URL to open
+     * @param theOffset [in] file offset
+     * @param theContentLen [out] file length
+     * @return local reference to java.io.InputStream
+     */
+    jobject createInputStream(StJNIEnv& theJEnv,
+                              const StString& theUrl,
+                              int64_t theOffset,
+                              int64_t& theContentLen) {
+        jobject aJConnection = myjava_net_URL.openConnection(theJEnv, theUrl);
+        if(aJConnection == NULL) {
+            return NULL;
+        }
+
+        if(theOffset != 0) {
+            StString anOffset = StString("bytes=") + theOffset + "-";
+            jstring aJStr_Range  = theJEnv->NewStringUTF("Range");
+            jstring aJStr_Offset = theJEnv->NewStringUTF(anOffset.toCString());
+            theJEnv->CallVoidMethod(aJConnection, mysetRequestProperty, aJStr_Range, aJStr_Offset);
+            theJEnv->DeleteLocalRef(aJStr_Range);
+            theJEnv->DeleteLocalRef(aJStr_Offset);
+        }
+        theJEnv->CallVoidMethod(aJConnection, myconnect);
+        if(theJEnv->ExceptionCheck()) {
+            ST_ERROR_LOG("Unable to open connection java.net.URLConnection '" + theUrl + "'");
+            theJEnv->ExceptionClear();
+            theJEnv->DeleteLocalRef(aJConnection);
+            return NULL;
+        }
+
+        if(mygetContentLengthLong != NULL) {
+            theContentLen = theJEnv->CallLongMethod(aJConnection, mygetContentLengthLong);
+        } else {
+            theContentLen = theJEnv->CallIntMethod(aJConnection, mygetContentLength);
+        }
+
+        jobject aJInputStream = theJEnv->CallObjectMethod(aJConnection, mygetInputStream);
+        theJEnv->DeleteLocalRef(aJConnection);
+        if(theJEnv->ExceptionCheck()) {
+            theJEnv->ExceptionClear();
+            if(aJInputStream != NULL) {
+                theJEnv->DeleteLocalRef(aJInputStream);
+                aJInputStream = NULL;
+            }
+        }
+        if(aJInputStream == NULL) {
+            ST_ERROR_LOG("Unable to create java.io.InputStream");
+        }
+        return aJInputStream;
+    }
+
+    // java.net.URL wrapper.
+    struct st_java_net_URL {
+
+        /**
+         * Load java.net.URL class and its methods.
+         */
+        bool load(StJNIEnv& theJEnv) {
+            myClass = theJEnv->FindClass("java/net/URL");
+            if(myClass == NULL) {
+                ST_ERROR_LOG("Unable to find java.net.URL class");
+                return false;
+            }
+
+            myClass = (jclass )theJEnv->NewGlobalRef(myClass);
+            myInit = theJEnv->GetMethodID(myClass, "<init>", "(Ljava/lang/String;)V");
+            myopenConnection = theJEnv->GetMethodID(myClass, "openConnection", "()Ljava/net/URLConnection;");
+            if(myInit == NULL || myopenConnection == NULL) {
+                ST_ERROR_LOG("Unable to find java.net.URL class methods");
+                release(theJEnv);
+                return false;
+            }
+            return true;
+        }
+
+        /**
+         * Release global references (to Java class).
+         */
+        void release(StJNIEnv& theJEnv) {
+            if(myClass != NULL) {
+                theJEnv->DeleteGlobalRef(myClass);
+                myClass = NULL;
+            }
+        }
+
+        /**
+         * Create java.net.URLConnection opening specified URL.
+         * Return local reference or NULL on failure.
+         */
+        jobject openConnection(StJNIEnv& theJEnv, const StString& theUrl) {
+            jobject aJNetUrl = create(theJEnv, theUrl);
+            if(aJNetUrl == NULL) {
+                ST_ERROR_LOG("Unable to create java.net.URL");
+                return NULL;
+            }
+
+            jobject aJNetUrlCon = theJEnv->CallObjectMethod(aJNetUrl, myopenConnection);
+            theJEnv->DeleteLocalRef(aJNetUrl);
+            if(theJEnv->ExceptionCheck()) {
+                theJEnv->ExceptionClear();
+                if(aJNetUrlCon != NULL) {
+                    theJEnv->DeleteLocalRef(aJNetUrlCon);
+                    aJNetUrlCon = NULL;
+                }
+            }
+            if(aJNetUrlCon == NULL) {
+                ST_ERROR_LOG("Unable to create java.net.URLConnection");
+                return NULL;
+            }
+            return aJNetUrlCon;
+        }
+
+            private:
+
+        /**
+         * Create java.net.URL class instance with specified URL; returns local reference.
+         */
+        jobject create(StJNIEnv& theJEnv, const StString& theUrl) {
+            jstring aJStr_Url = theJEnv->NewStringUTF(theUrl.toCString());
+            jobject aNetURL = theJEnv->NewObject(myClass, myInit, aJStr_Url);
+            theJEnv->DeleteLocalRef(aJStr_Url);
+            return aNetURL;
+        }
+
+            private:
+
+        jclass    myClass = NULL;
+        jmethodID myInit  = NULL;
+        jmethodID myopenConnection = NULL;
+
+    } myjava_net_URL;
+
+    // java.net.URLConnection
+    jmethodID myconnect = NULL;
+    jmethodID mysetRequestProperty = NULL;
+    jmethodID mygetInputStream = NULL;
+    jmethodID mygetContentLength = NULL;
+    jmethodID mygetContentLengthLong = NULL;
+
+    // java.nio.channels.Channels
+    jclass    myNioChannels_Class = NULL;
+    jmethodID myNioChannels_newChannel = NULL;
+
+    //java.nio.channels.ReadableByteChannel
+    //myNioReadableByteChannel_Class = NULL
+    jmethodID myNioReadableByteChannel_read = NULL;
+
+};
+#endif
+
+StAVIOJniHttpContext::StAVIOJniHttpContext()
+: myFunctions(NULL),
+#if defined(__ANDROID__)
+  myJEnv((JavaVM* )av_jni_get_java_vm(NULL)),
+#else
+  myJEnv(NULL),
+#endif
+  myReadChannel(NULL),
+  myContentLen(0),
+  myPosition(0) {
+#if defined(__ANDROID__)
+    if(!myJEnv.isNull()) {
+        myFunctions = new FunctionTable();
+        if(!myFunctions->load(myJEnv)) {
+            myFunctions->release(myJEnv);
+            myJEnv.detach();
+        }
+    }
+#endif
+}
+
+StAVIOJniHttpContext::~StAVIOJniHttpContext() {
+    close();
+    if(myFunctions != NULL) {
+    #if defined(__ANDROID__)
+        myFunctions->release(myJEnv);
+        delete myFunctions;
+    #endif
+    }
+}
+
+void StAVIOJniHttpContext::close() {
+    if(myReadChannel != NULL) {
+    #if defined(__ANDROID__)
+        myJEnv->DeleteGlobalRef((jobject )myReadChannel);
+    #endif
+        myReadChannel = NULL;
+    }
+}
+
+bool StAVIOJniHttpContext::reopenReadChannel(int64_t theOffset) {
+    if(myJEnv.isNull()) {
+        return false;
+    }
+
+#if defined(__ANDROID__)
+    if(myReadChannel != NULL) {
+        myJEnv->DeleteGlobalRef((jobject )myReadChannel);
+        myReadChannel = NULL;
+    }
+
+    /**
+     * java.net.URL anUrl = new java.net.URL(aPath);
+     * java.net.URLConnection anUrlConnection = anUrl.openConnection();
+     * anUrlConnection.setRequestProperty ("Range", "bytes="+offset+"-");
+     * anUrlConnection.connect();
+     * java.io.InputStream anInputStream = anUrlConnection.getInputStream();
+     * java.nio.channels.ReadableByteChannel aReadableByteChannel = java.nio.channels.Channels.newChannel(anInputStream);
+     */
+    jobject aJReadChannel = myFunctions->createNewChannel(myJEnv, myUrl, theOffset, myContentLen);
+    if(aJReadChannel == NULL) {
+        myReadChannel = NULL;
+        return false;
+    }
+    myReadChannel = myJEnv->NewGlobalRef(aJReadChannel);
+    myPosition = theOffset;
+    return true;
+#else
+    (void )theOffset;
+    return false;
+#endif
+}
+
+bool StAVIOJniHttpContext::open(const StString& theUrl) {
+    close();
+    myUrl = theUrl;
+    return reopenReadChannel(0);
+}
+
+int StAVIOJniHttpContext::read(uint8_t* theBuf,
+                               int      theBufSize) {
+    if(myReadChannel == NULL
+    || theBuf == NULL
+    || theBufSize <= 0) {
+        return -1;
+    }
+
+#if defined(__ANDROID__)
+    int aNbRead = myFunctions->readChannelIntoBuffer(myJEnv, (jobject )myReadChannel, theBuf, theBufSize);
+    if(aNbRead == -1) {
+        return AVERROR_EOF;
+    }
+    return aNbRead;
+#else
+    return -1;
+#endif
+}
+
+int64_t StAVIOJniHttpContext::seek(int64_t theOffset,
+                                   int     theWhence) {
+    if(myReadChannel == NULL) {
+        return -1;
+    }
+
+    switch(theWhence) {
+        case AVSEEK_SIZE: {
+            return myContentLen != 0 ? myContentLen : -1;
+        }
+        case SEEK_SET: {
+            reopenReadChannel(theOffset);
+            return myPosition;
+        }
+        case SEEK_CUR: {
+            reopenReadChannel(myPosition + theOffset);
+            return myPosition;
+        }
+        case SEEK_END: {
+            if(myContentLen <= 0) {
+                return -1;
+            }
+            reopenReadChannel(myContentLen + theOffset);
+            return myPosition;
+        }
+    }
+    return -1;
+}

sview-17_04.tar.gz/StShared/StAVImage.cpp -> sview-20_08.tar.gz/StShared/StAVImage.cpp Changed

@@ -1,5 +1,5 @@
 /**
- * Copyright © 2011-2015 Kirill Gavrilov <kirill@sview.ru>
+ * Copyright © 2011-2020 Kirill Gavrilov <kirill@sview.ru>
  *
  * Distributed under the Boost Software License, Version 1.0.
  * See accompanying file license-boost.txt or copy at
@@ -46,7 +46,8 @@
         }
     }
     switch(theImage.getColorModel()) {
-        case StImage::ImgColor_YUV: {
+        case StImage::ImgColor_YUV:
+        case StImage::ImgColor_YUVA: {
             size_t aDelimX = (theImage.getPlane(1).getSizeX() > 0) ? (aPlane0.getSizeX() / theImage.getPlane(1).getSizeX()) : 1;
             size_t aDelimY = (theImage.getPlane(1).getSizeY() > 0) ? (aPlane0.getSizeY() / theImage.getPlane(1).getSizeY()) : 1;
             if(theImage.getPlane(1).getFormat() == StImagePlane::ImgUV) {
@@ -101,7 +102,7 @@
                 }
             } else if(aDelimX == 1 && aDelimY == 2) {
                 return theImage.getColorScale() == StImage::ImgScale_Mpeg
-                     ? stAV::PIX_FMT::YUVJ440P : stAV::PIX_FMT::YUV440P;
+                     ? stAV::PIX_FMT::YUV440P : stAV::PIX_FMT::YUVJ440P;
             } else if(aDelimX == 4 && aDelimY == 1) {
                 return stAV::PIX_FMT::YUV411P;
             } else if(aDelimX == 4 && aDelimY == 4) {
@@ -121,12 +122,16 @@
     }
 }
 
+static const int THE_SWSCALE_FLAGS_FAST    = SWS_BICUBIC;
+static const int THE_SWSCALE_FLAGS_QUALITY = SWS_LANCZOS | SWS_ACCURATE_RND | SWS_FULL_CHR_H_INT;
+
 /**
  * Convert image from one format to another using swscale.
  * Image buffers should be already initialized!
  */
 static bool convert(const StImage& theImageFrom, AVPixelFormat theFormatFrom,
-                          StImage& theImageTo,   AVPixelFormat theFormatTo) {
+                          StImage& theImageTo,   AVPixelFormat theFormatTo,
+                    int theSwsFlags) {
     ST_DEBUG_LOG("StAVImage, convert from " + stAV::PIX_FMT::getString(theFormatFrom) + " " + theImageFrom.getSizeX() + "x" + theImageFrom.getSizeY()
                + " to " + stAV::PIX_FMT::getString(theFormatTo) + " " + theImageTo.getSizeX() + "x" + theImageTo.getSizeY());
     if(theFormatFrom == stAV::PIX_FMT::NONE
@@ -136,7 +141,7 @@
 
     SwsContext* aCtxToRgb = sws_getContext((int )theImageFrom.getSizeX(), (int )theImageFrom.getSizeY(), theFormatFrom, // source
                                            (int )theImageTo.getSizeX(),   (int )theImageTo.getSizeY(),   theFormatTo,   // destination
-                                           SWS_BICUBIC, NULL, NULL, NULL);
+                                           theSwsFlags, NULL, NULL, NULL);
     if(aCtxToRgb == NULL) {
         return false;
     }
@@ -156,6 +161,59 @@
     return true;
 }
 
+/**
+ * Return AV pixel format for an image plane.
+ */
+static int getAVPixelFormatForPlane(const StImagePlane& theImage) {
+    switch(theImage.getFormat()) {
+        case StImagePlane::ImgRGB:    return stAV::PIX_FMT::RGB24;
+        case StImagePlane::ImgBGR:    return stAV::PIX_FMT::BGR24;
+        case StImagePlane::ImgRGBA:   return stAV::PIX_FMT::RGBA32;
+        case StImagePlane::ImgBGRA:   return stAV::PIX_FMT::BGRA32;
+        case StImagePlane::ImgGray:   return stAV::PIX_FMT::GRAY8;
+        case StImagePlane::ImgGray16: return stAV::PIX_FMT::GRAY16;
+        default:                      return stAV::PIX_FMT::NONE;
+    }
+}
+
+bool StAVImage::resizePlane(const StImagePlane& theImageFrom,
+                            StImagePlane&       theImageTo) {
+    if(theImageFrom.isNull()
+    || theImageFrom.getSizeX() < 1
+    || theImageFrom.getSizeY() < 1
+    || theImageTo.isNull()
+    || theImageTo.getSizeX() < 1
+    || theImageTo.getSizeY() < 1) {
+        return false;
+    }
+
+    StAVImage::init();
+    const AVPixelFormat aFormatFrom = (AVPixelFormat )getAVPixelFormatForPlane(theImageFrom);
+    const AVPixelFormat aFormatTo   = (AVPixelFormat )getAVPixelFormatForPlane(theImageTo);
+    if(aFormatFrom == stAV::PIX_FMT::NONE
+    || aFormatTo   == stAV::PIX_FMT::NONE) {
+        return false;
+    }
+
+    SwsContext* aCtxToRgb = sws_getContext((int )theImageFrom.getSizeX(), (int )theImageFrom.getSizeY(), aFormatFrom,
+                                           (int )theImageTo.getSizeX(),   (int )theImageTo.getSizeY(),   aFormatTo,
+                                           THE_SWSCALE_FLAGS_FAST, NULL, NULL, NULL);
+    if(aCtxToRgb == NULL) {
+        return false;
+    }
+
+    uint8_t* aSrcData[4] = { (uint8_t* )theImageFrom.getData(), NULL, NULL, NULL };
+    int  aSrcLinesize[4] = { (int )theImageFrom.getSizeRowBytes(), 0, 0, 0 };
+    uint8_t* aDstData[4] = { (uint8_t* )theImageTo.getData(), NULL, NULL, NULL };
+    int  aDstLinesize[4] = { (int )theImageTo.getSizeRowBytes(), 0, 0, 0 };
+    sws_scale(aCtxToRgb,
+              aSrcData, aSrcLinesize,
+              0, (int )theImageFrom.getSizeY(),
+              aDstData, aDstLinesize);
+    sws_freeContext(aCtxToRgb);
+    return true;
+}
+
 bool StAVImage::resize(const StImage& theImageFrom,
                        StImage&       theImageTo) {
     if(theImageFrom.isNull()
@@ -173,7 +231,8 @@
     return aFormatFrom != stAV::PIX_FMT::NONE
         && aFormatTo   != stAV::PIX_FMT::NONE
         && convert(theImageFrom, aFormatFrom,
-                   theImageTo,   aFormatTo);
+                   theImageTo,   aFormatTo,
+                   THE_SWSCALE_FLAGS_FAST);
 }
 
 void StAVImage::close() {
@@ -235,6 +294,10 @@
             myCodec = avcodec_find_decoder_by_name("webp");
             break;
         }
+        case ST_TYPE_DDS: {
+            myCodec = avcodec_find_decoder_by_name("dds");
+            break;
+        }
         default: {
             break;
         }
@@ -258,7 +321,7 @@
     #endif
         if(avErrCode != 0
         || myFormatCtx->nb_streams < 1
-        || myFormatCtx->streams[0]->codec->codec_id == 0) {
+        || stAV::getCodecId(myFormatCtx->streams[0]) == AV_CODEC_ID_NONE) {
             if(myFormatCtx != NULL) {
             #if(LIBAVFORMAT_VERSION_INT >= AV_VERSION_INT(53, 17, 0))
                 avformat_close_input(&myFormatCtx);
@@ -289,7 +352,7 @@
         }
 
         // find the decoder for the video stream
-        myCodecCtx = myFormatCtx->streams[0]->codec;
+        myCodecCtx = stAV::getCodecCtx(myFormatCtx->streams[0]);
         if(theImageType == ST_TYPE_NONE) {
             myCodec = avcodec_find_decoder(myCodecCtx->codec_id);
         }
@@ -353,7 +416,12 @@
 
     // decode one frame
     int isFrameFinished = 0;
-#if(LIBAVCODEC_VERSION_INT >= AV_VERSION_INT(52, 23, 0))
+#if(LIBAVCODEC_VERSION_INT >= AV_VERSION_INT(57, 106, 102))
+    if(avcodec_send_packet(myCodecCtx, anAvPkt.getAVpkt()) == 0
+    && avcodec_receive_frame(myCodecCtx, myFrame.Frame) == 0) {
+        isFrameFinished = 1;
+    }
+#elif(LIBAVCODEC_VERSION_INT >= AV_VERSION_INT(52, 23, 0))
     avcodec_decode_video2(myCodecCtx, myFrame.Frame, &isFrameFinished, anAvPkt.getAVpkt());
 #else
     avcodec_decode_video(myCodecCtx, myFrame.Frame, &isFrameFinished,
@@ -472,7 +540,7 @@
             aDimsYUV.isFullScale = true;
         }
     #endif
-        setColorModel(StImage::ImgColor_YUV);
+        setColorModel(aDimsYUV.hasAlpha ? StImage::ImgColor_YUVA : StImage::ImgColor_YUV);
         setColorScale(aDimsYUV.isFullScale ? StImage::ImgScale_Full : StImage::ImgScale_Mpeg);
         StImagePlane::ImgFormat aPlaneFrmt = StImagePlane::ImgGray;
         if(aDimsYUV.bitsPerComp == 9) {
@@ -491,6 +559,10 @@
                                    size_t(aDimsYUV.widthU), size_t(aDimsYUV.heightU), myFrame.getLineSize(1));
         changePlane(2).initWrapper(aPlaneFrmt, myFrame.getPlane(2),
                                    size_t(aDimsYUV.widthV), size_t(aDimsYUV.heightV), myFrame.getLineSize(2));
+        if(aDimsYUV.hasAlpha) {
+            changePlane(3).initWrapper(aPlaneFrmt, myFrame.getPlane(3),
+                                       size_t(aDimsYUV.widthY), size_t(aDimsYUV.heightY), myFrame.getLineSize(3));
+        }
     } else {
         ///ST_DEBUG_LOG("StAVImage, perform conversion from Pixel format '" + avcodec_get_pix_fmt_name(myCodecCtx->pix_fmt) + "' to RGB");
         // initialize software scaler/converter
@@ -566,7 +638,8 @@
                 anImage.changePlane().initTrash(StImagePlane::ImgRGB, getSizeX(), getSizeY(), getAligned(getSizeX() * 3));
                 AVPixelFormat aPFrmtTarget = stAV::PIX_FMT::RGB24;
                 if(!convert(*this,   aPFormatAV,
-                            anImage, aPFrmtTarget)) {
+                            anImage, aPFrmtTarget,
+                            THE_SWSCALE_FLAGS_QUALITY)) {
                     setState("SWScale library, failed to create SWScaler context");
                     close();
                     return false;
@@ -616,7 +689,8 @@
                 anImage.changePlane(2).initTrash(StImagePlane::ImgGray, getSizeX(), getSizeY(), getAligned(getSizeX()));
                 stMemSet(anImage.changePlane(2).changeData(), '\0', anImage.getPlane(2).getSizeBytes());
                 if(!convert(*this,   aPFormatAV,
-                            anImage, aPFrmtTarget)) {
+                            anImage, aPFrmtTarget,
+                            THE_SWSCALE_FLAGS_QUALITY)) {
                     setState("SWScale library, failed to create SWScaler context");
                     close();
                     return false;
@@ -681,12 +755,20 @@
         return false;
     }
 
+    // encode the image
+    StAVPacket aPacket;
+#if(LIBAVCODEC_VERSION_INT >= AV_VERSION_INT(57, 106, 102))
+    int anEncSize = 0;
+    if(avcodec_send_frame(myCodecCtx, myFrame.Frame) == 0
+    && avcodec_receive_packet(myCodecCtx, aPacket.getAVpkt()) == 0
+    && aPacket.getAVpkt()->data != NULL) {
+        anEncSize = aPacket.getSize();
+        aRawFile.wrapBuffer(aPacket.getAVpkt()->data, anEncSize);
+    }
+#else
     // allocate the buffer, large enough (stupid formula copied from ffmpeg.c)
     int aBuffSize = int(getSizeX() * getSizeY() * 10);
     aRawFile.initBuffer(aBuffSize);
-
-    // encode the image
-    StAVPacket aPacket;
     aPacket.getAVpkt()->data = (uint8_t* )aRawFile.changeBuffer();
     aPacket.getAVpkt()->size = aBuffSize;
 #if(LIBAVCODEC_VERSION_INT >= AV_VERSION_INT(54, 2, 100))
@@ -698,6 +780,7 @@
 #else
     int anEncSize = avcodec_encode_video(myCodecCtx, aPacket.changeData(), aPacket.getSize(), myFrame.Frame);
 #endif
+#endif
     if(anEncSize <= 0) {
         setState("AVCodec library, fail to encode the image");
         close();

sview-17_04.tar.gz/StShared/StAVPacket.cpp -> sview-20_08.tar.gz/StShared/StAVPacket.cpp Changed

@@ -64,7 +64,11 @@
   myIsOwn(false) {
     avInitPacket();
     if(myType == DATA_PACKET) {
+    #if(LIBAVCODEC_VERSION_INT >= AV_VERSION_INT(57, 106, 102))
+        av_packet_ref(&myPacket, &theCopy.myPacket); // copy by reference
+    #else
         setAVpkt(theCopy.myPacket);
+    #endif
     }
 }
 
@@ -75,17 +79,21 @@
 void StAVPacket::free() {
     if(myIsOwn) {
         avDestructPacket(&myPacket);
+        avInitPacket();
     } else {
-    #if(LIBAVCODEC_VERSION_INT >= AV_VERSION_INT(55, 0, 0))
+    #if(LIBAVCODEC_VERSION_INT >= AV_VERSION_INT(57, 12, 100))
+        av_packet_unref(&myPacket);
+    #elif(LIBAVCODEC_VERSION_INT >= AV_VERSION_INT(55, 0, 0))
         av_free_packet(&myPacket);
+        avInitPacket();
     #else
         if(myPacket.destruct != NULL) {
             myPacket.destruct(&myPacket);
             myPacket.destruct = NULL;
         }
+        avInitPacket();
     #endif
     }
-    avInitPacket();
     myIsOwn = false;
 }
 
@@ -104,9 +112,9 @@
 #endif
 
     // now copy data with special padding space
-    myPacket.data = stMemAllocAligned<uint8_t*>((theCopy.size + FF_INPUT_BUFFER_PADDING_SIZE), 16); // data must be aligned to 16 bytes for SSE!
+    myPacket.data = stMemAllocAligned<uint8_t*>((theCopy.size + AV_INPUT_BUFFER_PADDING_SIZE), 16); // data must be aligned to 16 bytes for SSE!
     stMemCpy (myPacket.data, theCopy.data, theCopy.size);
-    stMemZero(myPacket.data + (ptrdiff_t )theCopy.size, FF_INPUT_BUFFER_PADDING_SIZE);
+    stMemZero(myPacket.data + (ptrdiff_t )theCopy.size, AV_INPUT_BUFFER_PADDING_SIZE);
 
 #if(LIBAVCODEC_VERSION_INT >= AV_VERSION_INT(52, 118, 0))
     if(myPacket.side_data_elems > 0) {
@@ -117,9 +125,9 @@
         for(int anIter = 0; anIter < theCopy.side_data_elems; ++anIter) {
             aSize = theCopy.side_data[anIter].size;
             myPacket.side_data[anIter] = theCopy.side_data[anIter];
-            myPacket.side_data[anIter].data = stMemAllocAligned<uint8_t*>(aSize + FF_INPUT_BUFFER_PADDING_SIZE, 16);
+            myPacket.side_data[anIter].data = stMemAllocAligned<uint8_t*>(aSize + AV_INPUT_BUFFER_PADDING_SIZE, 16);
             stMemCpy (myPacket.side_data[anIter].data, theCopy.side_data[anIter].data, aSize);
-            stMemZero(myPacket.side_data[anIter].data + (ptrdiff_t )aSize, FF_INPUT_BUFFER_PADDING_SIZE);
+            stMemZero(myPacket.side_data[anIter].data + (ptrdiff_t )aSize, AV_INPUT_BUFFER_PADDING_SIZE);
         }
     }
 #endif

sview-17_04.tar.gz/StShared/StAVVideoMuxer.cpp -> sview-20_08.tar.gz/StShared/StAVVideoMuxer.cpp Changed

@@ -194,16 +194,18 @@
 
 bool StAVVideoMuxer::addStream(AVFormatContext* theContext,
                                AVStream*        theStream) {
+    AVCodecContext* aCodecCtxSrc = stAV::getCodecCtx(theStream);
 #if(LIBAVFORMAT_VERSION_INT >= AV_VERSION_INT(57, 0, 0))
-    AVStream* aStreamOut = avformat_new_stream(theContext, theStream->codec->codec);
+    AVStream* aStreamOut = avformat_new_stream(theContext, aCodecCtxSrc->codec);
 #else
-    AVStream* aStreamOut = avformat_new_stream(theContext, (AVCodec* )theStream->codec->codec);
+    AVStream* aStreamOut = avformat_new_stream(theContext, (AVCodec* )aCodecCtxSrc->codec);
 #endif
     if(aStreamOut == NULL) {
         signals.onError(StString("Failed allocating output stream."));
         return false;
     }
-    if(avcodec_copy_context(aStreamOut->codec, theStream->codec) < 0) {
+    AVCodecContext* aCodecCtxNew = stAV::getCodecCtx(aStreamOut);
+    if(avcodec_copy_context(aCodecCtxNew, aCodecCtxSrc) < 0) {
         signals.onError(StString("Failed to copy context from input to output stream codec context."));
         return false;
     }
@@ -211,13 +213,13 @@
 //#if(LIBAVFORMAT_VERSION_INT >= AV_VERSION_INT(54, 2, 100))
 //    myIsAttachedPic = (theStream->disposition & AV_DISPOSITION_ATTACHED_PIC) != 0;
 //#endif
-    if(theStream->codec->codec_type == AVMEDIA_TYPE_VIDEO) {
-        aStreamOut->sample_aspect_ratio        = theStream->sample_aspect_ratio;
-        aStreamOut->codec->sample_aspect_ratio = aStreamOut->sample_aspect_ratio;
+    if(aCodecCtxSrc->codec_type == AVMEDIA_TYPE_VIDEO) {
+        aStreamOut->sample_aspect_ratio   = theStream->sample_aspect_ratio;
+        aCodecCtxNew->sample_aspect_ratio = aStreamOut->sample_aspect_ratio;
     }
 
     if(theContext->oformat->flags & AVFMT_GLOBALHEADER) {
-        aStreamOut->codec->flags |= CODEC_FLAG_GLOBAL_HEADER;
+        aCodecCtxNew->flags |= AV_CODEC_FLAG_GLOBAL_HEADER;
     }
     return true;
 }
@@ -254,7 +256,7 @@
         for(unsigned int aStreamId = 0; aStreamId < aCtxSrc.Context->nb_streams; ++aStreamId) {
             aCtxSrc.Streams.add((unsigned int )-1);
             AVStream* aStreamSrc = aCtxSrc.Context->streams[aStreamId];
-            if(aStreamSrc->codec->codec_type == AVMEDIA_TYPE_VIDEO) {
+            if(stAV::getCodecType(aStreamSrc) == AVMEDIA_TYPE_VIDEO) {
                 if(addStream(aCtxOut.Context, aStreamSrc)) {
                     aCtxSrc.Streams[aStreamId] = aStreamCount++;
                 }
@@ -268,7 +270,7 @@
         StRemuxContext& aCtxSrc = aSrcCtxList[aCtxId];
         for(unsigned int aStreamId = 0; aStreamId < aCtxSrc.Context->nb_streams; ++aStreamId) {
             AVStream* aStreamSrc = aCtxSrc.Context->streams[aStreamId];
-            if(aStreamSrc->codec->codec_type == AVMEDIA_TYPE_AUDIO
+            if(stAV::getCodecType(aStreamSrc) == AVMEDIA_TYPE_AUDIO
             && addStream(aCtxOut.Context, aStreamSrc)) {
                 aCtxSrc.Streams[aStreamId] = aStreamCount++;
             }
@@ -280,8 +282,8 @@
         StRemuxContext& aCtxSrc = aSrcCtxList[aCtxId];
         for(unsigned int aStreamId = 0; aStreamId < aCtxSrc.Context->nb_streams; ++aStreamId) {
             AVStream* aStreamSrc = aCtxSrc.Context->streams[aStreamId];
-            if(aStreamSrc->codec->codec_type != AVMEDIA_TYPE_VIDEO
-            && aStreamSrc->codec->codec_type != AVMEDIA_TYPE_AUDIO
+            if(stAV::getCodecType(aStreamSrc) != AVMEDIA_TYPE_VIDEO
+            && stAV::getCodecType(aStreamSrc) != AVMEDIA_TYPE_AUDIO
             && addStream(aCtxOut.Context, aStreamSrc)) {
                 aCtxSrc.Streams[aStreamId] = aStreamCount++;
             }
@@ -303,7 +305,7 @@
         return false;
     }
 
-    AVPacket aPacket;
+    StAVPacket aPacket;
     for(;;) {
         size_t aNbEmpty = 0;
         for(size_t aCtxId = 0; aCtxId < aSrcCtxList.size(); ++aCtxId) {
@@ -313,18 +315,18 @@
                 continue;
             }
 
-            if(av_read_frame(aCtxSrc.Context, &aPacket) < 0) {
+            if(av_read_frame(aCtxSrc.Context, aPacket.getAVpkt()) < 0) {
                 aCtxSrc.State = false;
                 ++aNbEmpty;
                 continue;
             }
 
-            unsigned int aStreamOutIndex = aCtxSrc.Streams[aPacket.stream_index];
+            unsigned int aStreamOutIndex = aCtxSrc.Streams[aPacket.getStreamId()];
             if(aStreamOutIndex == (unsigned int )-1) {
                 continue;
             }
 
-            AVStream* aStreamIn  = aCtxSrc.Context->streams[aPacket.stream_index];
+            AVStream* aStreamIn  = aCtxSrc.Context->streams[aPacket.getStreamId()];
             AVStream* aStreamOut = aCtxOut.Context->streams[aStreamOutIndex];
 
         #ifdef ST_LIBAV_FORK
@@ -332,17 +334,17 @@
         #else
             const AVRounding aRoundParams = AVRounding(AV_ROUND_NEAR_INF | AV_ROUND_PASS_MINMAX);
         #endif
-            aPacket.pts      = av_rescale_q_rnd(aPacket.pts, aStreamIn->time_base, aStreamOut->time_base, aRoundParams);
-            aPacket.dts      = av_rescale_q_rnd(aPacket.dts, aStreamIn->time_base, aStreamOut->time_base, aRoundParams);
-            aPacket.duration = static_cast<int >(av_rescale_q(aPacket.duration, aStreamIn->time_base, aStreamOut->time_base));
-            aPacket.pos      = -1;
+            aPacket.getAVpkt()->pts      = av_rescale_q_rnd(aPacket.getPts(), aStreamIn->time_base, aStreamOut->time_base, aRoundParams);
+            aPacket.getAVpkt()->dts      = av_rescale_q_rnd(aPacket.getDts(), aStreamIn->time_base, aStreamOut->time_base, aRoundParams);
+            aPacket.getAVpkt()->duration = static_cast<int >(av_rescale_q(aPacket.getDuration(), aStreamIn->time_base, aStreamOut->time_base));
+            aPacket.getAVpkt()->pos      = -1;
 
-            aState = av_interleaved_write_frame(aCtxOut.Context, &aPacket);
+            aState = av_interleaved_write_frame(aCtxOut.Context, aPacket.getAVpkt());
             if(aState < 0) {
                 signals.onError(StString("Error muxing packet (") + stAV::getAVErrorDescription(aState) + ").");
                 return false;
             }
-            av_free_packet(&aPacket);
+            aPacket.free();
         }
         if(aNbEmpty == aSrcCtxList.size()) {
             break;

sview-17_04.tar.gz/StShared/StAction.cpp -> sview-20_08.tar.gz/StShared/StAction.cpp Changed

sview-17_04.tar.gz/StShared/StCocoaCoords.mm -> sview-20_08.tar.gz/StShared/StCocoaCoords.mm Changed

sview-17_04.tar.gz/StShared/StConfigImpl.cpp -> sview-20_08.tar.gz/StShared/StConfigImpl.cpp Changed

sview-17_04.tar.gz/StShared/StDevILImage.cpp -> sview-20_08.tar.gz/StShared/StDevILImage.cpp Changed

sview-17_04.tar.gz/StShared/StExifDir.cpp -> sview-20_08.tar.gz/StShared/StExifDir.cpp Changed

@@ -249,7 +249,12 @@
                         }
                     }
                 } else {
-                    ST_DEBUG_LOG("StExifDir, found unsupported (" + CameraMaker + ") maker notes");
+                    if(anEntry.Format == StExifEntry::FMT_STRING) {
+                        StString aMakerNoteName((char *)anEntry.ValuePtr);
+                        ST_DEBUG_LOG("StExifDir, found unsupported (" + aMakerNoteName + ") maker notes");
+                    } else {
+                        ST_DEBUG_LOG("StExifDir, found unsupported (" + CameraMaker + ": " + CameraModel + ") maker notes");
+                    }
                 }
                 break;
             }
@@ -474,7 +479,8 @@
         if(aDir->Type == theQuery.Type) {
             for(size_t anEntryId = 0; anEntryId < aDir->Entries.size(); ++anEntryId) {
                 const StExifEntry& anEntry = aDir->Entries[anEntryId];
-                if(anEntry.Tag == theQuery.Entry.Tag) {
+                if(anEntry.Tag == theQuery.Entry.Tag
+                && (anEntry.Format == theQuery.Entry.Format || theQuery.Entry.Format == 0)) {
                     theQuery.Entry  = anEntry;
                     theQuery.Folder = aDir.access();
                     return true;

sview-17_04.tar.gz/StShared/StFTFont.cpp -> sview-20_08.tar.gz/StShared/StFTFont.cpp Changed

@@ -24,6 +24,7 @@
     }
     stMemZero(mySubsets, sizeof(mySubsets));
     stMemZero(myFTFaces, sizeof(myFTFaces));
+    stMemZero(myFontFaces, sizeof(myFontFaces));
 }
 
 StFTFont::~StFTFont() {
@@ -43,6 +44,7 @@
             aFace = NULL;
         }
         myFontPaths[aStyleIt].clear();
+        myFontFaces[aStyleIt] = 0;
     }
 }
 
@@ -52,6 +54,7 @@
     }
 
     if(myFTFaces[theStyle] != NULL) {
+        myUChar  = 0;
         myStyle  = theStyle;
         myFTFace = myFTFaces[theStyle];
         return true;
@@ -102,8 +105,10 @@
     return true;
 }
 
-bool StFTFont::load(const StString&       theFontPath,
-                    const StFTFont::Style theStyle) {
+bool StFTFont::load(const StString& theFontPath,
+                    const int theFaceId,
+                    const StFTFont::Style theStyle,
+                    const bool theToSyntItalic) {
     if(!myFTLib->isValid()
     || theStyle <  Style_Regular
     || theStyle >= StylesNB
@@ -114,18 +119,34 @@
     myFTFace = NULL;
     myGlyphImg.nullify();
     myFontPaths[theStyle] = theFontPath;
+    myFontFaces[theStyle] = theFaceId;
 
     FT_Face& aFace = myFTFaces[theStyle];
     if(aFace != NULL) {
         FT_Done_Face(aFace);
     }
     const StString aFontPath = StFileNode::getCompatibleName(theFontPath);
-    if(FT_New_Face(myFTLib->getInstance(), aFontPath.toCString(), 0, &aFace) != 0) {
+    if(FT_New_Face(myFTLib->getInstance(), aFontPath.toCString(), (FT_Long )theFaceId, &aFace) != 0) {
         ST_DEBUG_LOG("Font '" + aFontPath + "' fail to load!");
         FT_Done_Face(aFace);
         aFace = NULL;
         return false;
     }
+
+    if(theToSyntItalic) {
+        const double THE_SHEAR_ANGLE = 10.0 * M_PI / 180.0;
+
+        FT_Matrix aMat;
+        aMat.xx = FT_Fixed(std::cos(-THE_SHEAR_ANGLE) * (1 << 16));
+        aMat.xy = 0;
+        aMat.yx = 0;
+        aMat.yy = aMat.xx;
+
+        FT_Fixed aFactor = FT_Fixed(std::tan(THE_SHEAR_ANGLE) * (1 << 16));
+        aMat.xy += FT_MulFix(aFactor, aMat.xx);
+
+        FT_Set_Transform(aFace, &aMat, 0);
+    }
     return loadCharmap(aFontPath, aFace);
 }
 
@@ -144,6 +165,7 @@
     myFTFace = NULL;
     myGlyphImg.nullify();
     myFontPaths[theStyle] = theFontName;
+    myFontFaces[theStyle] = 0;
 
     FT_Face& aFace = myFTFaces[theStyle];
     if(aFace != NULL) {
@@ -171,13 +193,11 @@
 
     // test Unicode subsets
     mySubsets[Subset_General] = true;
-    mySubsets[Subset_Korean]  = FT_Get_Char_Index(theFace, 0x0B371) != 0
-                             && FT_Get_Char_Index(theFace, 0x0D130) != 0;
-    mySubsets[Subset_CJK]     = FT_Get_Char_Index(theFace, 0x06F22) != 0;
-
-//if(mySubsets[Subset_Korean]) { std::cerr << "  found Korean in " << myFontPath << "\n"; }
-//if(mySubsets[Subset_CJK])    { std::cerr << "  found CJK    in " << myFontPath << "\n"; }
-
+    mySubsets[Subset_Korean]  =     FT_Get_Char_Index(theFace, 0x0B371) != 0
+                                 && FT_Get_Char_Index(theFace, 0x0D130) != 0;
+    mySubsets[Subset_CJK]         = FT_Get_Char_Index(theFace, 0x06F22) != 0;
+    mySubsets[Subset_Arabic]      = FT_Get_Char_Index(theFace, 0x00600) != 0;
+    mySubsets[Subset_MiscSymbols] = FT_Get_Char_Index(theFace, 0x0266A) != 0;
     return true;
 }
 
@@ -294,56 +314,65 @@
     addAdvanceY(theUCharNext, thePen);
 }
 
-float StFTFont::getAdvanceX(const stUtf32_t theUCharNext) {
+bool StFTFont::getKerning(FT_Vector&      theKern,
+                          const stUtf32_t theUCharCurr,
+                          const stUtf32_t theUCharNext) const {
+    theKern.x = 0;
+    theKern.y = 0;
+    if(theUCharNext != 0 && FT_HAS_KERNING(myFTFace) != 0) {
+        const FT_UInt aCharCurr = FT_Get_Char_Index(myFTFace, theUCharCurr);
+        const FT_UInt aCharNext = FT_Get_Char_Index(myFTFace, theUCharNext);
+        if(aCharCurr == 0 || aCharNext == 0
+        || FT_Get_Kerning (myFTFace, aCharCurr, aCharNext, FT_KERNING_UNFITTED, &theKern) != 0) {
+            theKern.x = 0;
+            theKern.y = 0;
+            return false;
+        }
+        return true;
+    }
+    return false;
+}
+
+float StFTFont::getAdvanceX(const stUtf32_t theUCharNext) const {
     if(myUChar == 0) {
         return 0.0f;
     }
 
-    if(FT_HAS_KERNING(myFTFace) == 0 || theUCharNext == 0
-    || FT_Get_Kerning(myFTFace, myUChar, theUCharNext, FT_KERNING_UNFITTED, &myKernAdvance) != 0) {
-        return float(myFTFace->glyph->advance.x) / 64.0f;
-    }
-    return float(myKernAdvance.x + myFTFace->glyph->advance.x) / 64.0f;
+    FT_Vector aKern;
+    getKerning(aKern, myUChar, theUCharNext);
+    return float(aKern.x + myFTFace->glyph->advance.x) / 64.0f;
 }
 
-float StFTFont::getAdvanceY(const stUtf32_t theUCharNext) {
+float StFTFont::getAdvanceY(const stUtf32_t theUCharNext) const {
     if(myUChar == 0) {
         return 0.0f;
     }
 
-    if(FT_HAS_KERNING(myFTFace) == 0 || theUCharNext == 0
-    || FT_Get_Kerning(myFTFace, myUChar, theUCharNext, FT_KERNING_UNFITTED, &myKernAdvance) != 0) {
-        return float(myFTFace->glyph->advance.y) / 64.0f;
-    }
-    return float(myKernAdvance.y + myFTFace->glyph->advance.y) / 64.0f;
+    FT_Vector aKern;
+    getKerning(aKern, myUChar, theUCharNext);
+    return float(aKern.y + myFTFace->glyph->advance.y) / 64.0f;
 }
 
 void StFTFont::addAdvanceX(const stUtf32_t  theUCharNext,
-                           StVec2<GLfloat>& thePen) {
+                           StVec2<GLfloat>& thePen) const {
     if(myUChar == 0) {
         return;
     }
 
-    if(FT_HAS_KERNING(myFTFace) == 0 || theUCharNext == 0
-    || FT_Get_Kerning(myFTFace, myUChar, theUCharNext, FT_KERNING_UNFITTED, &myKernAdvance) != 0) {
-        thePen.x() += float(myFTFace->glyph->advance.x) / 64.0f;
-    } else {
-        thePen.x() += float(myKernAdvance.x + myFTFace->glyph->advance.x) / 64.0f;
-    }
+    FT_Vector aKern;
+    getKerning(aKern, myUChar, theUCharNext);
+    thePen.x() += float(aKern.x + myFTFace->glyph->advance.x) / 64.0f;
 }
 
 void StFTFont::addAdvanceY(const stUtf32_t  theUCharNext,
-                           StVec2<GLfloat>& thePen) {
+                           StVec2<GLfloat>& thePen) const {
     if(myUChar == 0) {
         return;
     }
 
-    if(FT_HAS_KERNING(myFTFace) == 0 || theUCharNext == 0
-    || FT_Get_Kerning(myFTFace, myUChar, theUCharNext, FT_KERNING_UNFITTED, &myKernAdvance) != 0) {
-        thePen.y() += float(myFTFace->glyph->advance.y) / 64.0f;
-    } else {
-        thePen.y() += float(myKernAdvance.y + myFTFace->glyph->advance.y) / 64.0f;
-    }
+    FT_Vector aKern;
+    getKerning(aKern, myUChar, theUCharNext);
+    thePen.y() += float(aKern.y + myFTFace->glyph->advance.y) / 64.0f;
 }
 
 bool StFTFont::hasSymbol(const stUtf32_t theUChar) const {

sview-17_04.tar.gz/StShared/StFTFontRegistry.cpp -> sview-20_08.tar.gz/StShared/StFTFontRegistry.cpp Changed

@@ -13,9 +13,14 @@
 #include <StThreads/StProcess.h>
 #include <stAssert.h>
 
+#if !defined(_WIN32) && !defined(__ANDROID__) && !defined(__APPLE__) && !defined(__EMSCRIPTEN__)
+  // use fontconfig library on Linux
+  #include <fontconfig/fontconfig.h>
+#endif
+
 namespace {
-    const StFTFontFamily THE_NO_FAMILY;
-};
+    static const StFTFontFamily THE_NO_FAMILY;
+}
 
 StFTFontRegistry::StFTFontRegistry() {
     myFTLib = new StFTLibrary();
@@ -51,7 +56,8 @@
     myFolders.add(stCString("/Library/Fonts"));
 
     // western
-    myFilesMajor.add(stCString("Times.dfont"));
+    myFilesMinor.add(stCString("Times.dfont")); // old macOS
+    myFilesMajor.add(stCString("Times.ttc"));
     myFilesMajor.add(stCString("Times New Roman.ttf"));
     myFilesMajor.add(stCString("Times New Roman Bold.ttf"));
     myFilesMajor.add(stCString("Times New Roman Italic.ttf"));
@@ -67,7 +73,8 @@
     //myFilesMajor.add(stCString("AppleMyungjo.ttf"));
     myFilesMajor.add(stCString("AppleGothic.ttf"));
     // chinese
-    myFilesMajor.add(stCString("华文仿宋.ttf"));
+    myFilesMinor.add(stCString("华文仿宋.ttf")); // old macOS
+    myFilesMajor.add(stCString("Songti.ttc"));
 #elif defined(__ANDROID__)
     myFolders.add(stCString("/system/fonts"));
 
@@ -90,6 +97,7 @@
     myFilesMajor.add(stCString("DroidSansMono.ttf"));
 
     // not all phones have the following fonts
+    myFilesMinor.add(stCString("NotoSansCJK-Regular.ttc"));
 
     // Korean
     myFilesMinor.add(stCString("NanumGothic.ttf"));
@@ -104,9 +112,32 @@
 
     // Japanese
     //myFilesMinor.add(stCString("NotoSansJP-Regular.otf"));
+
+    // Arabic
+    myFilesMinor.add(stCString("NotoNaskhArabic-Regular.ttf"));
+    //myFilesMinor.add(stCString("NotoNaskhArabic-Bold.ttf"));
 #else
-    myFolders.add(stCString("/usr/share/fonts"));
-    myFolders.add(stCString("/usr/local/share/fonts"));
+
+#if !defined(__EMSCRIPTEN__)
+    if(FcConfig* aFcCfg = FcInitLoadConfig()) {
+        if(FcStrList* aFcFontDir = FcConfigGetFontDirs(aFcCfg)) {
+            for(;;) {
+                FcChar8* aFcFolder = FcStrListNext(aFcFontDir);
+                if(aFcFolder == NULL) {
+                    break;
+                }
+
+                myFolders.add(StString((const char* )aFcFolder));
+            }
+            FcStrListDone(aFcFontDir);
+        }
+        FcConfigDestroy(aFcCfg);
+    }
+#endif
+    if(myFolders.isEmpty()) {
+        myFolders.add(stCString("/usr/share/fonts"));
+        myFolders.add(stCString("/usr/local/share/fonts"));
+    }
 
     // western
     myFilesMajor.add(stCString("DejaVuSerif.ttf"));
@@ -130,6 +161,7 @@
     myFilesMajor.add(stCString("NanumMyeongjoBold.ttf"));
     myFilesMajor.add(stCString("NanumGothic.ttf"));
     myFilesMajor.add(stCString("NanumGothicBold.ttf"));
+    myFilesMinor.add(stCString("NotoSerifCJK-Regular.ttc"));
 
     // chinese
     //myFilesMajor.add(stCString("DroidSansJapanese.ttf"));
@@ -145,6 +177,98 @@
     myFolders.add(theFolder);
 }
 
+bool StFTFontRegistry::registerFamily(const StString& theFontPath, int theFaceId) {
+    const FT_Long aFaceId = theFaceId != -1 ? theFaceId : 0;
+    FT_Face aFace = NULL;
+    if(FT_New_Face(myFTLib->getInstance(), theFontPath.toCString(), aFaceId, &aFace) != 0) {
+        if(aFace != NULL) {
+            FT_Done_Face(aFace);
+        }
+        return false;
+    }
+    if(aFace->family_name == NULL // skip broken fonts (error in FreeType?)
+    || FT_Select_Charmap(aFace, ft_encoding_unicode) != 0) { // handle only UNICODE fonts
+        FT_Done_Face(aFace);
+        return false;
+    }
+
+    // generate font family name
+    StString aStyle(aFace->style_name != NULL ? aFace->style_name : "");
+    {
+        // remove standard style combinations reflected by style_flags
+        // and keep only extra styles like Light, Condensed and similar
+        static const StString THE_EMPTY;
+        static const StString THE_SPACE1(" ");
+        static const StString THE_SPACE2("  ");
+        static const StString THE_ITALIC1("Italic");
+        static const StString THE_ITALIC2("Oblique");
+        static const StString THE_BOLD("Bold");
+        static const StString THE_REGULAR1("Regular");
+        static const StString THE_REGULAR2("Book");
+        if(aFace->style_flags == (FT_STYLE_FLAG_ITALIC | FT_STYLE_FLAG_BOLD)) {
+            aStyle = aStyle.replace(THE_BOLD, THE_EMPTY);
+            const size_t aLen = aStyle.Length;
+            aStyle = aStyle.replace(THE_ITALIC1, THE_EMPTY);
+            if(aLen == aStyle.Length) {
+                aStyle = aStyle.replace(THE_ITALIC2, THE_EMPTY);
+            }
+        } else if(aFace->style_flags == FT_STYLE_FLAG_BOLD) {
+            aStyle = aStyle.replace(THE_BOLD, THE_EMPTY);
+        } else if(aFace->style_flags == FT_STYLE_FLAG_ITALIC) {
+            const size_t aLen = aStyle.Length;
+            aStyle = aStyle.replace(THE_ITALIC1, THE_EMPTY);
+            if(aLen == aStyle.Length) {
+                aStyle = aStyle.replace(THE_ITALIC2, THE_EMPTY);
+            }
+        }
+        const size_t aLen2 = aStyle.Length;
+        aStyle = aStyle.replace(THE_REGULAR1, THE_EMPTY);
+        if(aLen2 == aStyle.Length) {
+            aStyle = aStyle.replace(THE_REGULAR2, THE_EMPTY);
+        }
+        aStyle.leftAdjust();
+        aStyle.rightAdjust();
+        aStyle.replace(THE_SPACE2, THE_SPACE1);
+    }
+
+    StString aFamilyName = aFace->family_name;
+    if(!aStyle.isEmpty()) {
+        aFamilyName = aFamilyName + " " + aStyle;
+    }
+
+    StFTFontFamily& aFamily = myFonts[aFamilyName];
+    aFamily.FamilyName = aFamilyName;
+    if(aFace->style_flags == (FT_STYLE_FLAG_ITALIC | FT_STYLE_FLAG_BOLD)) {
+        aFamily.BoldItalic = theFontPath;
+        aFamily.BoldItalicFace = (int )aFaceId;
+    } else if(aFace->style_flags == FT_STYLE_FLAG_BOLD) {
+        aFamily.Bold = theFontPath;
+        aFamily.BoldFace = (int )aFaceId;
+    } else if(aFace->style_flags == FT_STYLE_FLAG_ITALIC) {
+        aFamily.Italic = theFontPath;
+        aFamily.ItalicFace = (int )aFaceId;
+    } else {
+        aFamily.Regular = theFontPath;
+        aFamily.RegularFace = (int )aFaceId;
+    }
+    //ST_DEBUG_LOG("StFTFontRegistry, font file '" + theFontPath + " [" + aFaceId + "]" + "', family '" + aFamily.FamilyName + "', contains " + aFace->num_glyphs + " glyphs!");
+
+    if(theFaceId < aFace->num_faces) {
+        const FT_Long aNbInstances = aFace->style_flags >> 16;
+        for(FT_Long anInstIter = 1; anInstIter < aNbInstances; ++anInstIter) {
+            const FT_Long aSubFaceId = aFaceId + (anInstIter << 16);
+            registerFamily(theFontPath, aSubFaceId);
+        }
+    }
+    if(theFaceId == -1) {
+        for(FT_Long aFaceIter = 1; aFaceIter < aFace->num_faces; ++aFaceIter) {
+            registerFamily(theFontPath, aFaceIter);
+        }
+    }
+    FT_Done_Face(aFace);
+    return true;
+}
+
 void StFTFontRegistry::searchFiles(const StArrayList<StString>& theNames,
                                    const bool                   theIsMajor) {
     for(size_t aNameIter = 0; aNameIter < theNames.size(); ++aNameIter) {
@@ -165,32 +289,13 @@
             continue;
         }
 
-        FT_Face aFace = NULL;
-        if(FT_New_Face(myFTLib->getInstance(), aPath.toCString(), 0, &aFace) != 0) {
+        if(!registerFamily(aPath, -1)) {
             if(theIsMajor) {
                 ST_ERROR_LOG("StFTFontRegistry, major font file '" + aName + "' fail to load"
                             + " from path '" + aPath + "'!");
             }
-            if(aFace != NULL) {
-                FT_Done_Face(aFace);
-            }
             continue;
         }
-
-        StFTFontFamily& aFamily = myFonts[aFace->family_name];
-        aFamily.FamilyName = aFace->family_name;
-        if(aFace->style_flags == (FT_STYLE_FLAG_ITALIC | FT_STYLE_FLAG_BOLD)) {
-            aFamily.BoldItalic = aPath;
-        } else if(aFace->style_flags == FT_STYLE_FLAG_BOLD) {
-            aFamily.Bold = aPath;
-        } else if(aFace->style_flags == FT_STYLE_FLAG_ITALIC) {
-            aFamily.Italic = aPath;
-        } else {
-            aFamily.Regular = aPath;
-        }
-        //ST_DEBUG_LOG("StFTFontRegistry, font file '" + aName + "', family '" + aFamily.FamilyName + "', contains " + aFace->num_glyphs + " glyphs!");
-
-        FT_Done_Face(aFace);
     }
 }
 
@@ -217,11 +322,16 @@
     aSerif.Western = findFont(stCString("Times New Roman"));
     aSans .Western = findFont(stCString("Trebuchet MS"));
     aMono .Western = findFont(stCString("Tahoma"));
+    aSans.MiscSymbols = aSerif.Western; // Trebuchet font does not include this sub-set
     const StFTFontFamily& aMalgun = findFont(stCString("Malgun Gothic"));
     const StFTFontFamily& aGulim  = findFont(stCString("Gulim"));
     const StFTFontFamily& aKor = aMalgun.FamilyName.isEmpty() && !aGulim.FamilyName.isEmpty()
                                ? aGulim
                                : aMalgun;
+    const StFTFontFamily& anArabic = findFont(stCString("Times New Roman"));
+    aSerif.Arabic  = anArabic;
+    aSans .Arabic  = anArabic;
+    aMono .Arabic  = anArabic;
     aSerif.Korean  = aKor;
     aSans .Korean  = aKor;
     aMono .Korean  = aKor;
@@ -236,9 +346,17 @@
     aSerif.Korean  = findFont(stCString("AppleGothic")); // AppleMyungjo can not be loaded
     aSans .Korean  = findFont(stCString("AppleGothic"));
     aMono .Korean  = findFont(stCString("AppleGothic"));
-    aSerif.CJK     = findFont(stCString("STFangsong"));
-    aSans .CJK     = findFont(stCString("STFangsong"));
-    aMono .CJK     = findFont(stCString("STFangsong"));
+    const StFTFontFamily& aSongtiSC = findFont(stCString("Songti SC Light"));
+    const StFTFontFamily& aFang = findFont(stCString("STFangsong"));
+    const StFTFontFamily& aCjk = aSongtiSC.FamilyName.isEmpty() && !aFang.FamilyName.isEmpty()
+                               ? aFang
+                               : aSongtiSC;
+    aSerif.CJK     = aCjk;
+    aSans .CJK     = aCjk;
+    aMono .CJK     = aCjk;
+    aSerif.Arabic  = findFont(stCString("DecoType Naskh"));
+    aSans .Arabic  = findFont(stCString("DecoType Naskh"));
+    aMono .Arabic  = findFont(stCString("DecoType Naskh"));
 #elif defined(__ANDROID__)
     aSerif.Western = findFont(stCString("Noto Serif"));
     if(aSerif.Western.FamilyName.isEmpty()) {
@@ -246,21 +364,41 @@
     }
     aSans .Western = findFont(stCString("Roboto")); // actually DroidSans.ttf
     aMono .Western = findFont(stCString("Droid Sans Mono"));
+
     aSerif.Korean  = findFont(stCString("NanumGothic")); // no serif
-    aSans .Korean  = findFont(stCString("NanumGothic"));
-    aMono .Korean  = findFont(stCString("NanumGothic"));
+    aSans .Korean  = aSerif.Korean;
+    aMono .Korean  = aSerif.Korean;
     if(aSerif.Korean.FamilyName.isEmpty()) {
         aSerif.Korean = findFont(stCString("Noto Sans KR"));
-        aSans .Korean = findFont(stCString("Noto Sans KR"));
-        aMono .Korean = findFont(stCString("Noto Sans KR"));
+        aSans .Korean = aSerif.Korean;
+        aMono .Korean = aSerif.Korean;
     }
     aSerif.CJK     = findFont(stCString("Droid Sans Fallback"));
-    aSans .CJK     = findFont(stCString("Droid Sans Fallback"));
-    aMono .CJK     = findFont(stCString("Droid Sans Fallback"));
+    aSans .CJK     = aSerif.CJK;
+    aMono .CJK     = aSerif.CJK;
     if(aSerif.CJK.FamilyName.isEmpty()) {
         aSerif.CJK = findFont(stCString("Noto Sans SC"));
-        aSans .CJK = findFont(stCString("Noto Sans SC"));
-        aMono .CJK = findFont(stCString("Noto Sans SC"));
+        aSans .CJK = aSerif.CJK;
+        aMono .CJK = aSerif.CJK;
+    }
+    if(aSerif.CJK.FamilyName.isEmpty()) {
+        aSerif.CJK = findFont(stCString("Noto Sans CJK JP"));
+        aSans .CJK = aSerif.CJK;
+        aMono .CJK = aSerif.CJK;
+    }
+    if(aSerif.Korean.FamilyName.isEmpty()) {
+        aSerif.Korean = aSerif.CJK;
+        aSans .Korean = aSerif.CJK;
+        aMono .Korean = aSerif.CJK;
+    }
+
+    aSerif.Arabic = findFont(stCString("Droid Arabic Naskh"));
+    aSans .Arabic = aSerif.Arabic;
+    aMono .Arabic = aSerif.Arabic;
+    if(aSerif.Arabic.FamilyName.isEmpty()) {
+        aSerif.Arabic = findFont(stCString("Noto Naskh Arabic"));
+        aSans .Arabic = aSerif.Arabic;
+        aMono .Arabic = aSerif.Arabic;
     }
 #else
     aSerif.Western = findFont(stCString("FreeSerif"));
@@ -270,9 +408,17 @@
         aSans .Western = findFont(stCString("DejaVu Sans"));
     }
     aMono .Western = findFont(stCString("DejaVu Sans Mono"));
-    aSerif.Korean  = findFont(stCString("NanumMyeongjo"));
-    aSans .Korean  = findFont(stCString("NanumGothic"));
-    aMono .Korean  = findFont(stCString("NanumGothic"));
+
+    const StFTFontFamily& aNanumMyeon     = findFont(stCString("NanumMyeongjo"));
+    const StFTFontFamily& aNotoSerifCjkJp = findFont(stCString("Noto Serif CJK JP"));
+    const StFTFontFamily& aNanumGoth      = findFont(stCString("NanumGothic"));
+    aSerif.Korean  = aNanumMyeon.FamilyName.isEmpty() && !aNotoSerifCjkJp.FamilyName.isEmpty()
+                   ? aNotoSerifCjkJp
+                   : aNanumMyeon;;
+    aSans .Korean  = aNanumGoth.FamilyName.isEmpty() && !aNotoSerifCjkJp.FamilyName.isEmpty()
+                   ? aNotoSerifCjkJp
+                   : aNanumGoth;
+    aMono .Korean  = aSans.Korean;
     aSerif.CJK     = findFont(stCString("Droid Sans Fallback"));
     aSans .CJK     = findFont(stCString("Droid Sans Fallback"));
     aMono .CJK     = findFont(stCString("Droid Sans Fallback"));

sview-17_04.tar.gz/StShared/StFileNode.ObjC.mm -> sview-20_08.tar.gz/StShared/StFileNode.ObjC.mm Changed

@@ -9,7 +9,6 @@
 #if (defined(__APPLE__))
 
 #include <StFile/StFileNode.h>
-#include <StFile/StMIMEList.h>
 
 #include <StCocoa/StCocoaLocalPool.h>
 
@@ -68,21 +67,21 @@
             [aFilePanel setAllowedFileTypes: myFilter];
         }
 
+    ST_DISABLE_DEPRECATION_WARNINGS
         if([aFilePanel runModal] == NSOKButton) {
             myIsFileSelected = true;
             // automatically convert filenames from decomposed form used by Mac OS X file systems
             NSString* aFileName = [[aFilePanel filename] precomposedStringWithCanonicalMapping];
             myResult = [aFileName UTF8String];
         }
+    ST_ENABLE_DEPRECATION_WARNINGS
     }
 
 @end
 
-bool StFileNode::openFileDialog(const StString& theFolder,
-                                const StString& theTitle,
-                                const StMIMEList& theFilter,
-                                StString& theFilePath,
-                                bool toSave) {
+bool StFileNode::openFileDialog(StString& theFilePath,
+                                const StOpenFileName& theInfo,
+                                bool theToSave) {
     if(NSApp == nil) {
         return false;
     }
@@ -91,14 +90,14 @@
     StFileNode::getFolderAndFile(theFilePath, aFolderSrc, aFileNameSrc);
 
     StCocoaLocalPool aLocalPool;
-    NSString* aTitle     = [NSString stringWithUTF8String: theTitle.toCString()];
-    NSString* aFolder    = [NSString stringWithUTF8String: theFolder.toCString()];
+    NSString* aTitle     = [NSString stringWithUTF8String: theInfo.Title.toCString()];
+    NSString* aFolder    = [NSString stringWithUTF8String: theInfo.Folder.toCString()];
     NSString* anInitFile = [NSString stringWithUTF8String: aFileNameSrc.toCString()];
     NSMutableArray* aFilter = NULL;
-    if(!theFilter.isEmpty()) {
-        aFilter = [NSMutableArray arrayWithCapacity: theFilter.size()];
-        for(size_t aMimeId = 0; aMimeId < theFilter.size(); ++aMimeId) {
-            const StMIME& aMime = theFilter[aMimeId];
+    if(!theInfo.Filter.isEmpty()) {
+        aFilter = [NSMutableArray arrayWithCapacity: theInfo.Filter.size()];
+        for(size_t aMimeId = 0; aMimeId < theInfo.Filter.size(); ++aMimeId) {
+            const StMIME& aMime = theInfo.Filter[aMimeId];
             [aFilter addObject: [NSString stringWithUTF8String: aMime.getExtension().toCString()]];
         }
     }
@@ -107,7 +106,7 @@
                                                     withTitle: aTitle
                                                    withFolder: aFolder
                                                      withFile: anInitFile
-                                                       toSave: toSave];
+                                                       toSave: theToSave];
     if([NSThread isMainThread]) {
         [anOpenFile doDialog: NULL];
     } else {

sview-17_04.tar.gz/StShared/StFileNode.cpp -> sview-20_08.tar.gz/StShared/StFileNode.cpp Changed

@@ -1,5 +1,5 @@
 /**
- * Copyright © 2010-2013 Kirill Gavrilov <kirill@sview.ru>
+ * Copyright © 2010-2017 Kirill Gavrilov <kirill@sview.ru>
  *
  * Distributed under the Boost Software License, Version 1.0.
  * See accompanying file license-boost.txt or copy at
@@ -81,6 +81,37 @@
 #endif
 }
 
+bool StFileNode::isFileReadOnly(const StCString& thePath) {
+#ifdef _WIN32
+    StStringUtfWide aPath;
+    aPath.fromUnicode(thePath);
+    DWORD anAttribs = ::GetFileAttributesW(aPath.toCString());
+    return (anAttribs & FILE_ATTRIBUTE_READONLY) != 0;
+#else
+    // not implemented
+    return false;
+#endif
+}
+
+bool StFileNode::removeReadOnlyFlag(const StCString& thePath) {
+#ifdef _WIN32
+    StStringUtfWide aPath;
+    aPath.fromUnicode(thePath);
+    DWORD anAttribs = ::GetFileAttributesW(aPath.toCString());
+    if(anAttribs == INVALID_FILE_ATTRIBUTES) {
+        return false;
+    } else if((anAttribs & FILE_ATTRIBUTE_READONLY) == 0) {
+        return true;
+    }
+
+    anAttribs = (anAttribs & ~FILE_ATTRIBUTE_READONLY);
+    return ::SetFileAttributesW(aPath.toCString(), anAttribs) != FALSE;
+#else
+    // not implemented
+    return false;
+#endif
+}
+
 bool StFileNode::removeFile(const StCString& thePath) {
 #ifdef _WIN32
     StStringUtfWide aPath;

sview-17_04.tar.gz/StShared/StFileNode2.cpp -> sview-20_08.tar.gz/StShared/StFileNode2.cpp Changed

@@ -9,7 +9,6 @@
 #ifndef __APPLE__
 
 #include <StFile/StFileNode.h>
-#include <StFile/StMIMEList.h>
 #include <StStrings/StLogger.h>
 
 #ifdef _WIN32
@@ -29,23 +28,20 @@
  * in commonly used class.
  * This needed only for Windows.
  */
-bool StFileNode::openFileDialog(const StString& theFolder,
-                                const StString& theTitle,
-                                const StMIMEList& theFilter,
-                                StString& theFilePath,
-                                bool toSave) {
+bool StFileNode::openFileDialog(StString& theFilePath,
+                                const StOpenFileName& theInfo,
+                                bool theToSave) {
 #ifdef _WIN32
-    const StStringUtfWide aFolder = theFolder.toUtfWide();
-    const StStringUtfWide aTitle  = theTitle.toUtfWide();
+    const StStringUtfWide aFolder = theInfo.Folder.toUtfWide();
+    const StStringUtfWide aTitle  = theInfo.Title.toUtfWide();
 
     // use dummy \n symbol instead of NULL-termination symbol \0 inside string
     // because such string will be invalid for StString class
     const StStringUtfWide NULL_CHAR = '\n';
 
-    StStringUtfWide aFilterString;
-    StStringUtfWide anAllSupportedExt;
-    for(size_t aMimeId = 0; aMimeId < theFilter.size(); ++aMimeId) {
-        const StMIME& aMime = theFilter[aMimeId];
+    StStringUtfWide aFilterString, anAllSupportedExt, anExtraSupportedExt;
+    for(size_t aMimeId = 0; aMimeId < theInfo.Filter.size(); ++aMimeId) {
+        const StMIME& aMime = theInfo.Filter[aMimeId];
         if(aMimeId > 0) {
             anAllSupportedExt += StStringUtfWide(';');
         }
@@ -53,15 +49,38 @@
     }
 
     // fill 'All supported'
-    if(!anAllSupportedExt.isEmpty() && theFilter.size() > 1) {
-        aFilterString += StStringUtfWide(L"All supported\n");
+    if(!anAllSupportedExt.isEmpty() && theInfo.Filter.size() > 1) {
+        if(!theInfo.FilterTitle.isEmpty()) {
+            aFilterString += theInfo.FilterTitle.toUtfWide();
+        } else {
+            aFilterString += StStringUtfWide(L"All supported");
+        }
+        aFilterString += StStringUtfWide(L"\n");
         aFilterString += anAllSupportedExt + NULL_CHAR;
     }
 
+    // fill 'Extra supported'
+    for(size_t aMimeId = 0; aMimeId < theInfo.ExtraFilter.size(); ++aMimeId) {
+        const StMIME& aMime = theInfo.ExtraFilter[aMimeId];
+        if(aMimeId > 0) {
+            anExtraSupportedExt += StStringUtfWide(';');
+        }
+        anExtraSupportedExt += StStringUtfWide(L"*.") + aMime.getExtension().toUtfWide();
+    }
+    if(!anExtraSupportedExt.isEmpty() && theInfo.ExtraFilter.size() > 1) {
+        if(!theInfo.ExtraFilterTitle.isEmpty()) {
+            aFilterString += theInfo.ExtraFilterTitle.toUtfWide();
+        } else {
+            aFilterString += StStringUtfWide(L"Extra supported");
+        }
+        aFilterString += StStringUtfWide(L"\n");
+        aFilterString += anExtraSupportedExt + NULL_CHAR;
+    }
+
     // fill MIME types
-    for(size_t aMimeId = 0; aMimeId < theFilter.size(); ++aMimeId) {
-        const StMIME& aMime = theFilter[aMimeId];
-        if((aMimeId > 0) && (aMime.getDescription() == theFilter[aMimeId - 1].getDescription())) {
+    for(size_t aMimeId = 0; aMimeId < theInfo.Filter.size(); ++aMimeId) {
+        const StMIME& aMime = theInfo.Filter[aMimeId];
+        if((aMimeId > 0) && (aMime.getDescription() == theInfo.Filter[aMimeId - 1].getDescription())) {
             // append extension to previous MIME (prevent duplication)
             aFilterString = aFilterString.subString(0, aFilterString.getLength() - 1); // backstep
             aFilterString += StStringUtfWide(L";*.") + aMime.getExtension().toUtfWide() + NULL_CHAR;
@@ -72,7 +91,7 @@
     }
 
     // fill 'Any File'
-    aFilterString += StStringUtfWide(L"Any File (*)\n");
+    aFilterString += StStringUtfWide(L"All Files (*)\n");
     aFilterString += StStringUtfWide(L"*\n"); // last string should be terminated by \0\0
 
     // replace dummy CR symbol within '\0' using 'hack' code
@@ -104,7 +123,7 @@
     anOpenStruct.nMaxFileTitle   = sizeof(aFileTitle);
     anOpenStruct.lpstrTitle      = aTitle.toCString();
     anOpenStruct.Flags = OFN_PATHMUSTEXIST | OFN_FILEMUSTEXIST;
-    if(!toSave) {
+    if(!theToSave) {
         if(GetOpenFileNameW(&anOpenStruct)
         && *anOpenStruct.lpstrFile != L'\0') {
             theFilePath = StString(anOpenStruct.lpstrFile);
@@ -125,17 +144,17 @@
     }
     gdk_threads_enter();
     bool isFileSelected = false;
-    GtkWidget* aDialog = gtk_file_chooser_dialog_new(theTitle.toCString(), NULL, (toSave ? GTK_FILE_CHOOSER_ACTION_SAVE : GTK_FILE_CHOOSER_ACTION_OPEN),
-                                                     GTK_STOCK_CANCEL, GTK_RESPONSE_CANCEL, (toSave ? GTK_STOCK_SAVE : GTK_STOCK_OPEN),
+    GtkWidget* aDialog = gtk_file_chooser_dialog_new(theInfo.Folder.toCString(), NULL, (theToSave ? GTK_FILE_CHOOSER_ACTION_SAVE : GTK_FILE_CHOOSER_ACTION_OPEN),
+                                                     GTK_STOCK_CANCEL, GTK_RESPONSE_CANCEL, (theToSave ? GTK_STOCK_SAVE : GTK_STOCK_OPEN),
                                                      GTK_RESPONSE_ACCEPT, NULL);
-    gtk_file_chooser_set_current_folder(GTK_FILE_CHOOSER(aDialog), theFolder.toCString());
+    gtk_file_chooser_set_current_folder(GTK_FILE_CHOOSER(aDialog), theInfo.Folder.toCString());
     if(!theFilePath.isEmpty()) {
         gtk_file_chooser_set_filename(GTK_FILE_CHOOSER(aDialog), theFilePath.toCString());
     }
 
     GtkFileFilter* gtkFilter = gtk_file_filter_new();
-    for(size_t aMimeId = 0; aMimeId < theFilter.size(); ++aMimeId) {
-        const StMIME& aMime = theFilter[aMimeId];
+    for(size_t aMimeId = 0; aMimeId < theInfo.Filter.size(); ++aMimeId) {
+        const StMIME& aMime = theInfo.Filter[aMimeId];
         gtk_file_filter_add_pattern(gtkFilter, (StString("*.") + aMime.getExtension()).toCString());
     }

sview-17_04.tar.gz/StShared/StFolder.cpp -> sview-20_08.tar.gz/StShared/StFolder.cpp Changed

sview-17_04.tar.gz/StShared/StFormatEnum.cpp -> sview-20_08.tar.gz/StShared/StFormatEnum.cpp Changed

sview-17_04.tar.gz/StShared/StFreeImage.cpp -> sview-20_08.tar.gz/StShared/StFreeImage.cpp Changed

sview-17_04.tar.gz/StShared/StGLContext.cpp -> sview-20_08.tar.gz/StShared/StGLContext.cpp Changed

@@ -1,5 +1,5 @@
 /**
- * Copyright © 2012-2016 Kirill Gavrilov <kirill@sview.ru>
+ * Copyright © 2012-2019 Kirill Gavrilov <kirill@sview.ru>
  *
  * Distributed under the Boost Software License, Version 1.0.
  * See accompanying file license-boost.txt or copy at
@@ -15,6 +15,7 @@
 
 #include <StGLCore/StGLCore44.h>
 #include <StGL/StGLArbFbo.h>
+#include <StGL/StGLTexture.h>
 
 #include <StStrings/StDictionary.h>
 #include <StStrings/StLogger.h>
@@ -51,27 +52,28 @@
   arbFbo(NULL),
   arbNPTW(false),
   arbTexRG(false),
+  arbTexFloat(false),
   arbTexClear(false),
 #if defined(GL_ES_VERSION_2_0)
-  hasUnpack(false),
   hasHighp(false),
   hasTexRGBA8(false),
   extTexBGRA8(false),
+  extTexR16(false),
 #else
-  hasUnpack(true),
   hasHighp(true),
   hasTexRGBA8(true), // always available on desktop
   extTexBGRA8(true),
+  extTexR16(true),
 #endif
   extAll(NULL),
   extSwapTear(false),
+  khrFlushControl(false),
   myFuncs(new StGLFunctions()),
   myResMgr(theResMgr),
   myGlVendor(GlVendor_UNKNOWN),
   myGpuName(GPU_UNKNOWN),
   myVerMajor(0),
   myVerMinor(0),
-  myMaxTexDim(0),
   myWasInit(false),
   myFramebufferDraw(0),
   myFramebufferRead(0),
@@ -84,6 +86,12 @@
 #ifdef __APPLE__
     mySysLib.loadSimple("/System/Library/Frameworks/OpenGL.framework/Versions/Current/OpenGL");
 #endif
+
+#if defined(GL_ES_VERSION_2_0)
+    myDevCaps.hasUnpack = false;
+#else
+    myDevCaps.hasUnpack = true;
+#endif
 }
 
 StGLContext::StGLContext(const bool theToInitialize)
@@ -104,26 +112,27 @@
   arbFbo(NULL),
   arbNPTW(false),
   arbTexRG(false),
+  arbTexFloat(false),
   arbTexClear(false),
 #if defined(GL_ES_VERSION_2_0)
-  hasUnpack(false),
   hasHighp(false),
   hasTexRGBA8(false),
   extTexBGRA8(false),
+  extTexR16(false),
 #else
-  hasUnpack(true), // always available on desktop
   hasHighp(true),
   hasTexRGBA8(true),
   extTexBGRA8(true),
+  extTexR16(true),
 #endif
   extAll(NULL),
   extSwapTear(false),
+  khrFlushControl(false),
   myFuncs(new StGLFunctions()),
   myGlVendor(GlVendor_UNKNOWN),
   myGpuName(GPU_UNKNOWN),
   myVerMajor(0),
   myVerMinor(0),
-  myMaxTexDim(0),
   myWasInit(false),
   myFramebufferDraw(0),
   myFramebufferRead(0),
@@ -136,6 +145,12 @@
 #ifdef __APPLE__
     mySysLib.loadSimple("/System/Library/Frameworks/OpenGL.framework/Versions/Current/OpenGL");
 #endif
+
+#if defined(GL_ES_VERSION_2_0)
+    myDevCaps.hasUnpack = false;
+#else
+    myDevCaps.hasUnpack = true; // always available on desktop
+#endif
     if(theToInitialize) {
         stglInit();
     }
@@ -460,7 +475,7 @@
     theMap.add(StDictEntry("GLdevice",    (const char* )glGetString(GL_RENDERER)));
     theMap.add(StDictEntry("GLversion",   (const char* )glGetString(GL_VERSION)));
     theMap.add(StDictEntry("GLSLversion", (const char* )glGetString(GL_SHADING_LANGUAGE_VERSION)));
-    theMap.add(StDictEntry("Max texture size", myMaxTexDim));
+    theMap.add(StDictEntry("Max texture size", myDevCaps.maxTexDim));
     theMap.add(StDictEntry("Window Info", StString()
             + myViewport.width() + "x" + myViewport.height()
             + " RGB" + myWindowBits.RGB + " A" + myWindowBits.Alpha
@@ -669,8 +684,8 @@
     core11    = (StGLCore11*    )(&(*myFuncs));
     core11fwd = (StGLCore11Fwd* )(&(*myFuncs));
 
-    myMaxTexDim = 2048;
-    glGetIntegerv(GL_MAX_TEXTURE_SIZE, &myMaxTexDim);
+    myDevCaps.maxTexDim = 2048;
+    glGetIntegerv(GL_MAX_TEXTURE_SIZE, &myDevCaps.maxTexDim);
 
 #if !defined(GL_ES_VERSION_2_0)
     bool has12 = false;
@@ -694,7 +709,8 @@
 
     // retrieve platform-dependent extensions
 #if defined(ST_HAVE_EGL)
-    //const char* aEglExts = eglQueryString(eglGetCurrentDisplay(), EGL_EXTENSIONS);
+    const char* anEglExts = eglQueryString(eglGetCurrentDisplay(), EGL_EXTENSIONS);
+    khrFlushControl = stglCheckExtension(anEglExts, "EGL_KHR_context_flush_control");
 #elif defined(_WIN32)
     if(STGL_READ_FUNC(wglGetExtensionsStringARB)) {
         const char* aWglExts = myFuncs->wglGetExtensionsStringARB(wglGetCurrentDC());
@@ -708,6 +724,7 @@
         }
         if(stglCheckExtension(aWglExts, "WGL_ARB_create_context_profile")) {
             STGL_READ_FUNC(wglCreateContextAttribsARB);
+            khrFlushControl = stglCheckExtension(aWglExts, "WGL_ARB_context_flush_control");
         }
         extSwapTear = stglCheckExtension(aWglExts, "WGL_EXT_swap_control_tear");
         if(stglCheckExtension(aWglExts, "WGL_NV_DX_interop")) {
@@ -744,6 +761,7 @@
         STGL_READ_FUNC(glXQueryCurrentRendererStringMESA);
     }
     extSwapTear = stglCheckExtension(aGlxExts, "GLX_EXT_swap_control_tear");
+    khrFlushControl = stglCheckExtension(aGlxExts, "GLX_ARB_context_flush_control");
 #endif
 
 #if defined(GL_ES_VERSION_2_0)
@@ -754,11 +772,13 @@
     hasTexRGBA8 = isGlGreaterEqual(3, 0)
                || stglCheckExtension("GL_OES_rgb8_rgba8");
     extTexBGRA8 = stglCheckExtension("GL_EXT_texture_format_BGRA8888");
+    extTexR16   = stglCheckExtension("GL_EXT_texture_norm16");
     arbTexRG    = isGlGreaterEqual(3, 0)
                || stglCheckExtension("GL_EXT_texture_rg");
+    arbTexFloat = isGlGreaterEqual(3, 0);
     const bool hasFBO = isGlGreaterEqual(2, 0)
                      || stglCheckExtension("GL_OES_framebuffer_object");
-    hasUnpack = isGlGreaterEqual(3, 0);
+    myDevCaps.hasUnpack = isGlGreaterEqual(3, 0);
 
     if(isGlGreaterEqual(2, 0)) {
         // enable compatible functions
@@ -801,8 +821,11 @@
 #else
     hasTexRGBA8 = true;
     extTexBGRA8 = true;
+    extTexR16   = true;
     arbNPTW     = stglCheckExtension("GL_ARB_texture_non_power_of_two");
     arbTexRG    = stglCheckExtension("GL_ARB_texture_rg");
+    arbTexFloat = isGlGreaterEqual(3, 0)
+               || stglCheckExtension("GL_ARB_texture_float");
 
     // load OpenGL 1.2 new functions
     has12 = isGlGreaterEqual(1, 2)
@@ -1609,6 +1632,12 @@
         }*/
     }
 
+    for(int aFormatIter = 0; aFormatIter < StImagePlane::ImgNB; ++aFormatIter) {
+        const StImagePlane::ImgFormat aFormat = (StImagePlane::ImgFormat )aFormatIter;
+        GLint aDummy = 0;
+        myDevCaps.setSupportedFormat(aFormat, StGLTexture::getInternalFormat(*this, aFormat, aDummy));
+    }
+
     // log OpenGL info
     ST_DEBUG_LOG("Created new GL context:\n" + stglFullInfo());

sview-17_04.tar.gz/StShared/StGLFontManager.cpp -> sview-20_08.tar.gz/StShared/StGLFontManager.cpp Changed

@@ -67,10 +67,16 @@
     }
 
     StHandle<StFTFont> aFontFt = new StFTFont(myFTLib);
-    aFontFt->load(aFont.Regular,    StFTFont::Style_Regular);
-    aFontFt->load(aFont.Bold,       StFTFont::Style_Bold);
-    aFontFt->load(aFont.Italic,     StFTFont::Style_Italic);
-    aFontFt->load(aFont.BoldItalic, StFTFont::Style_BoldItalic);
+    const bool hasItalic     = !aFont.Italic.isEmpty();
+    const bool hasBoldItalic = !aFont.BoldItalic.isEmpty();
+    aFontFt->load(aFont.Regular, aFont.RegularFace,    StFTFont::Style_Regular);
+    aFontFt->load(aFont.Bold,    aFont.BoldFace,       StFTFont::Style_Bold);
+    aFontFt->load(hasItalic ? aFont.Italic : aFont.Regular,
+                  hasItalic ? aFont.ItalicFace : aFont.RegularFace,
+                  StFTFont::Style_Italic, !hasItalic);
+    aFontFt->load(hasBoldItalic ? aFont.BoldItalic : aFont.Bold,
+                  hasBoldItalic ? aFont.BoldItalicFace : aFont.BoldFace,
+                  StFTFont::Style_BoldItalic, !hasBoldItalic);
     aFontFt->init(theSize, myResolution);
     aFontGl = new StGLFontEntry(aFontFt);
     return aFontGl;
@@ -107,6 +113,12 @@
     aGenFont                                    = findCreate(aPack.Western.FamilyName, theSize);
     aFont->changeFont(StFTFont::Subset_CJK)     = findCreate(aPack.CJK    .FamilyName, theSize);
     aFont->changeFont(StFTFont::Subset_Korean)  = findCreate(aPack.Korean .FamilyName, theSize);
+    if(aGenFont.isNull() || !aGenFont->hasSubset(StFTFont::Subset_Arabic)) {
+        aFont->changeFont(StFTFont::Subset_Arabic) = findCreate(aPack.Arabic.FamilyName, theSize);
+    }
+    if(aGenFont.isNull() || !aGenFont->hasSubset(StFTFont::Subset_MiscSymbols)) {
+        aFont->changeFont(StFTFont::Subset_MiscSymbols) = findCreate(aPack.MiscSymbols.FamilyName, theSize);
+    }
 
     if(aGenFont.isNull()) {
         aGenFont = findCreateFallback(theSize);

sview-17_04.tar.gz/StShared/StGLProjCamera.cpp -> sview-20_08.tar.gz/StShared/StGLProjCamera.cpp Changed

@@ -18,6 +18,7 @@
 StGLProjCamera::StGLProjCamera()
 : myMatrix(),
   myMatrixMono(),
+  myIsCustomFrust(false),
   myFOVy(45.0f),
   myZoom(1.0f),
   myAspect(1.0f),
@@ -41,6 +42,7 @@
                                const GLfloat theZScreen)
 : myMatrix(),
   myMatrixMono(),
+  myIsCustomFrust(false),
   myFOVy(theFOVy),
   myZoom(1.0f),
   myAspect(1.0f),
@@ -58,6 +60,56 @@
     updateFrustum();
 }
 
+StGLProjCamera::StGLProjCamera(const StGLProjCamera& theOther)
+: myMatrix(theOther.myMatrix),
+  myMatrixMono(theOther.myMatrixMono),
+  myVrFrustumL(theOther.myVrFrustumL),
+  myVrFrustumR(theOther.myVrFrustumR),
+  myIsCustomFrust(theOther.myIsCustomFrust),
+  myFOVy(theOther.myFOVy),
+  myZoom(theOther.myZoom),
+  myAspect(theOther.myAspect),
+  myZScreen(theOther.myZScreen),
+  myIOD(theOther.myIOD),
+  myFrustL(theOther.myFrustL),
+  myFrustR(theOther.myFrustR),
+  myFrustM(theOther.myFrustM),
+  myFrust(NULL),
+  myIsPersp(theOther.myIsPersp) {
+    myFrust = &myFrustM;
+    if(theOther.myFrust == &theOther.myFrustL) {
+        myFrust = &myFrustL;
+    } else if(theOther.myFrust == &theOther.myFrustR) {
+        myFrust = &myFrustR;
+    }
+    updateFrustum();
+}
+
+void StGLProjCamera::copyFrom(const StGLProjCamera& theOther) {
+    myMatrix = theOther.myMatrix;
+    myMatrixMono = theOther.myMatrixMono;
+    myVrFrustumL = theOther.myVrFrustumL;
+    myVrFrustumR = theOther.myVrFrustumR;
+    myIsCustomFrust = theOther.myIsCustomFrust;
+    myFOVy = theOther.myFOVy;
+    myZoom = theOther.myZoom;
+    myAspect = theOther.myAspect;
+    myZScreen = theOther.myZScreen;
+    myIOD = theOther.myIOD;
+    myFrustL = theOther.myFrustL;
+    myFrustR = theOther.myFrustR;
+    myFrustM = theOther.myFrustM;
+    myIsPersp = theOther.myIsPersp;
+
+    myFrust = &myFrustM;
+    if(theOther.myFrust == &theOther.myFrustL) {
+        myFrust = &myFrustL;
+    } else if(theOther.myFrust == &theOther.myFrustR) {
+        myFrust = &myFrustR;
+    }
+    updateFrustum();
+}
+
 void StGLProjCamera::getZParams(const GLdouble theZValue,
                                 StRectD_t&     theSectRect) const {
     if(myIsPersp) {
@@ -94,14 +146,35 @@
     return std::atan2(aDYHalf, myFrustM.zNear * myZoom);
 }
 
+void StGLProjCamera::resetCustomProjection() {
+    myVrFrustumL = StRectF_t();
+    myVrFrustumR = StRectF_t();
+    myIsCustomFrust = false;
+    updateFrustum();
+}
+
+void StGLProjCamera::setCustomProjection(const StRectF_t& theLeft, const StRectF_t& theRight) {
+    myVrFrustumL = theLeft;
+    myVrFrustumR = theRight;
+    myIsCustomFrust = true;
+    updateFrustum();
+}
+
 void StGLProjCamera::updateFrustum() {
     // sets top of frustum based on FOVy and near clipping plane
+    const GLfloat aZNear = myFrustM.zNear;
+    GLfloat aDXStereoShift = (0.5f * myIOD) * aZNear / myZScreen;
+
     GLfloat aDYHalf = myIsPersp
-                    ? (myZoom * myFrustM.zNear * std::tan(ST_DTR_HALF * myFOVy))
-                    : (myZoom * myFrustM.zNear); ///
-    // sets right of frustum based on aspect ratio
+                    ? (myZoom * aZNear * std::tan(ST_DTR_HALF * myFOVy))
+                    : (myZoom * aZNear);
     GLfloat aDXHalf = myAspect * aDYHalf;
-    GLfloat aDXStereoShift = (0.5f * myIOD) * myFrustM.zNear / myZScreen;
+    /*GLfloat aDXHalf = aDYHalf;
+    if(myAspect > 1.0f) {
+        aDXHalf *= myAspect;
+    } else {
+        aDYHalf /= myAspect;
+    }*/
 
     // frustum for left view
     myFrustL.yTop    =  aDYHalf;
@@ -122,6 +195,19 @@
     myFrustM.xRight  =  aDXHalf;
     myFrustM.xTranslation = 0.0f;
 
+    if(myIsCustomFrust) {
+        myFrustL.yTop    = aZNear * myVrFrustumL.top();
+        myFrustL.yBottom = aZNear * myVrFrustumL.bottom();
+        myFrustL.xLeft   = aZNear * myVrFrustumL.left();
+        myFrustL.xRight  = aZNear * myVrFrustumL.right();
+
+        myFrustR.yTop    = aZNear * myVrFrustumR.top();
+        myFrustR.yBottom = aZNear * myVrFrustumR.bottom();
+        myFrustR.xLeft   = aZNear * myVrFrustumR.left();
+        myFrustR.xRight  = aZNear * myVrFrustumR.right();
+        myFrustL.xTranslation = myFrustR.xTranslation = 0.0f;
+    }
+
     // update current matrix
     setupMatrix();
 }

sview-17_04.tar.gz/StShared/StGLQuadTexture.cpp -> sview-20_08.tar.gz/StShared/StGLQuadTexture.cpp Changed

@@ -1,5 +1,5 @@
 /**
- * Copyright © 2009-2012 Kirill Gavrilov <kirill@sview.ru>
+ * Copyright © 2009-2020 Kirill Gavrilov <kirill@sview.ru>
  *
  * Distributed under the Boost Software License, Version 1.0.
  * See accompanying file license-boost.txt or copy at
@@ -19,7 +19,9 @@
 : StGLTexture(GL_RGB8),
 #endif
   myDataSize(1.0f, 1.0f),
-  myDisplayRatio(1.0f) {
+  myDisplayRatio(1.0f),
+  myPAR(1.0f),
+  myPanorama(StPanorama_OFF) {
     //
 }
 
@@ -50,34 +52,43 @@
                                      const GLsizei     theTextureSizeY) {
     // test existing size / new size
     /// TODO (Kirill Gavrilov#8) we can automatically reduce texture size here
-    if((theTexture.getSizeX() < theTextureSizeX) ||
-       (theTexture.getSizeY() < theTextureSizeY) ||
-       !theTexture.isValid()) {
-        ST_DEBUG_LOG("Requested texture size (" + theTextureSizeX + 'x' + theTextureSizeY
-                   + ") larger than current texture size(" + theTexture.getSizeX() + 'x' + theTexture.getSizeY() + ')');
-        const GLsizei anOriginalSizeX = theTexture.getSizeX();
-        const GLsizei anOriginalSizeY = theTexture.getSizeY();
-
-        const GLint aMaxTexDim = theCtx.getMaxTextureSize();
-        GLsizei aNewSizeX = stMin(theTextureSizeX, GLsizei(aMaxTexDim));
-        GLsizei aNewSizeY = stMin(theTextureSizeY, GLsizei(aMaxTexDim));
-        if(!theCtx.arbNPTW) {
-            aNewSizeX = getPowerOfTwo(theTextureSizeX, GLsizei(aMaxTexDim));
-            aNewSizeY = getPowerOfTwo(theTextureSizeY, GLsizei(aMaxTexDim));
+    if(theTexture.isValid()) {
+        if(theTexture.getSizeX() == theTextureSizeX
+        && theTexture.getSizeY() == theTextureSizeY) {
+            return;
         }
-        if((aNewSizeY != anOriginalSizeY)
-        || (aNewSizeX != anOriginalSizeX)) {
-            if(!theTexture.initTrash(theCtx, aNewSizeX, aNewSizeY)) {
-                theTexture.initTrash(theCtx,
-                                     (anOriginalSizeX > 0) ? anOriginalSizeX : 512,
-                                     (anOriginalSizeY > 0) ? anOriginalSizeY : 512);
-                ST_DEBUG_LOG("FAILED to Increase the texture size to (" + aNewSizeX + 'x' +  aNewSizeY + ")!");
-            } else {
-                ST_DEBUG_LOG("Increase the texture size to (" + aNewSizeX + 'x' +  aNewSizeY + ") success!");
-            }
+
+        if(theTexture.getTarget() != GL_TEXTURE_CUBE_MAP
+        && theTexture.getSizeX() >= theTextureSizeX
+        && theTexture.getSizeY() >= theTextureSizeY) {
+            return;
+        }
+    }
+
+    ST_DEBUG_LOG("Requested texture size (" + theTextureSizeX + 'x' + theTextureSizeY
+                + ") larger than current texture size(" + theTexture.getSizeX() + 'x' + theTexture.getSizeY() + ')');
+    const GLsizei anOriginalSizeX = theTexture.getSizeX();
+    const GLsizei anOriginalSizeY = theTexture.getSizeY();
+
+    const GLint aMaxTexDim = theCtx.getMaxTextureSize();
+    GLsizei aNewSizeX = stMin(theTextureSizeX, GLsizei(aMaxTexDim));
+    GLsizei aNewSizeY = stMin(theTextureSizeY, GLsizei(aMaxTexDim));
+    if(!theCtx.arbNPTW) {
+        aNewSizeX = getPowerOfTwo(theTextureSizeX, GLsizei(aMaxTexDim));
+        aNewSizeY = getPowerOfTwo(theTextureSizeY, GLsizei(aMaxTexDim));
+    }
+    if((aNewSizeY != anOriginalSizeY)
+    || (aNewSizeX != anOriginalSizeX)) {
+        if(!theTexture.initTrash(theCtx, aNewSizeX, aNewSizeY)) {
+            theTexture.initTrash(theCtx,
+                                  (anOriginalSizeX > 0) ? anOriginalSizeX : 512,
+                                  (anOriginalSizeY > 0) ? anOriginalSizeY : 512);
+            ST_DEBUG_LOG("FAILED to Increase the texture size to (" + aNewSizeX + 'x' +  aNewSizeY + ")!");
         } else {
-            ST_DEBUG_LOG("Not possible to Increase the texture size!");
+            ST_DEBUG_LOG("Increase the texture size to (" + aNewSizeX + 'x' +  aNewSizeY + ") success!");
         }
+    } else {
+        ST_DEBUG_LOG("Not possible to Increase the texture size!");
     }
 }
 
@@ -100,20 +111,24 @@
 }
 
 void StGLFrameTextures::setMinMagFilter(StGLContext& theCtx,
-                                        const GLenum theMinMagFilter) {
-    myTextures[0].setMinMagFilter(theCtx, theMinMagFilter);
+                                        const GLenum theMinFilter,
+                                        const GLenum theMagFilter) {
+    myTextures[0].setMinMagFilter(theCtx, theMinFilter, theMagFilter);
     /// TODO (Kirill Gavrilov#4) investigate
-    myTextures[1].setMinMagFilter(theCtx, GL_LINEAR);
-    myTextures[2].setMinMagFilter(theCtx, GL_LINEAR);
-    myTextures[3].setMinMagFilter(theCtx, GL_LINEAR);
+    const GLenum aMinFilter = theMinFilter != GL_NEAREST ? theMinFilter : GL_LINEAR;
+    const GLenum aMagFilter = theMagFilter != GL_NEAREST ? theMagFilter : GL_LINEAR;
+    myTextures[1].setMinMagFilter(theCtx, aMinFilter, aMagFilter);
+    myTextures[2].setMinMagFilter(theCtx, aMinFilter, aMagFilter);
+    myTextures[3].setMinMagFilter(theCtx, aMinFilter, aMagFilter);
 }
 
 void StGLQuadTexture::setMinMagFilter(StGLContext& theCtx,
-                                      const GLenum theMinMagFilter) {
-    myTextures[FRONT_TEXTURE +  LEFT_TEXTURE].setMinMagFilter(theCtx, theMinMagFilter);
-    myTextures[FRONT_TEXTURE + RIGHT_TEXTURE].setMinMagFilter(theCtx, theMinMagFilter);
-    myTextures[BACK_TEXTURE  +  LEFT_TEXTURE].setMinMagFilter(theCtx, theMinMagFilter);
-    myTextures[BACK_TEXTURE  + RIGHT_TEXTURE].setMinMagFilter(theCtx, theMinMagFilter);
+                                        const GLenum theMinFilter,
+                                        const GLenum theMagFilter) {
+    myTextures[FRONT_TEXTURE +  LEFT_TEXTURE].setMinMagFilter(theCtx, theMinFilter, theMagFilter);
+    myTextures[FRONT_TEXTURE + RIGHT_TEXTURE].setMinMagFilter(theCtx, theMinFilter, theMagFilter);
+    myTextures[BACK_TEXTURE  +  LEFT_TEXTURE].setMinMagFilter(theCtx, theMinFilter, theMagFilter);
+    myTextures[BACK_TEXTURE  + RIGHT_TEXTURE].setMinMagFilter(theCtx, theMinFilter, theMagFilter);
 }
 
 StGLQuadTexture::StGLQuadTexture()

sview-17_04.tar.gz/StShared/StGLTextFormatter.cpp -> sview-20_08.tar.gz/StShared/StGLTextFormatter.cpp Changed

@@ -1,5 +1,5 @@
 /**
- * Copyright © 2012-2017 Kirill Gavrilov <kirill@sview.ru>
+ * Copyright © 2012-2018 Kirill Gavrilov <kirill@sview.ru>
  *
  * Distributed under the Boost Software License, Version 1.0.
  * See accompanying file license-boost.txt or copy at
@@ -10,6 +10,8 @@
 
 #include <StGL/StGLVertexBuffer.h>
 
+#include <algorithm>
+
 /**
  * Auxiliary function to translate rectangles by the vector.
  */
@@ -395,6 +397,27 @@
     }
 }
 
+void StGLTextFormatter::flipLeftRight(size_t theCharFrom, size_t theCharTo) {
+    if(theCharFrom == theCharTo
+    || theCharTo == size_t(-1)) {
+        return;
+    }
+
+    float aRight = myRects[theCharTo].px.right();
+    for(size_t aCharIter = theCharFrom; aCharIter < theCharTo; ++aCharIter) {
+        StGLRect&       aRect1 = myRects[aCharIter + 0].px;
+        const StGLRect& aRect2 = myRects[aCharIter + 1].px;
+        float aStepX = aRect2.left() - aRect1.left();
+        aRect1.moveRightTo(aRight);
+        aRight -= aStepX;
+    }
+
+    StGLRect& aRectLast = myRects[theCharTo].px;
+    aRectLast.moveRightTo(aRight);
+
+    std::reverse (myRects.begin() + theCharFrom, (theCharTo + 1) == myRects.size() ? myRects.end() : myRects.begin() + theCharTo + 1);
+}
+
 void StGLTextFormatter::format(const GLfloat theWidth,
                                const GLfloat theHeight) {
     if(myRectsNb == 0 || myIsFormatted) {
@@ -412,6 +435,8 @@
     // split text into lines and apply horizontal alignment
     myPenCurrLine = -myAscender;
     size_t aRectIter = 0;
+    size_t aFlipLower = 0, aFlipInnerLower = 0;
+    bool isRight2Left = false, isLeft2RightInner = false;
     for(StUtf8Iter anIter = myString.iterator(); *anIter != 0; ++anIter) {
         const stUtf32_t aCharThis = *anIter;
         if(aCharThis == '\x0D') {
@@ -423,6 +448,14 @@
                 myAlignWidth = myRects[aLastRect].px.right();
                 ///toCorrectXAlignment = true;
             }
+            if(isRight2Left) {
+                if(isLeft2RightInner) {
+                    flipLeftRight(aFlipInnerLower, aLastRect);
+                    isLeft2RightInner = false;
+                }
+                flipLeftRight(aFlipLower, aLastRect);
+                aFlipLower = aLastRect + 1;
+            }
             newLine(aLastRect);
             continue;
         } else if(aCharThis == ' ') {
@@ -430,6 +463,28 @@
             continue;
         }
 
+        if(StFTFont::isRightToLeft(aCharThis)) {
+            if(!isRight2Left) {
+                isRight2Left = true;
+                aFlipLower = aRectIter;
+            } else if(isLeft2RightInner) {
+                flipLeftRight(aFlipInnerLower, aRectIter - 1);
+                isLeft2RightInner = false;
+            }
+        } else if(isRight2Left) {
+            if((aCharThis >= '0' && aCharThis <= '9')
+            || (isLeft2RightInner && (aCharThis == '.' || aCharThis == ','))) {
+                if(!isLeft2RightInner) {
+                    isLeft2RightInner = true;
+                    aFlipInnerLower = aRectIter;
+                }
+            } else {
+                isRight2Left = false;
+                flipLeftRight(aFlipLower, aRectIter - 1);
+                aFlipLower = aRectIter;
+            }
+        }
+
         GLfloat aWidth = myRects[aRectIter].px.right() - myLineLeft;
         myTextWidth = stMax(myTextWidth, aWidth);
         if(theWidth > 0.0f && aWidth >= theWidth) {
@@ -439,6 +494,14 @@
                 aLastRect = aRectIter - 1;
             }
 
+            if(isRight2Left) {
+                if(isLeft2RightInner) {
+                    flipLeftRight(aFlipInnerLower, aLastRect);
+                    isLeft2RightInner = false;
+                }
+                flipLeftRight(aFlipLower, aLastRect);
+                aFlipLower = aLastRect + 1;
+            }
             newLine(aLastRect);
         }
 
@@ -449,6 +512,13 @@
     if(myRectsNb != 0) {
         myTextWidth = stMax(myTextWidth, myRects[myRectsNb - 1].px.right() - myLineLeft);
     }
+    if(isRight2Left) {
+        if(isLeft2RightInner) {
+            flipLeftRight(aFlipInnerLower, myRectsNb - 1);
+            isLeft2RightInner = false;
+        }
+        flipLeftRight(aFlipLower, myRectsNb - 1);
+    }
     newLine(myRectsNb - 1);
     if(myRectsNb != 0
     && myAlignWidth <= 0.0f) {

sview-17_04.tar.gz/StShared/StGLTexture.cpp -> sview-20_08.tar.gz/StShared/StGLTexture.cpp Changed

@@ -1,5 +1,5 @@
 /**
- * Copyright © 2009-2015 Kirill Gavrilov <kirill@sview.ru>
+ * Copyright © 2009-2019 Kirill Gavrilov <kirill@sview.ru>
  *
  * Distributed under the Boost Software License, Version 1.0.
  * See accompanying file license-boost.txt or copy at
@@ -11,48 +11,76 @@
 #include <StImage/StImagePlane.h>
 
 #include <StGLCore/StGLCore20.h>
+#include <StGL/StGLArbFbo.h>
 #include <StGL/StGLContext.h>
 
 #include <StStrings/StLogger.h>
 #include <stAssert.h>
 
-bool StGLTexture::getInternalFormat(const StGLContext&  theCtx,
-                                    const StImagePlane& theData,
-                                    GLint&              theInternalFormat) {
-    (void )theCtx;
-    // sized formats are not supported by OpenGL ES
-    switch(theData.getFormat()) {
+#ifndef GL_R16
+    #define GL_R16      0x822A
+    #define GL_R16F     0x822D
+    #define GL_R32F     0x822E
+    #define GL_RGB16F   0x881B
+    #define GL_RGBA32F  0x8814
+    #define GL_RGB32F   0x8815
+    #define GL_RGBA16F  0x881A
+    #define GL_RGB16F   0x881B
+    #define GL_RGB4     0x804F
+    #define GL_RGB5     0x8050
+    #define GL_RGB8     0x8051
+    #define GL_RGB10    0x8052
+    #define GL_RGB12    0x8053
+    #define GL_RGB16    0x8054
+    #define GL_RGBA8    0x8058
+    #define GL_RGB10_A2 0x8059
+    #define GL_RGBA12   0x805A
+    #define GL_RGBA16   0x805B
+    //#define GL_ALPHA4   0x803B
+    #define GL_ALPHA8   0x803C
+    #define GL_ALPHA16  0x803E
+
+    #define GL_HALF_FLOAT                     0x140B
+    #define GL_UNSIGNED_INT_2_10_10_10_REV    0x8368
+#endif
+
+bool StGLTexture::getInternalFormat(const StGLContext& theCtx,
+                                    const StImagePlane::ImgFormat theFormat,
+                                    GLint& theInternalFormat) {
+    switch(theFormat) {
         case StImagePlane::ImgRGBAF:
-        case StImagePlane::ImgBGRAF:
-        #if defined(GL_ES_VERSION_2_0)
-            theInternalFormat = GL_RGBA;
-        #else
+        case StImagePlane::ImgBGRAF: // BGRA requires texture swizzling on OpenGL ES
             theInternalFormat = GL_RGBA32F;
-        #endif
+            if(!theCtx.arbTexFloat) {
+            #if defined(GL_ES_VERSION_2_0)
+                return false;
+            #else
+                theInternalFormat = GL_RGBA8;
+            #endif
+            }
             return true;
         case StImagePlane::ImgRGBF:
-        case StImagePlane::ImgBGRF:
-        #if defined(GL_ES_VERSION_2_0)
-            theInternalFormat = GL_RGB;
-        #else
+        case StImagePlane::ImgBGRF: // BGR requires texture swizzling on OpenGL ES
             theInternalFormat = GL_RGB32F;
-        #endif
+            if(!theCtx.arbTexFloat) {
+            #if defined(GL_ES_VERSION_2_0)
+                return false;
+            #else
+                theInternalFormat = GL_RGB8;
+            #endif
+            }
             return true;
         case StImagePlane::ImgRGBA:
         case StImagePlane::ImgBGRA:
         #if defined(GL_ES_VERSION_2_0)
-            theInternalFormat = GL_RGBA;
+            theInternalFormat = GL_RGBA; // non-sized for compatibility with OpenGL ES 2.0
         #else
             theInternalFormat = GL_RGBA8;
         #endif
             return true;
         case StImagePlane::ImgRGBA64:
-        #if defined(GL_ES_VERSION_2_0)
-            theInternalFormat = GL_RGBA;
-        #else
-            theInternalFormat = GL_RGBA16;
-        #endif
-            return true;
+            theInternalFormat = theCtx.arbTexRG ? GL_RGBA16 : GL_RGBA8;
+            return theCtx.extTexR16;
         case StImagePlane::ImgRGB: {
             theInternalFormat = GL_RGB8;
             return true;
@@ -68,61 +96,52 @@
         case StImagePlane::ImgBGR: {
             theInternalFormat = GL_RGB8;
         #if defined(GL_ES_VERSION_2_0)
-            return false;
+            return false; // still can be done via swizzling...
         #else
             return true;
         #endif
         }
         case StImagePlane::ImgBGR32:
-        #if defined(GL_ES_VERSION_2_0)
             theInternalFormat = GL_RGB8;
-            if(!theCtx.extTexBGRA8) {
-                return false;
+        #if defined(GL_ES_VERSION_2_0)
+            if(theCtx.extTexBGRA8) {
+                // GL_EXT_texture_format_BGRA8888 has been introduced for OpenGL ES 1.0
+                // and does not defined sized format supported by OpenGL ES 3.0+
+                theInternalFormat = GL_BGRA_EXT;
+            } else {
+                return false; // still can be done via swizzling...
             }
-
-            // GL_EXT_texture_format_BGRA8888 has been introduced for OpenGL ES 1.0
-            // and does not defined sized format supported by OpenGL ES 3.0+
-            theInternalFormat = GL_BGRA_EXT;
-        #else
-            theInternalFormat = GL_RGB8;
         #endif
             return true;
         case StImagePlane::ImgRGB48:
-        #if defined(GL_ES_VERSION_2_0)
-            theInternalFormat = GL_RGB;
-        #else
             theInternalFormat = GL_RGB16;
-        #endif
-            return true;
+            return theCtx.extTexR16;
         case StImagePlane::ImgGrayF:
-        #if defined(GL_ES_VERSION_2_0)
-            theInternalFormat = GL_ALPHA;
-        #else
-            //theInternalFormat = GL_R32F;    // OpenGL3+ hardware
-            //theInternalFormat = GL_ALPHA32F_ARB;
-            theInternalFormat = GL_ALPHA16; // backward compatibility
-        #endif
+            theInternalFormat = GL_R32F;
+            if(!theCtx.arbTexFloat || !theCtx.arbTexRG) {
+            #if defined(GL_ES_VERSION_2_0)
+                return false;
+            #else
+                // there is also GL_ALPHA32F_ARB
+                theInternalFormat = theCtx.arbTexRG ? GL_R16 : GL_ALPHA16;
+            #endif
+            }
             return true;
         case StImagePlane::ImgGray16:
-        #if defined(GL_ES_VERSION_2_0)
-            theInternalFormat = GL_ALPHA;
-        #else
-            //theInternalFormat = GL_R16;   // OpenGL3+ hardware
-            theInternalFormat = GL_ALPHA16; // backward compatibility
+            theInternalFormat = GL_R16; // equals to GL_R16_EXT on OpenGL ES extension
+        #if !defined(GL_ES_VERSION_2_0)
+            theInternalFormat = theCtx.arbTexRG ? GL_R16 : GL_ALPHA16;
         #endif
-            return true;
+            return theCtx.extTexR16;
         case StImagePlane::ImgGray:
         #if defined(GL_ES_VERSION_2_0)
-            theInternalFormat = GL_ALPHA;
+            theInternalFormat = theCtx.arbTexRG ? GL_R8 : GL_ALPHA;
         #else
-            // this texture format is deprecated with OpenGL3+, use GL_R8 (GL_RED) instead
-            //theInternalFormat = GL_R8;   // OpenGL3+ hardware
-            theInternalFormat = GL_ALPHA8; // backward compatibility
+            theInternalFormat = theCtx.arbTexRG ? GL_R8 : GL_ALPHA8;
         #endif
             return true;
         case StImagePlane::ImgUV:
-            // this texture format is deprecated with OpenGL3+, use GL_R8 (GL_RED) instead
-            //theInternalFormat = GL_RG8;   // OpenGL3+ hardware
+            //theInternalFormat = theCtx.arbTexRG ? GL_RG8 : GL_LUMINANCE_ALPHA; // OpenGL3+
             theInternalFormat = GL_LUMINANCE_ALPHA;
             return true;
         default:
@@ -134,28 +153,21 @@
                                 const StImagePlane& theData,
                                 GLenum& thePixelFormat,
                                 GLenum& theDataType) {
-#if !defined(GL_ES_VERSION_2_0)
-    (void )theCtx;
-#endif
     thePixelFormat = GL_RGB;
     theDataType    = GL_UNSIGNED_BYTE;
     switch(theData.getFormat()) {
         case StImagePlane::ImgGray: {
-            // we fill ALPHA channel in the texture!
-            //thePixelFormat = GL_RED;
-            thePixelFormat = GL_ALPHA;
+            thePixelFormat = theCtx.arbTexRG ? GL_RED : GL_ALPHA;
             theDataType = GL_UNSIGNED_BYTE;
             return true;
         }
         case StImagePlane::ImgGray16: {
-            // we fill ALPHA channel in the texture!
-            //thePixelFormat = GL_RED;
-            thePixelFormat = GL_ALPHA;
+            thePixelFormat = theCtx.arbTexRG ? GL_RED : GL_ALPHA;
             theDataType = GL_UNSIGNED_SHORT;
             return true;
         }
         case StImagePlane::ImgUV: {
-            //thePixelFormat = GL_RG;
+            //thePixelFormat = theCtx.arbTexRG ? GL_RG : GL_LUMINANCE_ALPHA;
             thePixelFormat = GL_LUMINANCE_ALPHA;
             theDataType = GL_UNSIGNED_BYTE;
             return true;
@@ -204,8 +216,7 @@
             return true;
         }
         case StImagePlane::ImgGrayF: {
-            //thePixelFormat = GL_RED;
-            thePixelFormat = GL_ALPHA;
+            thePixelFormat = theCtx.arbTexRG ? GL_RED : GL_ALPHA;
             theDataType = GL_FLOAT;
             return true;
         }
@@ -241,30 +252,6 @@
     }
 }
 
-#ifndef GL_R16
-    #define GL_R16      0x822A
-    #define GL_R16F     0x822D
-    #define GL_R32F     0x822E
-    #define GL_RGB16F   0x881B
-    #define GL_RGBA32F  0x8814
-    #define GL_RGB32F   0x8815
-    #define GL_RGBA16F  0x881A
-    #define GL_RGB16F   0x881B
-    #define GL_RGB4     0x804F
-    #define GL_RGB5     0x8050
-    #define GL_RGB8     0x8051
-    #define GL_RGB10    0x8052
-    #define GL_RGB12    0x8053
-    #define GL_RGB16    0x8054
-    #define GL_RGBA8    0x8058
-    #define GL_RGB10_A2 0x8059
-    #define GL_RGBA12   0x805A
-    #define GL_RGBA16   0x805B
-    //#define GL_ALPHA4   0x803B
-    #define GL_ALPHA8   0x803C
-    #define GL_ALPHA16  0x803E
-#endif
-
 bool StGLTexture::isAlphaFormat(const GLint theInternalFormat) {
     switch(theInternalFormat) {
         // RED variations (GL_RED, OpenGL 3.0+)
@@ -371,6 +358,49 @@
     }
 }
 
+/**
+ * Return appropriate data type for specified internal format.
+ */
+static GLenum getDataType(GLint theInternalFormat) {
+    switch(theInternalFormat) {
+        case GL_RED:
+        case GL_R8:
+        case GL_RGB:
+        case GL_RGB8:
+        case GL_RGBA:
+        case GL_RGBA8:
+        case GL_BGRA_EXT:
+        case GL_ALPHA:
+        case GL_ALPHA8:
+        case GL_LUMINANCE:
+        case GL_LUMINANCE_ALPHA:
+            return GL_UNSIGNED_BYTE;
+        case GL_R16:
+        case GL_RGB16:
+        case GL_RGBA16:
+        case GL_ALPHA16:
+            return GL_UNSIGNED_SHORT;
+        case GL_R16F:
+        case GL_RGB16F:
+        case GL_RGBA16F:
+            return GL_HALF_FLOAT;
+        case GL_R32F:
+        case GL_RGB32F:
+        case GL_RGBA32F:
+            return GL_FLOAT;
+        /*case GL_RGB4:
+        case GL_RGB5:
+        case GL_RGB10:
+        case GL_RGB12:
+        case GL_RGBA12:
+            return GL_UNSIGNED_BYTE;*/
+        case GL_RGB10_A2:
+            return GL_UNSIGNED_INT_2_10_10_10_REV;
+        default:
+            return GL_UNSIGNED_BYTE;
+    }
+}
+
 StGLTexture::StGLTexture()
 : mySizeX(0),
   mySizeY(0),
@@ -378,7 +408,9 @@
   myTextFormat(GL_RGBA8),
   myTextureId(NO_TEXTURE),
   myTextureUnit(GL_TEXTURE0),
-  myTextureFilt(GL_LINEAR) {
+  myFilterMin(GL_LINEAR),
+  myFilterMag(GL_LINEAR),
+  myHasMipMaps(0) {
     //
 }
 
@@ -389,7 +421,9 @@
   myTextFormat(theTextureFormat),
   myTextureId(NO_TEXTURE),
   myTextureUnit(GL_TEXTURE0),
-  myTextureFilt(GL_LINEAR) {
+  myFilterMin(GL_LINEAR),
+  myFilterMag(GL_LINEAR),
+  myHasMipMaps(0) {
     //
 }
 
@@ -490,14 +524,15 @@
     theCtx.stglResetErrors();
 #endif
 
+    myHasMipMaps = 0;
     if(!isValid()) {
         theCtx.core20fwd->glGenTextures(1, &myTextureId); // Create The Texture
     }
     bind(theCtx);
 
     // texture interpolation parameters - could be overridden later
-    theCtx.core20fwd->glTexParameteri(myTarget, GL_TEXTURE_MAG_FILTER, myTextureFilt);
-    theCtx.core20fwd->glTexParameteri(myTarget, GL_TEXTURE_MIN_FILTER, myTextureFilt);
+    theCtx.core20fwd->glTexParameteri(myTarget, GL_TEXTURE_MIN_FILTER, myFilterMin);
+    theCtx.core20fwd->glTexParameteri(myTarget, GL_TEXTURE_MAG_FILTER, myFilterMag);
     theCtx.core20fwd->glTexParameteri(myTarget, GL_TEXTURE_WRAP_S,     GL_CLAMP_TO_EDGE);
     theCtx.core20fwd->glTexParameteri(myTarget, GL_TEXTURE_WRAP_T,     GL_CLAMP_TO_EDGE);
 
@@ -506,9 +541,12 @@
         return false;
     }
 
+    // NULL is passed to glTexImage2D(), so that there is no actual data to be interpreted.
+    // However, OpenGL ES raises GL_INVALID_OPERATION if invalid type is passed.
+    const GLenum aDataType = getDataType(myTextFormat);
     GLint anInternalFormat = myTextFormat;
 #if defined(GL_ES_VERSION_2_0)
-    if(!theCtx.isGlGreaterEqual(3, 0)) {
+    if(!theCtx.isGlGreaterEqual(3, 0) && aDataType == GL_UNSIGNED_BYTE) {
         // sized formats are not supported here
         anInternalFormat = theDataFormat;
     }
@@ -524,12 +562,12 @@
         for(int aTargetIter = 0; aTargetIter < 6; ++aTargetIter) {
             theCtx.core20fwd->glTexImage2D(aTargets[aTargetIter], 0, anInternalFormat,
                                        mySizeX, mySizeY, 0,
-                                       theDataFormat, GL_UNSIGNED_BYTE, theData);
+                                       theDataFormat, aDataType, theData);
         }
     } else {
         theCtx.core20fwd->glTexImage2D(myTarget, 0, anInternalFormat,
                                        mySizeX, mySizeY, 0,
-                                       theDataFormat, GL_UNSIGNED_BYTE, theData);
+                                       theDataFormat, aDataType, theData);
     }
 #if defined(GL_ES_VERSION_2_0)
     // proxy texture is unavailable - check for errors
@@ -568,17 +606,40 @@
 }
 
 void StGLTexture::setMinMagFilter(StGLContext& theCtx,
-                                  const GLenum theMinMagFilter) {
-    if(!isValid()) {
-        myTextureFilt = theMinMagFilter;
+                                  const GLenum theMinFilter,
+                                  const GLenum theMagFilter) {
+    const bool needsMipMaps = theMinFilter != GL_NEAREST
+                           && theMinFilter != GL_LINEAR;
+    if(myFilterMin == theMinFilter
+    && myFilterMag == theMagFilter
+    && (!needsMipMaps || myHasMipMaps != 0)) {
         return;
-    } else if(myTextureFilt == theMinMagFilter) {
+    }
+
+    myFilterMin = theMinFilter;
+    myFilterMag = theMagFilter;
+    if(!isValid()) {
         return;
     }
-    myTextureFilt = theMinMagFilter;
+
     bind(theCtx);
-        theCtx.core20fwd->glTexParameteri(myTarget, GL_TEXTURE_MAG_FILTER, myTextureFilt);
-        theCtx.core20fwd->glTexParameteri(myTarget, GL_TEXTURE_MIN_FILTER, myTextureFilt);
+        if(needsMipMaps && myHasMipMaps == 0) {
+            theCtx.arbFbo->glGenerateMipmap(myTarget);
+            const GLenum anErr = glGetError();
+            if(anErr != GL_NO_ERROR) {
+                // note that OpenGL ES 2.0 does not support mip-map generation of non-power-of-two textures
+                ST_ERROR_LOG("Failed to generate mipmap levels with error " + theCtx.stglErrorToString(anErr));
+                myHasMipMaps = -1;
+            } else {
+                myHasMipMaps = 1;
+            }
+        }
+        GLenum aMinFilter = !needsMipMaps || myHasMipMaps == 1
+                          ? myFilterMin
+                          : GL_LINEAR;
+        theCtx.core20fwd->glTexParameteri(myTarget, GL_TEXTURE_MIN_FILTER, aMinFilter);
+        theCtx.core20fwd->glTexParameteri(myTarget, GL_TEXTURE_MAG_FILTER, myFilterMag);
+
     unbind(theCtx);
 }
 
@@ -595,6 +656,19 @@
 
 bool StGLTexture::fillPatch(StGLContext&        theCtx,
                             const StImagePlane& theData,
+                            const GLenum        theTarget,
+                            const GLsizei       theRowFrom,
+                            const GLsizei       theRowTo) {
+#ifdef __ANDROID__
+    GLsizei aBatchRows = 0;
+#else
+    GLsizei aBatchRows = 128; // TODO does it makes sense nowadays?
+#endif
+    return fillPatch(theCtx, theData, theTarget, theRowFrom, theRowTo, aBatchRows);
+}
+
+bool StGLTexture::fillPatch(StGLContext&        theCtx,
+                            const StImagePlane& theData,
                             GLenum              theTarget,
                             const GLsizei       theRowFrom,
                             const GLsizei       theRowTo,
@@ -605,6 +679,7 @@
     if(theData.isNull() || !isValid()) {
         return false;
     }
+
     GLenum aPixelFormat, aDataType;
     if(!getDataFormat(theCtx, theData, aPixelFormat, aDataType)) {
         return false;
@@ -620,6 +695,7 @@
         return false;
     }
 
+    myHasMipMaps = 0;
     bind(theCtx);
 
     // setup the alignment
@@ -639,13 +715,13 @@
         toBatchCopy  = false;
     }
 
-    if(!theCtx.hasUnpack
+    if(!theCtx.getDeviceCaps().hasUnpack
     && anExtraBytes >= anAligment) {
         toBatchCopy = false;
     }
 
     if(toBatchCopy) {
-        if(theCtx.hasUnpack) {
+        if(theCtx.getDeviceCaps().hasUnpack) {
             theCtx.core20fwd->glPixelStorei(GL_UNPACK_ROW_LENGTH, GLint(aPixelsWidth));
         }
 
@@ -667,12 +743,12 @@
                                               theData.getData(aRow, 0));
         }
 
-        if(theCtx.hasUnpack) {
+        if(theCtx.getDeviceCaps().hasUnpack) {
             theCtx.core20fwd->glPixelStorei(GL_UNPACK_ROW_LENGTH, 0);
         }
     } else {
         // copy row by row copy (the image plane greater than texture or batch copy is impossible)
-        if(theCtx.hasUnpack) {
+        if(theCtx.getDeviceCaps().hasUnpack) {
             theCtx.core20fwd->glPixelStorei(GL_UNPACK_ROW_LENGTH, 0);
         }

sview-17_04.tar.gz/StShared/StGLTextureData.cpp -> sview-20_08.tar.gz/StShared/StGLTextureData.cpp Changed

@@ -1,5 +1,5 @@
 /**
- * Copyright © 2009-2015 Kirill Gavrilov <kirill@sview.ru>
+ * Copyright © 2009-2020 Kirill Gavrilov <kirill@sview.ru>
  *
  * Distributed under the Boost Software License, Version 1.0.
  * See accompanying file license-boost.txt or copy at
@@ -10,8 +10,11 @@
 #include <StStrings/StLogger.h>
 
 #include <StGLCore/StGLCore11.h>
+#include <StGL/StGLContext.h>
 
-StGLTextureData::StGLTextureData()
+#include <StAV/StAVImage.h>
+
+StGLTextureData::StGLTextureData(const StHandle<StGLTextureUploadParams>& theUploadParams)
 : myPrev(NULL),
   myNext(NULL),
   myDataPtr(NULL),
@@ -20,6 +23,7 @@
   myPts(0.0),
   mySrcFormat(StFormat_AUTO),
   myCubemapFormat(StCubemap_OFF),
+  myUploadParams(theUploadParams),
   myFillFromRow(0),
   myFillRows(0) {
     //
@@ -316,10 +320,18 @@
             theCoeffX = 6;
             theCoeffY = 1;
             return true;
+        } else if(thePlane.getSizeY() / 6 == thePlane.getSizeX()) {
+            theCoeffX = 1;
+            theCoeffY = 6;
+            return true;
         } else if(thePlane.getSizeX() / 3 == thePlane.getSizeY() / 2) {
             theCoeffX = 3;
             theCoeffY = 2;
             return true;
+        } else if(thePlane.getSizeX() / 2 == thePlane.getSizeY() / 3) {
+            theCoeffX = 2;
+            theCoeffY = 3;
+            return true;
         }
         return false;
     }
@@ -589,12 +601,17 @@
 }
 
 void StGLTextureData::validateCubemap(const StCubemap theCubemap) {
-    if(theCubemap != StCubemap_Packed) {
+    if(theCubemap != StCubemap_Packed
+    && theCubemap != StCubemap_PackedEAC) {
         myCubemapFormat = StCubemap_OFF;
         return;
     }
 
     myCubemapFormat = theCubemap;
+    if(theCubemap == StCubemap_PackedEAC) {
+        return;
+    }
+
     size_t aCoeffs[2] = {0, 0};
     if(!myDataL.isNull()) {
         for(size_t aPlaneId = 0; aPlaneId < 4; ++aPlaneId) {
@@ -623,50 +640,168 @@
         return;
     }
 
-    if(myCubemapFormat != StCubemap_Packed) {
+    if(myCubemapFormat != StCubemap_Packed
+    && myCubemapFormat != StCubemap_PackedEAC) {
         theFrameTexture.fillPatch(theCtx, theData, GL_TEXTURE_2D, myFillFromRow, myFillFromRow + myFillRows);
         return;
     }
 
     size_t aCoeffs[2] = {0, 0};
-    if(!checkCubeMap(theData, aCoeffs[0], aCoeffs[1])) {
-        return;
+    if(myCubemapFormat == StCubemap_PackedEAC) {
+        if(theData.getSizeX() > theData.getSizeY()) {
+            aCoeffs[0] = 3;
+            aCoeffs[1] = 2;
+        } else {
+            aCoeffs[0] = 2;
+            aCoeffs[1] = 3;
+        }
+    } else {
+        if(!checkCubeMap(theData, aCoeffs[0], aCoeffs[1])) {
+            return;
+        }
     }
 
-    const size_t aPatch = theData.getSizeX() / aCoeffs[0];
-    if(aPatch < 2) {
+    const size_t aPatchX = theData.getSizeX() / aCoeffs[0];
+    const size_t aPatchY = theData.getSizeY() / aCoeffs[1];
+    if(aPatchX < 2 || aPatchY < 2) {
         return;
     }
 
-    const GLenum aTargets[6] = { GL_TEXTURE_CUBE_MAP_POSITIVE_X,
-                                 GL_TEXTURE_CUBE_MAP_NEGATIVE_X,
-                                 GL_TEXTURE_CUBE_MAP_POSITIVE_Y,
-                                 GL_TEXTURE_CUBE_MAP_NEGATIVE_Y,
-                                 GL_TEXTURE_CUBE_MAP_POSITIVE_Z,
-                                 GL_TEXTURE_CUBE_MAP_NEGATIVE_Z };
+    static const GLenum THE_SIDES_GL[6] = { GL_TEXTURE_CUBE_MAP_POSITIVE_X, GL_TEXTURE_CUBE_MAP_NEGATIVE_X,
+                                            GL_TEXTURE_CUBE_MAP_POSITIVE_Y, GL_TEXTURE_CUBE_MAP_NEGATIVE_Y,
+                                            GL_TEXTURE_CUBE_MAP_POSITIVE_Z, GL_TEXTURE_CUBE_MAP_NEGATIVE_Z };
+    static const GLenum THE_SIDES_EAC32[6] = { GL_TEXTURE_CUBE_MAP_POSITIVE_X, GL_TEXTURE_CUBE_MAP_NEGATIVE_Z, GL_TEXTURE_CUBE_MAP_NEGATIVE_X,
+                                               GL_TEXTURE_CUBE_MAP_NEGATIVE_Y, GL_TEXTURE_CUBE_MAP_POSITIVE_Z, GL_TEXTURE_CUBE_MAP_POSITIVE_Y };
+    static const GLenum THE_SIDES_EAC23[6] = { GL_TEXTURE_CUBE_MAP_NEGATIVE_X, GL_TEXTURE_CUBE_MAP_POSITIVE_Y,
+                                               GL_TEXTURE_CUBE_MAP_NEGATIVE_Z, GL_TEXTURE_CUBE_MAP_POSITIVE_Z,
+                                               GL_TEXTURE_CUBE_MAP_POSITIVE_X, GL_TEXTURE_CUBE_MAP_NEGATIVE_Y };
+
+    const GLenum* aTargets = myCubemapFormat == StCubemap_PackedEAC
+                           ? (aCoeffs[1] == 3 ? THE_SIDES_EAC23 : THE_SIDES_EAC32)
+                           : THE_SIDES_GL;
     for(size_t aTargetIter = 0; aTargetIter < 6; ++aTargetIter) {
         StImagePlane aPlane;
-        const bool isSecondRow = (aCoeffs[1] == 2 && aTargetIter >= 3);
-        const size_t aLeft = isSecondRow ? (aPatch * (aTargetIter - 3)) : (aPatch * aTargetIter);
-        const size_t aTop  = isSecondRow ? aPatch : 0;
+        size_t aTop = 0, aLeft = 0;
+        bool toTranspose = false;
+        switch(aCoeffs[1]) {
+            case 1: { // 6x1
+                aLeft = aPatchX * aTargetIter;
+                aTop  = 0;
+                break;
+            }
+            case 2: { // 3x2
+                if(aTargetIter >= 3) {
+                    // second row
+                    aLeft = aPatchX * (aTargetIter - 3);
+                    aTop  = aPatchY;
+                    if(myCubemapFormat == StCubemap_PackedEAC) {
+                        toTranspose = true;
+                    }
+                } else {
+                    // first row
+                    aLeft = aPatchX * aTargetIter;
+                    aTop  = 0;
+                }
+                break;
+            }
+            case 3: { // 2x3
+                if(aTargetIter >= 4) {
+                    // third row
+                    aLeft = aPatchX * (aTargetIter - 4);
+                    aTop  = aPatchY * 2;
+                } else if(aTargetIter >= 2) {
+                    // second row
+                    aLeft = aPatchX * (aTargetIter - 2);
+                    aTop  = aPatchY;
+                } else {
+                    // first row
+                    aLeft = aPatchX * aTargetIter;
+                    aTop  = 0;
+                }
+
+                if(myCubemapFormat == StCubemap_PackedEAC
+                && (aTargetIter % 2) == 0) {
+                    toTranspose = true;
+                }
+                break;
+            }
+            case 6: { // 1x6
+                aLeft = 0;
+                aTop  = aPatchY * aTargetIter;
+                break;
+            }
+        }
         if(!aPlane.initWrapper(theData.getFormat(), const_cast<GLubyte* >(theData.getData(aTop, aLeft)),
-                               aPatch, aPatch, theData.getSizeRowBytes())) {
+                               aPatchX, aPatchY, theData.getSizeRowBytes())) {
             ST_DEBUG_LOG("StGLTextureData::fillTexture(). wrapping failure");
             continue;
         }
-        theFrameTexture.fillPatch(theCtx, aPlane, aTargets[aTargetIter], myFillFromRow, myFillFromRow + myFillRows);
+
+        StImagePlane* aResPlane = &aPlane;
+
+        // this is too slow without multi-threading
+        (void )toTranspose;
+        /*if(toTranspose) {
+            StImagePlane& aTmpPlane = theCtx.getTmpImagePlane1();
+            aTmpPlane.initTransposedCopy(aPlane, aCoeffs[1] != 3);
+            aResPlane = &aTmpPlane;
+        }
+
+        if(aPatchX != aPatchY) {
+            size_t aPatch = stMax(aPatchX, aPatchY);
+            StImagePlane& aTmpPlane2 = theCtx.getTmpImagePlane2();
+            if(aTmpPlane2.getFormat() != aResPlane->getFormat()
+            || aTmpPlane2.getSizeX() != aResPlane->getSizeX()
+            || aTmpPlane2.getSizeY() != aResPlane->getSizeY()) {
+                aTmpPlane2.initTrash(aResPlane->getFormat(), aPatch, aPatch);
+            }
+            if(!aTmpPlane2.isNull()) {
+                StAVImage::resizePlane(*aResPlane, aTmpPlane2);
+                aResPlane = &aTmpPlane2;
+            }
+        }*/
+
+        theFrameTexture.fillPatch(theCtx, *aResPlane, aTargets[aTargetIter], myFillFromRow, myFillFromRow + myFillRows);
     }
 }
 
-static void setupDataRectangle(const StImagePlane& theImagePlane,
-                               const GLfloat       thePixelRatio,
-                               StGLFrameTexture&   theTextureFrame) {
+void StGLTextureData::setupDataRectangle(const StImagePlane& theImagePlane,
+                                         const GLfloat       thePixelRatio,
+                                         StGLFrameTexture&   theTextureFrame) {
     if(theImagePlane.isNull() || !theTextureFrame.isValid()) {
         return;
     }
 
-    const GLfloat aSizeXFloat = stMin(GLfloat(theImagePlane.getSizeX()), GLfloat(theTextureFrame.getSizeX()));
-    const GLfloat aSizeYFloat = stMin(GLfloat(theImagePlane.getSizeY()), GLfloat(theTextureFrame.getSizeY()));
+    size_t anImgSizeX = theImagePlane.getSizeX();
+    size_t anImgSizeY = theImagePlane.getSizeY();
+
+    StPanorama aPano = StPanorama_OFF;
+    size_t aCoeffs[2] = {0, 0};
+    if(myCubemapFormat == StCubemap_Packed
+    && checkCubeMap(theImagePlane, aCoeffs[0], aCoeffs[1])) {
+        anImgSizeX = anImgSizeX / aCoeffs[0];
+        anImgSizeY = anImgSizeY / aCoeffs[1];
+        switch(aCoeffs[0]) {
+            case 1: aPano = StPanorama_Cubemap1_6; break;
+            case 3: aPano = StPanorama_Cubemap3_2; break;
+            case 6: aPano = StPanorama_Cubemap6_1; break;
+        }
+    } else if(myCubemapFormat == StCubemap_PackedEAC) {
+        if(theImagePlane.getSizeX() > theImagePlane.getSizeY()) {
+            aCoeffs[0] = 3;
+            aCoeffs[1] = 2;
+            aPano = StPanorama_Cubemap3_2ytb;
+        } else {
+            aCoeffs[0] = 2;
+            aCoeffs[1] = 3;
+            aPano = StPanorama_Cubemap2_3ytb;
+        }
+        anImgSizeX = anImgSizeX / aCoeffs[0];
+        anImgSizeY = anImgSizeY / aCoeffs[1];
+    }
+
+    const GLfloat aSizeXFloat = stMin(GLfloat(anImgSizeX), GLfloat(theTextureFrame.getSizeX()));
+    const GLfloat aSizeYFloat = stMin(GLfloat(anImgSizeY), GLfloat(theTextureFrame.getSizeY()));
     StGLVec2 aDataSize (aSizeXFloat / GLfloat(theTextureFrame.getSizeX()),
                         aSizeYFloat / GLfloat(theTextureFrame.getSizeY()));
     if(aDataSize.x() > 1.0f) {
@@ -677,6 +812,8 @@
     }
     theTextureFrame.setDataSize(aDataSize);
     theTextureFrame.setDisplayRatio((thePixelRatio * aSizeXFloat) / aSizeYFloat);
+    theTextureFrame.setPixelRatio(thePixelRatio);
+    theTextureFrame.setPackedPanorama(aPano);
 }
 
 void StGLTextureData::setupAttributes(StGLFrameTextures& stFrameTextures, const StImage& theImage) {
@@ -701,7 +838,7 @@
             continue;
         }
 
-        if(!StGLTexture::getInternalFormat(theCtx, anImgPlane, anInternalFormat)) {
+        if(!StGLTexture::getInternalFormat(theCtx, anImgPlane.getFormat(), anInternalFormat)) {
             aTexture.release(theCtx);
             continue;
         }
@@ -717,6 +854,23 @@
             aTarget = GL_TEXTURE_CUBE_MAP;
             aSizeX  = aSizeX / GLsizei(aCoeffs[0]);
             aSizeY  = aSizeY / GLsizei(aCoeffs[1]);
+            if(aSizeX < 1) {
+                aTexture.release(theCtx);
+                continue;
+            }
+            aSizeX  = stMax(aSizeX, aSizeY); // cubemap requires squared images
+            aSizeY  = stMax(aSizeX, aSizeY);
+        } else if(theCubemap == StCubemap_PackedEAC) {
+            if(aSizeX > aSizeY) {
+                aSizeX /= 3;
+                aSizeY /= 2;
+            } else {
+                aSizeX /= 2;
+                aSizeY /= 3;
+            }
+            aTarget = GL_TEXTURE_CUBE_MAP;
+            aSizeX  = stMax(aSizeX, aSizeY); // cubemap requires squared images
+            aSizeY  = stMax(aSizeX, aSizeY);
         }
         if(aSizeX < 1) {
             aTexture.release(theCtx);
@@ -743,16 +897,38 @@
         theQTexture.getBack(StGLQuadTexture::LEFT_TEXTURE).setSource(StHandle<StStereoParams>());
         theQTexture.getBack(StGLQuadTexture::RIGHT_TEXTURE).setSource(StHandle<StStereoParams>());
 
-        // TODO (Kirill Gavrilov#9) this value is meanfull only for PageFlip,
-        //                          also rows number may be replaced with bytes count
-        static const GLsizei UPDATED_ROWS_MAX = 1088; // we use optimal value to update 1080p video frame at-once
-        GLsizei maxRows    = stMin(GLsizei(myDataL.getSizeY()), theQTexture.getBack(StGLQuadTexture::LEFT_TEXTURE).getSizeY());
-        GLsizei iterations = (maxRows / (UPDATED_ROWS_MAX * 2)) + 1;
-        if(!myDataR.isNull()) {
-            maxRows    = stMax(maxRows, stMin(GLsizei(myDataR.getSizeY()), theQTexture.getBack(StGLQuadTexture::RIGHT_TEXTURE).getSizeY()));
-            iterations = maxRows / UPDATED_ROWS_MAX + 1;
+        const int aNbRowsL = stMin(int(myDataL.getSizeY()), theQTexture.getBack(StGLQuadTexture::LEFT_TEXTURE).getSizeY());
+        const int aNbRowsR = !myDataR.isNull()
+                           ? stMin(int(myDataR.getSizeY()), theQTexture.getBack(StGLQuadTexture::RIGHT_TEXTURE).getSizeY())
+                           : 0;
+        const int aNbMaxRows = stMax(aNbRowsL, aNbRowsR);
+
+        const int aMaxUploadChunkMiB   = myUploadParams->MaxUploadChunkMiB;
+        const int aMaxUploadIterations = myUploadParams->MaxUploadIterations;
+        int aNbIters = 1;
+        if(aMaxUploadChunkMiB > 0 && aMaxUploadIterations > 1) {
+            size_t aStride = 0;
+            for(int aPlaneIter = 0; aPlaneIter < 4; ++aPlaneIter) {
+                const StImagePlane& aPlaneL = myDataL.getPlane(aPlaneIter);
+                if(!aPlaneL.isNull()) {
+                    // don't use aPlane.getSizeRowBytes() here since it may contain extra padding for side-by-side input
+                    aStride += aPlaneL.getSizeX() * aPlaneL.getSizePixelBytes();
+                }
+                if(!myDataR.isNull()) {
+                    const StImagePlane& aPlaneR = myDataR.getPlane(aPlaneIter);
+                    if(!aPlaneR.isNull()) {
+                        aStride += aPlaneR.getSizeX() * aPlaneR.getSizePixelBytes();
+                    }
+                }
+            }
+
+            const int aNbMaxFrameRows = int((size_t(aMaxUploadChunkMiB) * 1024 * 1024) / aStride);
+            aNbIters = stMin(aMaxUploadIterations, aNbMaxRows / aNbMaxFrameRows);
+        }
+        myFillRows = (aNbIters > 0) ? (aNbMaxRows / aNbIters) : aNbMaxRows;
+        if(myCubemapFormat == StCubemap_Packed || myCubemapFormat == StCubemap_PackedEAC) {
+            myFillRows = INT_MAX; /// TODO handle cube maps incremental updates specificall
         }
-        myFillRows = maxRows / iterations;
         myFillFromRow = 0;
     }

sview-17_04.tar.gz/StShared/StGLTextureQueue.cpp -> sview-20_08.tar.gz/StShared/StGLTextureQueue.cpp Changed

@@ -23,14 +23,22 @@
   myIsInUpdTexture(false),
   myIsReadyToSwap(false),
   myToCompress(false),
-  myHasStream(false) {
+  myHasStream(false),
+  myUploadParams(new StGLTextureUploadParams()) {
     ST_ASSERT(myQueueSizeMax >= 2, "StGLTextureQueue() - queue size limit should be >= 2");
+    // 1920x1080@YUV420p   ~  3 MiB
+    // 1920x1080@RGB8      ~  6 MiB
+    // 3840x2160@YUV420p   ~ 12 MiB
+    // 3840x2160@RGB8      ~ 24 MiB
+    // 3840x2160@YUV420p16 ~ 24 MiB
+    myUploadParams->MaxUploadChunkMiB   = 6;
+    myUploadParams->MaxUploadIterations = 1;
 
     // we create 'empty' queue
-    myDataFront = new StGLTextureData();
+    myDataFront = new StGLTextureData(myUploadParams);
     StGLTextureData* iter = myDataFront;
     for(size_t i = 1; i < myQueueSizeMax; ++i) {
-        iter->setNext(new StGLTextureData());
+        iter->setNext(new StGLTextureData(myUploadParams));
         iter = iter->getNext();
     }
     iter->setNext(myDataFront); // data in loop
@@ -186,12 +194,13 @@
     myMutexPop.unlock();
 }
 
-void StGLTextureQueue::drop(const size_t theCount) {
+void StGLTextureQueue::drop(const size_t theCount,
+                            double& thePtsFront) {
     myMutexPop.lock();
     myMutexPush.lock();
     myMutexSize.lock();
         if(myQueueSize < 2) {
-            // to small queue
+            // too small queue
             myMutexSize.unlock();
             myMutexPush.unlock();
             myMutexPop.unlock();
@@ -203,6 +212,7 @@
         for(size_t i = 0; i < decr; ++i, myDataFront = myDataFront->getNext()) {
             myDataFront->resetStParams();
         }
+        thePtsFront = myDataFront->getPTS();
         // reset queue
         myQueueSize -= decr;
         // empty texture update sequence

sview-20_08.tar.gz/StShared/StGLUVCylinder.cpp Added

@@ -0,0 +1,75 @@
+/**
+ * Copyright © 2019-2020 Kirill Gavrilov <kirill@sview.ru>
+ *
+ * Distributed under the Boost Software License, Version 1.0.
+ * See accompanying file license-boost.txt or copy at
+ * http://www.boost.org/LICENSE_1_0.txt
+ */
+
+#include <StGLMesh/StGLUVCylinder.h>
+
+#include <StGLCore/StGLCore20.h>
+#include <StGL/StGLContext.h>
+
+StGLUVCylinder::StGLUVCylinder(const StGLVec3& theCenter,
+                               const float theHeight,
+                               const float theRadius,
+                               const int theRings)
+: StGLMesh(GL_TRIANGLE_STRIP),
+  myCenter(theCenter),
+  myRadius(theRadius),
+  myHeight(theHeight),
+  myAngleFrom(0.0f),
+  myAngleTo(float(M_PI * 2.0)),
+  myNbRings(theRings) {
+    //
+}
+
+StGLUVCylinder::StGLUVCylinder(const StGLVec3& theCenter,
+                               const float theHeight,
+                               const float theRadius,
+                               const float theAngleFrom,
+                               const float theAngleTo,
+                               const int theRings)
+: StGLMesh(GL_TRIANGLE_STRIP),
+  myCenter(theCenter),
+  myRadius(theRadius),
+  myHeight(theHeight),
+  myAngleFrom(theAngleFrom),
+  myAngleTo(theAngleTo),
+  myNbRings(theRings) {
+    //
+}
+
+
+StGLUVCylinder::~StGLUVCylinder() {
+    //
+}
+
+bool StGLUVCylinder::computeMesh() {
+    clearRAM();
+    if(myNbRings == 0) {
+        return false;
+    }
+
+    const int aNbVerts = (myNbRings + 1) * 2;
+    myVertices.initArray(aNbVerts);
+    myNormals .initArray(aNbVerts);
+    myTCoords .initArray(aNbVerts);
+
+    const float anAngle = myAngleTo - myAngleFrom;
+    for(int aRingIter = 0; aRingIter <= myNbRings; ++aRingIter) {
+        const float aPhi    = myAngleFrom + float(aRingIter) * anAngle / float(myNbRings);
+        const float aTexCrd = float(aRingIter) / float(myNbRings);
+        myTCoords.changeValue(aRingIter * 2 + 0) = StGLVec2(aTexCrd, 0.0f);
+        myTCoords.changeValue(aRingIter * 2 + 1) = StGLVec2(aTexCrd, 1.0f);
+
+        const StGLVec3 aNorm(cosf(aPhi), 0.0f, sinf(aPhi));
+        myNormals.changeValue(aRingIter * 2 + 0) = aNorm;
+        myNormals.changeValue(aRingIter * 2 + 1) = aNorm;
+
+        myVertices.changeValue(aRingIter * 2 + 0) = myCenter + aNorm * myRadius - StGLVec3(0.0f, myHeight * 0.5f, 0.0f);
+        myVertices.changeValue(aRingIter * 2 + 1) = myCenter + aNorm * myRadius + StGLVec3(0.0f, myHeight * 0.5f, 0.0f);
+    }
+    return true;
+}

sview-17_04.tar.gz/StShared/StGLUVSphere.cpp -> sview-20_08.tar.gz/StShared/StGLUVSphere.cpp Changed

@@ -1,5 +1,5 @@
 /**
- * Copyright © 2010-2012 Kirill Gavrilov <kirill@sview.ru>
+ * Copyright © 2010-2019 Kirill Gavrilov <kirill@sview.ru>
  *
  * Distributed under the Boost Software License, Version 1.0.
  * See accompanying file license-boost.txt or copy at
@@ -12,22 +12,23 @@
 #include <StGLCore/StGLCore20.h>
 #include <StGL/StGLContext.h>
 
-/// TODO (Kirill Gavrilov#9) move to the common header
 namespace {
     static const GLfloat ST_PI     = 3.1415926535897932384626433832795f;
     static const GLfloat ST_TWOPI  = 6.2831853071795864769252867665590f;
     static const GLfloat ST_PIDIV2 = 1.5707963267948966192313216916397f;
-};
+}
 
 StGLUVSphere::StGLUVSphere(const StGLVec3& theCenter,
                            const GLfloat   theRadius,
-                           const size_t    theRings)
+                           const size_t    theRings,
+                           const bool      theIsHemisphere)
 : StGLMesh(GL_TRIANGLE_STRIP),
   myPrimCounts(1),
   myIndPointers(1),
   myCenter(theCenter),
   myRadius(theRadius),
-  myRings(theRings) {
+  myRings(theRings),
+  myIsHemisphere(theIsHemisphere) {
     //
 }
 
@@ -38,7 +39,8 @@
   myIndPointers(1),
   myCenter(theBndSphere.getCenter()),
   myRadius(theBndSphere.getRadius()),
-  myRings(theRings) {
+  myRings(theRings),
+  myIsHemisphere(false) {
     //
 }
 
@@ -73,7 +75,11 @@
         tcrd.y() = GLfloat(ringId) / GLfloat(aRingsCount);
 
         for(size_t pointId = 0; pointId <= pointPerRing; ++pointId) {
-            phi = GLfloat(pointId) * ST_TWOPI / GLfloat(pointPerRing);
+            if(myIsHemisphere) {
+                phi = ST_PIDIV2 + GLfloat(pointId) * ST_PI / GLfloat(pointPerRing);
+            } else {
+                phi = GLfloat(pointId) * ST_TWOPI / GLfloat(pointPerRing);
+            }
 
             tcrd.x() = GLfloat(pointId) / GLfloat(pointPerRing);

sview-17_04.tar.gz/StShared/StImage.cpp -> sview-20_08.tar.gz/StShared/StImage.cpp Changed

@@ -1,5 +1,5 @@
 /**
- * Copyright © 2010-2015 Kirill Gavrilov <kirill@sview.ru>
+ * Copyright © 2010-2019 Kirill Gavrilov <kirill@sview.ru>
  *
  * Distributed under the Boost Software License, Version 1.0.
  * See accompanying file license-boost.txt or copy at
@@ -14,26 +14,151 @@
         case ImgColor_RGB:     return "ImgColor_RGB";
         case ImgColor_RGBA:    return "ImgColor_RGBA";
         case ImgColor_GRAY:    return "ImgColor_GRAY";
+        case ImgColor_XYZ:     return "ImgColor_XYZ";
         case ImgColor_YUV:     return "ImgColor_YUV";
+        case ImgColor_YUVA:    return "ImgColor_YUVA";
         case ImgColor_CMYK:    return "ImgColor_CMYK";
         case ImgColor_HSV:     return "ImgColor_HSV";
         case ImgColor_HSL:     return "ImgColor_HSL";
-        default:               return "ImgColor_UNKNOWN";
     }
+    return "ImgColor_UNKNOWN";
 #else
     switch(theColorModel) {
         case ImgColor_RGB:     return "RGB";
         case ImgColor_RGBA:    return "RGBA";
         case ImgColor_GRAY:    return "Grayscale";
+        case ImgColor_XYZ:     return "XYZ";
         case ImgColor_YUV:     return "YUV";
+        case ImgColor_YUVA:    return "YUVA";
         case ImgColor_CMYK:    return "CMYK";
         case ImgColor_HSV:     return "HSV";
         case ImgColor_HSL:     return "HSL";
-        default:               return StString("UNKNOWN[") + theColorModel + "]";
     }
+    return StString("UNKNOWN[") + theColorModel + "]";
 #endif
 }
 
+const char* StImage::formatImgPixelFormat() const {
+    switch(myColorModel) {
+        case ImgColor_RGB:
+        case ImgColor_RGBA:
+        case ImgColor_GRAY: {
+            switch(myPlanes[0].getFormat()) {
+                case StImagePlane::ImgGray:    return "gray8";
+                case StImagePlane::ImgGray16:  return "gray16";
+                case StImagePlane::ImgRGB:     return "rgb24";
+                case StImagePlane::ImgBGR:     return "bgr24";
+                case StImagePlane::ImgRGB32:   return "rgb32";
+                case StImagePlane::ImgBGR32:   return "bgr32";
+                case StImagePlane::ImgRGB48:   return "rgb48";
+                case StImagePlane::ImgRGBA:    return "rgba32";
+                case StImagePlane::ImgBGRA:    return "bgra32";
+                case StImagePlane::ImgRGBA64:  return "rgba64";
+                case StImagePlane::ImgGrayF:   return "grayf";
+                case StImagePlane::ImgRGBF:    return "rgbf";
+                case StImagePlane::ImgBGRF:    return "bgrf";
+                case StImagePlane::ImgRGBAF:   return "rgbaf";
+                case StImagePlane::ImgBGRAF:   return "bgraf";
+                case StImagePlane::ImgUV:      return "uv";
+                case StImagePlane::ImgUNKNOWN: return "unknown";
+            }
+            return "invalid_rgb";
+        }
+        case ImgColor_XYZ: {
+            switch(myPlanes[0].getFormat()) {
+                case StImagePlane::ImgRGB:     return "xyz8";
+                case StImagePlane::ImgRGB48:   return "xyz12";
+                case StImagePlane::ImgRGBF:    return "xyzf";
+                default: break;
+            }
+            return "invalid_xyz";
+        }
+        case ImgColor_YUV:
+        case ImgColor_YUVA: {
+            const bool  hasAlpha = myColorModel == ImgColor_YUVA;
+            const size_t aDelimX = (myPlanes[1].getSizeX() > 0) ? (myPlanes[0].getSizeX() / myPlanes[1].getSizeX()) : 1;
+            const size_t aDelimY = (myPlanes[1].getSizeY() > 0) ? (myPlanes[0].getSizeY() / myPlanes[1].getSizeY()) : 1;
+            if(myPlanes[1].getFormat() == StImagePlane::ImgUV) {
+                return "nv12";
+            } else if(aDelimX == 1 && aDelimY == 1) {
+                switch(myColorScale) {
+                    case StImage::ImgScale_Mpeg:
+                        return myPlanes[0].getFormat() == StImagePlane::ImgGray16
+                             ? (hasAlpha ? "yuva444p16" : "yuv444p16")
+                             : (hasAlpha ? "yuva444p"   : "yuv444p");
+                    case StImage::ImgScale_Mpeg9:
+                    case StImage::ImgScale_Jpeg9:
+                        return (hasAlpha ? "yuva444p9" : "yuv444p9");
+                    case StImage::ImgScale_Mpeg10:
+                    case StImage::ImgScale_Jpeg10:
+                        return (hasAlpha ? "yuva444p10" : "yuv444p10");
+                    case StImage::ImgScale_Full:
+                    default:
+                        return myPlanes[0].getFormat() == StImagePlane::ImgGray16
+                             ? (hasAlpha ? "yuvaj444p16" : "yuvj444p16")
+                             : (hasAlpha ? "yuvaj444p"   : "yuvj444p");
+                }
+            } else if(aDelimX == 2 && aDelimY == 2) {
+                switch(myColorScale) {
+                    case StImage::ImgScale_Mpeg:
+                        return myPlanes[0].getFormat() == StImagePlane::ImgGray16
+                             ? (hasAlpha ? "yuva420p16" : "yuv420p16")
+                             : (hasAlpha ? "yuva420p"   : "yuv420p");
+                    case StImage::ImgScale_Mpeg9:
+                    case StImage::ImgScale_Jpeg9:
+                        return (hasAlpha ? "yuva420p9" : "yuv420p9");
+                    case StImage::ImgScale_Mpeg10:
+                    case StImage::ImgScale_Jpeg10:
+                        return (hasAlpha ? "yuva420p10" : "yuv420p10");
+                    case StImage::ImgScale_Full:
+                    default:
+                        return myPlanes[0].getFormat() == StImagePlane::ImgGray16
+                             ? (hasAlpha ? "yuvaj420p16" : "yuvj420p16")
+                             : (hasAlpha ? "yuvaj420p"   : "yuvj420p");
+                }
+            } else if(aDelimX == 2 && aDelimY == 1) {
+                switch(myColorScale) {
+                    case StImage::ImgScale_Mpeg:
+                        return myPlanes[0].getFormat() == StImagePlane::ImgGray16
+                             ? (hasAlpha ? "yuva422p16" : "yuv422p16")
+                             : (hasAlpha ? "yuva422p"   : "yuv422p");
+                    case StImage::ImgScale_Mpeg9:
+                    case StImage::ImgScale_Jpeg9:
+                        return (hasAlpha ? "yuva422p9" : "yuv422p9");
+                    case StImage::ImgScale_Mpeg10:
+                    case StImage::ImgScale_Jpeg10:
+                        return (hasAlpha ? "yuva422p10" : "yuv422p10");
+                    case StImage::ImgScale_Full:
+                    default:
+                        return myPlanes[0].getFormat() == StImagePlane::ImgGray16
+                             ? (hasAlpha ? "yuvaj422p16" : "yuvj422p16")
+                             : (hasAlpha ? "yuvaj422p"   : "yuvj422p");
+                }
+            } else if(aDelimX == 1 && aDelimY == 2) {
+                return myColorScale == StImage::ImgScale_Mpeg
+                     ? (hasAlpha ? "yuva440p"  : "yuv440p")
+                     : (hasAlpha ? "yuvaj440p" : "yuvj440p");
+            } else if(aDelimX == 4 && aDelimY == 1) {
+                return myColorScale == StImage::ImgScale_Mpeg
+                     ? (hasAlpha ? "yuva411p"  : "yuv411p")
+                     : (hasAlpha ? "yuvaj411p" : "yuvj411p");
+            } else if(aDelimX == 4 && aDelimY == 4) {
+                return myColorScale == StImage::ImgScale_Mpeg
+                     ? (hasAlpha ? "yuva410p"  : "yuv410p")
+                     : (hasAlpha ? "yuvaj410p" : "yuvj410p");
+            }
+            return (hasAlpha ? "yuva_unknown" : "yuv_unknown");
+        }
+        case ImgColor_CMYK:
+            return "CMYK";
+        case ImgColor_HSV:
+            return "HSV";
+        case ImgColor_HSL:
+            return "HSL";
+    }
+    return "unknown";
+}
+
 StImage::StImage()
 : myPAR(1.0f),
   myColorModel(ImgColor_RGB),
@@ -194,7 +319,8 @@
                              const StImage& theImageR,
                              const int theSeparationDx,
                              const int theSeparationDy) {
-    const bool isYUV = theImageL.getColorModel() == StImage::ImgColor_YUV;
+    const bool isYUV = theImageL.getColorModel() == StImage::ImgColor_YUV
+                    || theImageL.getColorModel() == StImage::ImgColor_YUVA;
     for(size_t aPlaneId = 0; aPlaneId < 4; ++aPlaneId) {
         float aScaleX = (theImageL.getPlane(aPlaneId).getSizeX() > 0) ? theImageL.getScaleFactorX(aPlaneId) : 1.0f;
         float aScaleY = (theImageL.getPlane(aPlaneId).getSizeY() > 0) ? theImageL.getScaleFactorY(aPlaneId) : 1.0f;

sview-17_04.tar.gz/StShared/StImageFile.cpp -> sview-20_08.tar.gz/StShared/StImageFile.cpp Changed

@@ -1,5 +1,5 @@
 /**
- * Copyright © 2010-2015 Kirill Gavrilov <kirill@sview.ru>
+ * Copyright © 2010-2020 Kirill Gavrilov <kirill@sview.ru>
  *
  * Distributed under the Boost Software License, Version 1.0.
  * See accompanying file license-boost.txt or copy at
@@ -11,14 +11,61 @@
 #include <StImage/StDevILImage.h>
 #include <StImage/StFreeImage.h>
 #include <StImage/StWebPImage.h>
+#include <StImage/StStbImage.h>
 #include <StAV/StAVImage.h>
 #include <StFile/StFileNode.h>
 #include <StFile/StMIME.h>
+#include <StFile/StRawFile.h>
 
 #include <StStrings/StLogger.h>
 
+/**
+ * DDS Pixel Format structure.
+ */
+struct StDDSPixelFormat {
+    uint32_t Size;
+    uint32_t Flags;
+    uint32_t FourCC;
+    uint32_t RGBBitCount;
+    uint32_t RBitMask;
+    uint32_t GBitMask;
+    uint32_t BBitMask;
+    uint32_t ABitMask;
+};
+
+/**
+ * DDS File header structure.
+ */
+struct StDDSFileHeader {
+    /**
+     * Caps2 flag indicating complete (6 faces) cubemap.
+     */
+    enum { DDSCompleteCubemap = 0xFE00 };
+
+    /**
+     * Return TRUE if cubmap flag is set.
+     */
+    bool isCompleteCubemap() const { return (Caps2 & DDSCompleteCubemap) != 0; }
+
+    uint32_t Size;
+    uint32_t Flags;
+    uint32_t Height;
+    uint32_t Width;
+    uint32_t PitchOrLinearSize;
+    uint32_t Depth;
+    uint32_t MipMapCount;
+    uint32_t Reserved1[11];
+    StDDSPixelFormat PixelFormatDef;
+    uint32_t Caps;
+    uint32_t Caps2;
+    uint32_t Caps3;
+    uint32_t Caps4;
+    uint32_t Reserved2;
+};
+
 StImageFile::StImageFile()
-: mySrcFormat(StFormat_AUTO) {
+: mySrcFormat(StFormat_AUTO),
+  mySrcPanorama(StPanorama_OFF) {
     //
 }
 
@@ -41,6 +88,8 @@
     } else if(thePreferred.isEqualsIgnoreCase(stCString("WebP")) ||
               thePreferred.isEqualsIgnoreCase(stCString("StWebPImage"))) {
         aPreferred = ST_WEBP;
+    } else if(thePreferred.isEqualsIgnoreCase(stCString("stb"))) {
+        aPreferred = ST_STB;
     }
     return aPreferred;
 }
@@ -50,6 +99,7 @@
         case ST_FREEIMAGE: return "FreeImage";
         case ST_DEVIL:     return "DevIL";
         case ST_WEBP:      return "WebP";
+        case ST_STB:       return "stb";
         default:
         case ST_LIBAV:     return "FFmpeg";
     }
@@ -93,6 +143,9 @@
     } else if(anExt.isEqualsIgnoreCase(stCString("webpll"))
            || theMIMEType.getMIMEType().isEquals(stCString("image/webpll"))) {
         return StImageFile::ST_TYPE_WEBPLL;
+    } else if(anExt.isEqualsIgnoreCase(stCString("dds"))
+           || theMIMEType.getMIMEType().isEquals(stCString("image/vnd-ms.dds"))) {
+       return StImageFile::ST_TYPE_DDS;
     }
     return StImageFile::ST_TYPE_NONE;
 }
@@ -164,6 +217,12 @@
             }
             break;
         }
+        case ST_STB: {
+            if(StStbImage::init()) {
+                return new StStbImage();
+            }
+            break;
+        }
         default:
         case ST_LIBAV: {
             if(StAVImage::init()) {
@@ -180,6 +239,111 @@
     return StHandle<StImageFile>();
 }
 
+bool StImageFile::load(const StString& theFilePath,
+                       ImageType theImageType,
+                       uint8_t* theDataPtr, int theDataSize) {
+    if(theImageType == ST_TYPE_DDS) {
+        // Most image libraries ignore arrays/cubemaps in DDS file.
+        // As DDS format is pretty simple - parse it here and load cubemap as vertically stacked image.
+        StRawFile aRawFile(theFilePath);
+        if(theDataPtr == NULL) {
+            if(!aRawFile.readFile()) {
+                return loadExtra(theFilePath, theImageType, theDataPtr, theDataSize, false);
+            }
+            theDataPtr = (uint8_t* )aRawFile.getBuffer();
+            theDataSize = (int )aRawFile.getSize();
+        }
+
+        if (theDataSize < 128
+         || memcmp (&theDataPtr[0], "DDS ", 4) != 0) {
+            return loadExtra(theFilePath, theImageType, theDataPtr, theDataSize, false);
+        }
+
+        const StDDSFileHeader* aSrcHeader = (const StDDSFileHeader* )&theDataPtr[4];
+        if (aSrcHeader->Size != 124
+         || aSrcHeader->Width  == 0
+         || aSrcHeader->Height == 0
+         || aSrcHeader->Width != aSrcHeader->Height
+         || aSrcHeader->PixelFormatDef.Size != 32
+         || (aSrcHeader->Caps2 & StDDSFileHeader::DDSCompleteCubemap) != StDDSFileHeader::DDSCompleteCubemap) {
+            return loadExtra(theFilePath, theImageType, theDataPtr, theDataSize, false);
+        }
+
+        const int aHeaderSize  = aSrcHeader->Size + 4;
+        const int aPayLoadSize = theDataSize - aHeaderSize;
+        if (aPayLoadSize % 6 != 0
+         || aPayLoadSize <= 0) {
+            return loadExtra(theFilePath, theImageType, theDataPtr, theDataSize, false);
+        }
+
+        const int aTileDataSize = aPayLoadSize / 6;
+        StArray<uint8_t> aTileBuffer (aTileDataSize + aHeaderSize);
+        memcpy(&aTileBuffer.changeFirst(),  "DDS ", 4);
+        memcpy(&aTileBuffer.changeValue(4), aSrcHeader, aSrcHeader->Size);
+        StDDSFileHeader* aHeaderTile = (StDDSFileHeader* )&aTileBuffer.changeValue(4);
+        aHeaderTile->Caps2 &= ~(StDDSFileHeader::DDSCompleteCubemap);
+
+        StHandle<StImageFile> aTileImage = createEmpty();
+
+        memcpy(&aTileBuffer.changeValue(aHeaderSize), &theDataPtr[aHeaderSize], aTileDataSize);
+        if(!aTileImage->loadExtra(theFilePath, theImageType, &aTileBuffer.changeFirst(), (int )aTileBuffer.size(), false)
+         || aTileImage->isNull()
+         || aTileImage->getSizeX() < 1
+         || aTileImage->getSizeY() < 1
+         || aTileImage->getSizeX() != aTileImage->getSizeY()) {
+            return loadExtra(theFilePath, theImageType, theDataPtr, theDataSize, false);
+        }
+
+        close();
+        nullify();
+        myMetadata   = aTileImage->myMetadata;
+        myStateDescr = aTileImage->myStateDescr;
+        mySrcFormat  = aTileImage->mySrcFormat;
+        setColorModel(aTileImage->getColorModel());
+        setColorScale(aTileImage->getColorScale());
+        setPixelRatio(aTileImage->getPixelRatio());
+        const bool isTopDownLayout = aTileImage->isTopDown();
+        for(size_t aPlaneId = 0; aPlaneId < 4; ++aPlaneId) {
+            const StImagePlane& aFromPlane = aTileImage->getPlane(aPlaneId);
+            const size_t aTileIndex = isTopDownLayout ? 0 : 5;
+            if(!aFromPlane.isNull()) {
+                if(!changePlane(aPlaneId).initTrash(aFromPlane.getFormat(), aFromPlane.getSizeX(), aFromPlane.getSizeX() * 6)) {
+                    return false;
+                }
+                changePlane(aPlaneId).setTopDown(aFromPlane.isTopDown());
+                memcpy(changePlane(aPlaneId).changeData() + aFromPlane.getSizeBytes() * aTileIndex,
+                       aFromPlane.getData(), aFromPlane.getSizeBytes());
+            }
+        }
+
+        for(size_t aTileIter = 1; aTileIter < 6; ++aTileIter) {
+            memcpy(&aTileBuffer.changeValue(aHeaderSize), &theDataPtr[aTileIter * aTileDataSize + aHeaderSize], aTileDataSize);
+            aTileImage = createEmpty();
+            if(!aTileImage->loadExtra(theFilePath, theImageType, &aTileBuffer.changeFirst(), (int )aTileBuffer.size(), false)
+             || aTileImage->isNull()
+             || aTileImage->getSizeX() != getSizeX()
+             || aTileImage->getSizeY() != getSizeX() // square
+             || aTileImage->getColorModel() != getColorModel()
+             || aTileImage->getPlane().getFormat() != getPlane().getFormat()) {
+                ST_ERROR_LOG("Internal error: DDS file is decoded into inconsistent tiles");
+                return loadExtra(theFilePath, theImageType, theDataPtr, theDataSize, false);
+            }
+
+            const size_t aTileIndex = isTopDownLayout ? aTileIter : (5 - aTileIter);
+            for(size_t aPlaneId = 0; aPlaneId < 4; ++aPlaneId) {
+                const StImagePlane& aFromPlane = aTileImage->getPlane(aPlaneId);
+                if(!aFromPlane.isNull()) {
+                    memcpy(changePlane(aPlaneId).changeData() + aFromPlane.getSizeBytes() * aTileIndex,
+                           aFromPlane.getData(), aFromPlane.getSizeBytes());
+                }
+            }
+        }
+        mySrcPanorama = StPanorama_Cubemap1_6;
+        return true;
+    }
+    return loadExtra(theFilePath, theImageType, theDataPtr, theDataSize, false);
+}
+
 StImageFileCounter::~StImageFileCounter() {}
 
 void StImageFileCounter::createReference(StHandle<StBufferCounter>& theOther) const {

sview-17_04.tar.gz/StShared/StImagePlane.cpp -> sview-20_08.tar.gz/StShared/StImagePlane.cpp Changed

@@ -1,5 +1,5 @@
 /**
- * Copyright © 2010-2015 Kirill Gavrilov <kirill@sview.ru>
+ * Copyright © 2010-2020 Kirill Gavrilov <kirill@sview.ru>
  *
  * Distributed under the Boost Software License, Version 1.0.
  * See accompanying file license-boost.txt or copy at
@@ -26,9 +26,9 @@
         case ImgRGBAF:   return "ImgRGBAF";
         case ImgBGRAF:   return "ImgBGRAF";
         case ImgUV:      return "ImgUV";
-        case ImgUNKNOWN:
-        default:         return "ImgUNKNOWN";
+        case ImgUNKNOWN: return "ImgUNKNOWN";
     }
+    return "unknown";
 }
 
 StImagePlane::StImagePlane()
@@ -159,6 +159,29 @@
     return true;
 }
 
+bool StImagePlane::initTransposedCopy(const StImagePlane& theCopy,
+                                      const bool theIsClockwise) {
+    if(myImgFormat != theCopy.myImgFormat
+    || mySizeX != theCopy.mySizeX
+    || mySizeY != theCopy.mySizeY) {
+        if(!initTrash(theCopy.myImgFormat, theCopy.mySizeY, theCopy.mySizeX)) {
+            return false;
+        }
+    }
+
+    const size_t aPixelSize = getSizePixelBytes();
+    const size_t aSrcColFrom =  theIsClockwise ? theCopy.mySizeX - 1 : 0;
+    const size_t aSrcRowFrom = !theIsClockwise ? theCopy.mySizeY - 1 : 0;
+    const size_t aSrcColIncr = aSrcColFrom == 0 ? 1 : size_t(-1);
+    const size_t aSrcRowIncr = aSrcRowFrom == 0 ? 1 : size_t(-1);
+    for(size_t aDstRow = 0, aSrcCol = aSrcColFrom; aDstRow < mySizeY; ++aDstRow, aSrcCol += aSrcColIncr) {
+        for(size_t aDstCol = 0, aSrcRow = aSrcRowFrom; aDstCol < mySizeX; ++aDstCol, aSrcRow += aSrcRowIncr) {
+            stMemCpy(changeData(aDstRow, aDstCol), theCopy.getData(aSrcRow, aSrcCol), aPixelSize);
+        }
+    }
+    return true;
+}
+
 bool StImagePlane::initWrapper(const StImagePlane& theCopy) {
     if(!initWrapper(theCopy.myImgFormat, theCopy.myDataPtr,
                     theCopy.mySizeX, theCopy.mySizeY, theCopy.mySizeRowBytes)) {

sview-20_08.tar.gz/StShared/StJNIEnv.cpp Added

@@ -0,0 +1,75 @@
+/**
+ * Copyright © 2019 Kirill Gavrilov <kirill@sview.ru>
+ *
+ * Distributed under the Boost Software License, Version 1.0.
+ * See accompanying file license-boost.txt or copy at
+ * http://www.boost.org/LICENSE_1_0.txt
+ */
+
+#include <StJNI/StJNIEnv.h>
+
+#include <StStrings/StLogger.h>
+#include <StThreads/StThread.h>
+
+#if defined(__ANDROID__)
+    #include <jni.h>
+#endif
+
+StJNIEnv::StJNIEnv(JavaVM* theJavaVM)
+: myJavaVM(theJavaVM),
+  myJniEnv(NULL),
+  myThreadId(0),
+  myToDetach(false) {
+    if(myJavaVM == NULL) {
+        return;
+    }
+
+#if defined(__ANDROID__)
+    void* aJniEnv = NULL;
+    switch(myJavaVM->GetEnv(&aJniEnv, JNI_VERSION_1_6)) {
+        case JNI_EDETACHED: {
+            if(myJavaVM->AttachCurrentThread(&myJniEnv, NULL) < 0) {
+                myJniEnv = NULL;
+                ST_ERROR_LOG("Failed to attach working thread to Java VM");
+                return;
+            }
+            myToDetach = true;
+            myThreadId = StThread::getCurrentThreadId();
+            break;
+        }
+        case JNI_OK: {
+            myJniEnv   = (JNIEnv* )aJniEnv;
+            myToDetach = false;
+            break;
+        }
+        case JNI_EVERSION: {
+            ST_ERROR_LOG("Failed to attach working thread to Java VM - JNI version is not supported");
+            break;
+        }
+        default: {
+            ST_ERROR_LOG("Failed to attach working thread to Java VM");
+            break;
+        }
+    }
+#endif
+}
+
+StJNIEnv::~StJNIEnv() {
+    detach();
+}
+
+void StJNIEnv::detach() {
+    if(myJavaVM != NULL
+    && myJniEnv != NULL
+    && myToDetach) {
+        if(myThreadId != StThread::getCurrentThreadId()) {
+            ST_ERROR_LOG("Internal error, StJNIEnv::detach() - attempt to detach from another thread");
+        }
+    #if defined(__ANDROID__)
+        myJavaVM->DetachCurrentThread();
+    #endif
+    }
+
+    myJniEnv   = NULL;
+    myToDetach = false;
+}

sview-17_04.tar.gz/StShared/StJpegParser.cpp -> sview-20_08.tar.gz/StShared/StJpegParser.cpp Changed

@@ -142,7 +142,8 @@
 StJpegParser::StJpegParser(const StCString& theFilePath)
 : StRawFile(theFilePath),
   myImages(NULL),
-  myStFormat(StFormat_AUTO) {
+  myStFormat(StFormat_AUTO),
+  myPanorama(StPanorama_OFF) {
     stMemZero(myOffsets, sizeof(myOffsets));
 #if !defined(_MSC_VER)
     (void )markerString;
@@ -157,7 +158,9 @@
     // destroy all images
     myImages.nullify();
     myComment.clear();
+    myXMP.clear();
     myStFormat = StFormat_AUTO;
+    myPanorama = StPanorama_OFF;
     myLength = 0;
     stMemZero(myOffsets, sizeof(myOffsets));
 }
@@ -232,6 +235,7 @@
     // parse the data
     StHandle<StJpegParser::Image> anImg = new StJpegParser::Image();
     anImg->Data = aData - 2;
+    bool toDetectCubemap = false;
 
     for(;;) {
         // search for the next marker in the file
@@ -251,6 +255,32 @@
         //ST_DEBUG_LOG(" #" + theImgCount + "." + theDepth + " [" + markerString(aMarker) + "] at position " + size_t(aData - myBuffer) + " / " + myLength); ///
         if(aMarker == M_EOI) {
             //ST_DEBUG_LOG("Jpeg, EOI at position " + size_t(aData - myBuffer) + " / " + myLength);
+
+            bool isPanoStereo = false;
+            if(toDetectCubemap && myPanorama == StPanorama_OFF) {
+                size_t aViewX = anImg->SizeX, aViewY = anImg->SizeY;
+                if(myStFormat == StFormat_SideBySide_LR || myStFormat == StFormat_SideBySide_RL) {
+                    aViewX /= 2;
+                } else if(myStFormat == StFormat_TopBottom_LR || myStFormat == StFormat_TopBottom_RL) {
+                    aViewY /= 2;
+                }
+                if(aViewX == aViewY * 6) {
+                    myPanorama = StPanorama_Cubemap6_1;
+                } else if(aViewX * 6 == aViewY) {
+                    myPanorama = StPanorama_Cubemap1_6;
+                } else if(aViewX * 2 == aViewY * 3) {
+                    myPanorama = StPanorama_Cubemap3_2;
+                }
+            } else if(anImg->get360PanoMakerNote(isPanoStereo)) {
+                if(myPanorama == StPanorama_OFF) {
+                    myPanorama = StPanorama_Sphere;
+                }
+                if(myStFormat == StFormat_AUTO
+                && isPanoStereo) {
+                    myStFormat = StFormat_TopBottom_LR;
+                }
+            }
+
             anImg->Length = size_t(aData - anImg->Data);
             return anImg;
         } else if(aMarker == M_SOI) {
@@ -369,6 +399,23 @@
                     }
                 } else if(stAreEqual(aData + 2, "http:", 5)) {
                     //ST_DEBUG_LOG("Image cotains XMP section");
+                    if(stAreEqual(aData + 2, "http://ns.adobe.com/xap/1.0/", 28)) { // XMP basic namespace
+                        myXMP = StString((char* )aData + 31, anItemLen - 31);
+                        {
+                          // GPano http://ns.google.com/photos/1.0/panorama/ namespace metadata.
+                          // Note possible cropped panorama parameters are ignored by sView.
+                          if(myXMP.isContains(stCString("<GPano:ProjectionType>equirectangular</GPano:ProjectionType>"))
+                          || myXMP.isContains(stCString("GPano:ProjectionType=\"equirectangular\""))) {
+                              // Google currently supports only equirectangular format
+                              myPanorama = StPanorama_Sphere;
+                          } else if(myXMP.isContains(stCString("<GPano:ProjectionType>cubemap</GPano:ProjectionType>"))
+                                 || myXMP.isContains(stCString("GPano:ProjectionType=\"cubemap\""))) {
+                              // this one doesn't yet exist, but try to support it
+                              toDetectCubemap = true;
+                          }
+                        }
+                        myXMP.clear();
+                    }
                 } else {
                     //ST_DEBUG_LOG("  @@@ APP2 " + StString((char* )aData + 2));
                 }
@@ -471,7 +518,10 @@
             return false;
         }
         stMemCpy(aNewData, myBuffer, myLength);
-        stMemFreeAligned(myBuffer);
+        if(myIsOwnData) {
+            stMemFreeAligned(myBuffer);
+        }
+        myIsOwnData = true;
 
         // update pointers of image(s) data
         for(StHandle<StJpegParser::Image> anImg = myImages;
@@ -607,6 +657,20 @@
     return aString;
 }
 
+bool StJpegParser::Image::get360PanoMakerNote(bool& theIsStereo) const {
+    StExifDir::Query aQuery(StExifDir::DType_General, StExifTags::Image_MakerNote, StExifEntry::FMT_STRING);
+    if(!StExifDir::findEntry(Exif, aQuery)) {
+        return false;
+    } else if(::strncmp((char* )aQuery.Entry.ValuePtr, "360Stereo", 9) == 0) {
+        theIsStereo = true;
+        return true;
+    } else if(::strncmp((char* )aQuery.Entry.ValuePtr, "360Mono", 7) == 0) {
+        theIsStereo = false;
+        return true;
+    }
+    return false;
+}
+
 bool StJpegParser::Image::getParallax(double& theParallax) const {
     StExifDir::Query aQuery(StExifDir::DType_MakerFuji, StExifTags::Fuji_Parallax);
     if(!StExifDir::findEntry(Exif, aQuery)

sview-17_04.tar.gz/StShared/StLogger.ObjC.mm -> sview-20_08.tar.gz/StShared/StLogger.ObjC.mm Changed

@@ -22,7 +22,9 @@
     StLogger::GetDefault().write(theMessage, StLogger::ST_INFO);
     StCocoaLocalPool aLocalPool;
     NSString* aMessage = [NSString stringWithUTF8String: theMessage.toCString()];
+ST_DISABLE_DEPRECATION_WARNINGS
     NSRunAlertPanel(@"Info", @"%@", @"OK", nil, nil, aMessage);
+ST_ENABLE_DEPRECATION_WARNINGS
 }
 
 void StMessageBox::Warn(const StString& theMessage) {
@@ -32,7 +34,9 @@
     StLogger::GetDefault().write(theMessage, StLogger::ST_WARNING);
     StCocoaLocalPool aLocalPool;
     NSString* aMessage = [NSString stringWithUTF8String: theMessage.toCString()];
+ST_DISABLE_DEPRECATION_WARNINGS
     NSRunAlertPanel(@"Warning", @"%@", @"OK", nil, nil, aMessage);
+ST_ENABLE_DEPRECATION_WARNINGS
 }
 
 void StMessageBox::Error(const StString& theMessage) {
@@ -42,7 +46,9 @@
     StLogger::GetDefault().write(theMessage, StLogger::ST_ERROR);
     StCocoaLocalPool aLocalPool;
     NSString* aMessage = [NSString stringWithUTF8String: theMessage.toCString()];
+ST_DISABLE_DEPRECATION_WARNINGS
     NSRunAlertPanel(@"Error", @"%@", @"OK", nil, nil, aMessage);
+ST_ENABLE_DEPRECATION_WARNINGS
 }
 
 bool StMessageBox::Question(const StString& theMessage) {
@@ -51,8 +57,10 @@
     }
     StCocoaLocalPool aLocalPool;
     NSString* aMessage = [NSString stringWithUTF8String: theMessage.toCString()];
+ST_DISABLE_DEPRECATION_WARNINGS
     int aResult = NSRunAlertPanel(@"Question", @"%@", @"Yes", @"No", nil, aMessage);
     return aResult == NSAlertDefaultReturn;
+ST_ENABLE_DEPRECATION_WARNINGS
 }
 
 #endif // __APPLE__

sview-17_04.tar.gz/StShared/StPlayList.cpp -> sview-20_08.tar.gz/StShared/StPlayList.cpp Changed

@@ -587,9 +587,9 @@
         }
 
         if(myCurrent != NULL) {
-            if(aRemItem->getPlayedFlag() != aPlayedFlag) {
+            if(myCurrent->getPlayedFlag() != aPlayedFlag) {
                 // the item has not been played yet - mark it as such
-                aRemItem->setPlayedFlag(aPlayedFlag);
+                myCurrent->setPlayedFlag(aPlayedFlag);
             } else {
                 // one played item has been removed
                 --myPlayedCount;
@@ -1120,7 +1120,10 @@
         }
     } else {
         // not a filesystem element - probably url or invalid path
-        StFileNode* aFileNode = new StFileNode(thePath, &myFoldersRoot);
+        StFolder* aSubFolder = new StFolder(stCString(""), &myFoldersRoot);
+        myFoldersRoot.add(aSubFolder);
+
+        StFileNode* aFileNode = new StFileNode(thePath, aSubFolder);
         myFoldersRoot.add(aFileNode);
         addRecentFile(*aFileNode); // append to recent files list
         addPlayItem(new StPlayItem(aFileNode, myDefStParams));

sview-17_04.tar.gz/StShared/StProcess.cpp -> sview-20_08.tar.gz/StShared/StProcess.cpp Changed

sview-17_04.tar.gz/StShared/StRawFile.cpp -> sview-20_08.tar.gz/StShared/StRawFile.cpp Changed

sview-17_04.tar.gz/StShared/StResourceManager.cpp -> sview-20_08.tar.gz/StShared/StResourceManager.cpp Changed

@@ -80,10 +80,13 @@
 
 StResourceManager::StResourceManager(const StString& theAppName)
 : myAppName(theAppName),
-  myUserHomeFolder(StProcess::getEnv(StString("HOME")) + SYS_FS_SPLITTER),
+  myUserHomeFolder(StProcess::getEnv(StString("HOME"))),
   myResFolder(StProcess::getStShareFolder()),
   myLang("en") {
-
+#if !defined(__ANDROID__)
+    myFolders[FolderId_Documents] = myUserHomeFolder;
+#endif
+    myUserHomeFolder += SYS_FS_SPLITTER;
 #if defined(_WIN32)
     StString anAppDataLocal, anAppDataLocalLow, anAppDataRoam;
     wchar_t* aPath = NULL;
@@ -101,6 +104,7 @@
     }
     if(::SHGetKnownFolderPath(FOLDERID_Documents, 0, NULL, &aPath) == S_OK) {
         myUserHomeFolder.fromUnicode(aPath);
+        myFolders[FolderId_Documents] = myUserHomeFolder;
         myUserHomeFolder += "\\";
         ::CoTaskMemFree(aPath);
     }
@@ -158,20 +162,32 @@
     StFolder::createFolder(myUserHomeFolder + "Library/Caches");
 #else
     // Linux world
-    myUserDataFolder = myUserHomeFolder + ".local/share/" + myAppName + "/";
-    mySettingsFolder = myUserHomeFolder + ".config/"      + myAppName + "/";
-    myCacheFolder    = myUserHomeFolder + ".cache/"       + myAppName + "/";
+    myUserDataFolder = StProcess::getEnv(StString("XDG_DATA_HOME"));
+    if(myUserDataFolder.isEmpty()) {
+        myUserDataFolder = myUserHomeFolder + ".local/share";
+        StFolder::createFolder(myUserHomeFolder + ".local");
+        StFolder::createFolder(myUserDataFolder);
+    }
+    myUserDataFolder = myUserDataFolder + "/" + myAppName + "/";
+
+    mySettingsFolder = StProcess::getEnv(StString("XDG_CONFIG_HOME"));
+    if(mySettingsFolder.isEmpty()) {
+        mySettingsFolder = myUserHomeFolder + ".config";
+        StFolder::createFolder(mySettingsFolder);
+    }
+    mySettingsFolder = mySettingsFolder + "/" + myAppName + "/";
+
+    myCacheFolder = StProcess::getEnv(StString("XDG_CACHE_HOME"));
+    if(myCacheFolder.isEmpty()) {
+        myCacheFolder = myUserHomeFolder + ".cache";
+        StFolder::createFolder(myCacheFolder);
+    }
+    myCacheFolder = myCacheFolder + "/" + myAppName + "/";
 
     myFolders[FolderId_Downloads] = myUserHomeFolder + "Downloads";
     myFolders[FolderId_Pictures]  = myUserHomeFolder + "Pictures";
     myFolders[FolderId_Music]     = myUserHomeFolder + "Music";
     myFolders[FolderId_Videos]    = myUserHomeFolder + "Videos";
-
-    // make sure parent paths are also exist (on broken home)
-    StFolder::createFolder(myUserHomeFolder + ".local");
-    StFolder::createFolder(myUserHomeFolder + ".local/share");
-    StFolder::createFolder(myUserHomeFolder + ".config");
-    StFolder::createFolder(myUserHomeFolder + ".cache");
 #endif
 
     StFolder::createFolder(myUserDataFolder);
@@ -187,6 +203,8 @@
         myLang = aSysLoc.subString(0, 2);
     } else if(aSysLoc.isStartsWith(stCString("russian"))) {
         myLang = "ru";
+    } else if(aSysLoc.isStartsWith(stCString("spanish"))) {
+        myLang = "es";
     } else if(aSysLoc.isStartsWith(stCString("french"))) {
         myLang = "fr";
     } else if(aSysLoc.isStartsWith(stCString("german"))) {

sview-17_04.tar.gz/StShared/StShared.cbp -> sview-20_08.tar.gz/StShared/StShared.cbp Changed

@@ -304,6 +304,7 @@
 		<Unit filename="StGLTexture.cpp" />
 		<Unit filename="StGLTextureData.cpp" />
 		<Unit filename="StGLTextureQueue.cpp" />
+		<Unit filename="StGLUVCylinder.cpp" />
 		<Unit filename="StGLUVSphere.cpp" />
 		<Unit filename="StGLVertexBuffer.cpp" />
 		<Unit filename="StImage.cpp" />
@@ -340,6 +341,7 @@
 		</Unit>
 		<Unit filename="StResourceManager.cpp" />
 		<Unit filename="StSettings.cpp" />
+		<Unit filename="StStbImage.cpp" />
 		<Unit filename="StSocket.ObjC.mm">
 			<Option compile="1" />
 			<Option link="1" />
@@ -439,6 +441,7 @@
 		<Unit filename="../include/StGLMesh/StGLMesh.h" />
 		<Unit filename="../include/StGLMesh/StGLPrism.h" />
 		<Unit filename="../include/StGLMesh/StGLQuads.h" />
+		<Unit filename="../include/StGLMesh/StGLUVCylinder.h" />
 		<Unit filename="../include/StGLMesh/StGLUVSphere.h" />
 		<Unit filename="../include/StGLStereo/StFormatEnum.h" />
 		<Unit filename="../include/StGLStereo/StGLProjCamera.h" />
@@ -457,6 +460,7 @@
 		<Unit filename="../include/StImage/StImagePlane.h" />
 		<Unit filename="../include/StImage/StJpegParser.h" />
 		<Unit filename="../include/StImage/StPixelRGB.h" />
+		<Unit filename="../include/StImage/StStbImage.h" />
 		<Unit filename="../include/StImage/StWebPImage.h" />
 		<Unit filename="../include/StLibrary.h" />
 		<Unit filename="../include/StSettings/StEnumParam.h" />

sview-17_04.tar.gz/StShared/StShared.rc -> sview-20_08.tar.gz/StShared/StShared.rc Changed

sview-17_04.tar.gz/StShared/StShared.vcxproj -> sview-20_08.tar.gz/StShared/StShared.vcxproj Changed

@@ -251,6 +251,7 @@
     <ClCompile Include="StGLTexture.cpp" />
     <ClCompile Include="StGLTextureData.cpp" />
     <ClCompile Include="StGLTextureQueue.cpp" />
+    <ClCompile Include="StGLUVCylinder.cpp" />
     <ClCompile Include="StGLUVSphere.cpp" />
     <ClCompile Include="StGLVertexBuffer.cpp" />
     <ClCompile Include="StImage.cpp" />
@@ -271,6 +272,7 @@
     <ClCompile Include="StRegisterImpl.cpp" />
     <ClCompile Include="StResourceManager.cpp" />
     <ClCompile Include="StSettings.cpp" />
+    <ClCompile Include="StStbImage.cpp" />
     <ClCompile Include="StDictionary.cpp" />
     <ClCompile Include="StThread.cpp" />
     <ClCompile Include="StTranslations.cpp" />
@@ -352,6 +354,7 @@
     <ClInclude Include="..\include\StGLMesh\StGLMesh.h" />
     <ClInclude Include="..\include\StGLMesh\StGLPrism.h" />
     <ClInclude Include="..\include\StGLMesh\StGLQuads.h" />
+    <ClInclude Include="..\include\StGLMesh\StGLUVCylinder.h" />
     <ClInclude Include="..\include\StGLMesh\StGLUVSphere.h" />
     <ClInclude Include="..\include\StGLStereo\StFormatEnum.h" />
     <ClInclude Include="..\include\StGLStereo\StGLProjCamera.h" />
@@ -370,6 +373,7 @@
     <ClInclude Include="..\include\StImage\StImagePlane.h" />
     <ClInclude Include="..\include\StImage\StJpegParser.h" />
     <ClInclude Include="..\include\StImage\StPixelRGB.h" />
+    <ClInclude Include="..\include\StImage\StStbImage.h" />
     <ClInclude Include="..\include\StImage\StWebPImage.h" />
     <ClInclude Include="..\include\StSettings\StEnumParam.h" />
     <ClInclude Include="..\include\StSettings\StFloat32Param.h  " />

sview-20_08.tar.gz/StShared/StStbImage.cpp Added

@@ -0,0 +1,147 @@
+/**
+ * Copyright © 2019 Kirill Gavrilov <kirill@sview.ru>
+ *
+ * Distributed under the Boost Software License, Version 1.0.
+ * See accompanying file license-boost.txt or copy at
+ * http://www.boost.org/LICENSE_1_0.txt
+ */
+
+#include <StImage/StStbImage.h>
+
+#include <StStrings/StLogger.h>
+#include <StThreads/StMutex.h>
+#include <StFile/StFileNode.h>
+
+//#define ST_HAVE_STB_IMAGE
+
+#ifdef ST_HAVE_STB_IMAGE
+    #define STB_IMAGE_IMPLEMENTATION
+    //#define STB_IMAGE_RESIZE_IMPLEMENTATION
+    //#define STB_IMAGE_WRITE_IMPLEMENTATION
+    #define STBI_WINDOWS_UTF8
+    #include <stb_image.h>
+    //#include <stb_image_resize.h>
+    //#include <stb_image_write.h>
+
+namespace {
+
+    static StImagePlane::ImgFormat convertFromStbFormat(int theChannels, bool theIsHDR) {
+        switch(theChannels) {
+            case STBI_grey:       return theIsHDR ? StImagePlane::ImgGrayF : StImagePlane::ImgGray;
+            case STBI_grey_alpha: return StImagePlane::ImgUNKNOWN;
+            case STBI_rgb:        return theIsHDR ? StImagePlane::ImgRGBF  : StImagePlane::ImgRGB;
+            case STBI_rgb_alpha:  return theIsHDR ? StImagePlane::ImgRGBAF : StImagePlane::ImgRGBA;
+        }
+        return StImagePlane::ImgUNKNOWN;
+    }
+
+}
+
+#endif
+
+bool StStbImage::init() {
+#ifdef ST_HAVE_STB_IMAGE
+    return true;
+#else
+    return false;
+#endif
+}
+
+StStbImage::StStbImage()
+: myStbImage(NULL) {
+    StStbImage::init();
+}
+
+StStbImage::~StStbImage() {
+    close();
+}
+
+void StStbImage::close() {
+    if(myStbImage != NULL) {
+    #ifdef ST_HAVE_STB_IMAGE
+        stbi_image_free(myStbImage);
+    #endif
+        myStbImage = NULL;
+    }
+}
+
+bool StStbImage::loadExtra(const StString& theFilePath,
+                           ImageType       theImageType,
+                           uint8_t*        theDataPtr,
+                           int             theDataSize,
+                           bool            theIsOnlyRGB) {
+    (void )theIsOnlyRGB;
+    if(!StStbImage::init()) {
+        setState("STB library is not initialized");
+        return false;
+    }
+
+    // reset current data
+    StImage::nullify();
+    setState();
+    close();
+
+#ifdef ST_HAVE_STB_IMAGE
+    bool isHdr = false;
+    int aWidth = 0, aHeight = 0, aChannels = 0;
+    //stbi_set_flip_vertically_on_load(true);
+    if(theDataPtr != NULL) {
+        (void )theImageType;
+        //stbi_info_from_memory();
+        isHdr = stbi_is_hdr_from_memory((unsigned char*)theDataPtr, theDataSize) != 0;
+        if(isHdr) {
+            //myStbImage = stbi_load_16_from_memory((unsigned char*)theDataPtr, theDataSize, &aWidth, &aHeight, &aChannels, STBI_default);
+            myStbImage = stbi_loadf_from_memory((unsigned char*)theDataPtr, theDataSize, &aWidth, &aHeight, &aChannels, STBI_default);
+        } else {
+            myStbImage = stbi_load_from_memory((unsigned char*)theDataPtr, theDataSize, &aWidth, &aHeight, &aChannels, STBI_default);
+        }
+    } else {
+        //stbi_info();
+        isHdr = stbi_is_hdr(theFilePath.toCString()) != 0;
+        if(isHdr) {
+            //myStbImage = stbi_load_16(theFilePath.toCString(), &aWidth, &aHeight, &aChannels, STBI_default);
+            myStbImage = stbi_loadf(theFilePath.toCString(), &aWidth, &aHeight, &aChannels, STBI_default);
+        } else {
+            myStbImage = stbi_load(theFilePath.toCString(), &aWidth, &aHeight, &aChannels, STBI_default);
+        }
+    }
+
+    if(myStbImage == NULL
+    || aWidth  < 1
+    || aHeight < 1) {
+        //stbi_failure_reason()
+        setState("STB library, unable to load image");
+        close();
+        return false;
+    }
+
+    StImagePlane::ImgFormat anImgFormat = convertFromStbFormat(aChannels, isHdr);
+    if(anImgFormat == StImagePlane::ImgUNKNOWN) {
+        setState("STB library, unknown pixel format");
+        close();
+        return false;
+    }
+
+    setColorModelPacked(anImgFormat);
+    changePlane(0).initWrapper(anImgFormat, (unsigned char* )myStbImage, aWidth, aHeight);
+
+    // set debug information
+    StString aDummy, aFileName;
+    StFileNode::getFolderAndFile(theFilePath, aDummy, aFileName);
+    setState(StString("STB library, loaded image '") + aFileName + "' " + getDescription());
+    return true;
+#else
+    (void )theFilePath;
+    (void )theImageType;
+    (void )theDataPtr;
+    (void )theDataSize;
+    return false;
+#endif
+}
+
+bool StStbImage::save(const StString& ,
+                      ImageType ,
+                      StFormat ) {
+    setState("STB library, save operation is NOT implemented");
+    return false;
+}

sview-17_04.tar.gz/StShared/StThread.cpp -> sview-20_08.tar.gz/StShared/StThread.cpp Changed

@@ -1,5 +1,5 @@
 /**
- * Copyright © 2009-2014 Kirill Gavrilov <kirill@sview.ru>
+ * Copyright © 2009-2017 Kirill Gavrilov <kirill@sview.ru>
  *
  * Distributed under the Boost Software License, Version 1.0.
  * See accompanying file license-boost.txt or copy at
@@ -114,20 +114,44 @@
 }
 
 bool StThread::wait() {
+    if(!isValid()) {
+        return false;
+    }
+
 #ifdef _WIN32
-    return isValid() && (WaitForSingleObject((HANDLE )myThread, INFINITE) != WAIT_FAILED);
+    if(WaitForSingleObject((HANDLE )myThread, INFINITE) == WAIT_FAILED) {
+        return false;
+    }
+    CloseHandle((HANDLE )myThread);
+    myThread = NULL;
 #else
-    return isValid() && (pthread_join(myThread, NULL) == 0);
+    if(pthread_join(myThread, NULL) != 0) {
+        return false;
+    }
+    myHasHandle = false;
 #endif
+    return true;
 }
 
 bool StThread::wait(const int theTimeMilliseconds) {
+    if(!isValid()) {
+        return false;
+    }
+
 #ifdef _WIN32
-    return isValid() && (WaitForSingleObject((HANDLE )myThread, (DWORD )theTimeMilliseconds) != WAIT_TIMEOUT);
+    if(WaitForSingleObject((HANDLE )myThread, (DWORD )theTimeMilliseconds) == WAIT_TIMEOUT) {
+        return false;
+    }
+    CloseHandle((HANDLE )myThread);
+    myThread = NULL;
 #else
     (void )theTimeMilliseconds;
-    return isValid() && (pthread_join(myThread, NULL) == 0);
+    if(pthread_join(myThread, NULL) != 0) {
+        return false;
+    }
+    myHasHandle = false;
 #endif
+    return true;
 }
 
 void StThread::kill() {

sview-17_04.tar.gz/StShared/StTranslations.cpp -> sview-20_08.tar.gz/StShared/StTranslations.cpp Changed

@@ -58,6 +58,10 @@
             params.language->changeValues().add("English");
             myLangFolderList.add("English");
         }
+        if(myResMgr->isResourceExist(StString("lang" ST_FILE_SPLITTER "Spanish" ST_FILE_SPLITTER) + myModuleName + StTranslations::DEFAULT_SUFFIX)) {
+            params.language->changeValues().add("Español");
+            myLangFolderList.add("Spanish");
+        }
         if(myResMgr->isResourceExist(StString("lang" ST_FILE_SPLITTER "Russian" ST_FILE_SPLITTER) + myModuleName + StTranslations::DEFAULT_SUFFIX)) {
             params.language->changeValues().add("русский");
             myLangFolderList.add("Russian");
@@ -110,6 +114,12 @@
                 params.language->setValue(int32_t(anIdInList));
                 isLangSet = true;
             }
+        } else if(aLang.isEqualsIgnoreCase(stCString("es"))) {
+            if(myLangFolderList.contains(stCString("Spanish"), anIdInList)
+            || myLangFolderList.contains(stCString("Español"), anIdInList)) {
+                params.language->setValue(int32_t(anIdInList));
+                isLangSet = true;
+            }
         } else if(aLang.isEqualsIgnoreCase(stCString("fr"))) {
             if(myLangFolderList.contains(stCString("French"),   anIdInList)
             || myLangFolderList.contains(stCString("français"), anIdInList)) {
@@ -170,6 +180,8 @@
     const StString& aLang = params.language->getValues()[theNewLang];
     if(aLang == stCString("русский")) {
         myLangCode = "rus";
+    } else if(aLang == stCString("Español")) {
+        myLangCode = "spa";
     } else if(aLang == stCString("français")) {
         myLangCode = "fre";
         //myLangCode = "fra";

sview-17_04.tar.gz/StShared/StVirtualKeys.cpp -> sview-20_08.tar.gz/StShared/StVirtualKeys.cpp Changed

sview-17_04.tar.gz/StShared/StWebPImage.cpp -> sview-20_08.tar.gz/StShared/StWebPImage.cpp Changed

sview-17_04.tar.gz/StShared/stAV.cpp -> sview-20_08.tar.gz/StShared/stAV.cpp Changed

@@ -1,5 +1,5 @@
 /**
- * Copyright © 2011-2016 Kirill Gavrilov <kirill@sview.ru>
+ * Copyright © 2011-2020 Kirill Gavrilov <kirill@sview.ru>
  *
  * Distributed under the Boost Software License, Version 1.0.
  * See accompanying file license-boost.txt or copy at
@@ -35,7 +35,8 @@
     #endif
 #endif
 
-#if(LIBAVCODEC_VERSION_INT >= AV_VERSION_INT(52, 30, 0))
+#if(LIBAVCODEC_VERSION_INT >= AV_VERSION_INT(52, 30, 0)) \
+&& ((LIBAVCODEC_VERSION_INT < AV_VERSION_INT(58, 9, 100)) || defined(ST_LIBAV_FORK))
 class StFFMpegLocker {
 
         public:
@@ -104,11 +105,14 @@
 #endif
 const AVPixelFormat stAV::PIX_FMT::NONE       = AVPixelFormat(-1);
 const AVPixelFormat stAV::PIX_FMT::YUV420P    = AVPixelFormat( 0);
+const AVPixelFormat stAV::PIX_FMT::YUVA420P   = ST_AV_GETPIXFMT("yuva420p");
 const AVPixelFormat stAV::PIX_FMT::PAL8       = ST_AV_GETPIXFMT("pal8");
 const AVPixelFormat stAV::PIX_FMT::GRAY8      = ST_AV_GETPIXFMT("gray");
 const AVPixelFormat stAV::PIX_FMT::GRAY16     = ST_AV_GETPIXFMT("gray16");
 const AVPixelFormat stAV::PIX_FMT::YUV422P    = ST_AV_GETPIXFMT("yuv422p");
+const AVPixelFormat stAV::PIX_FMT::YUVA422P   = ST_AV_GETPIXFMT("yuva422p");
 const AVPixelFormat stAV::PIX_FMT::YUV444P    = ST_AV_GETPIXFMT("yuv444p");
+const AVPixelFormat stAV::PIX_FMT::YUVA444P   = ST_AV_GETPIXFMT("yuva444p");
 const AVPixelFormat stAV::PIX_FMT::YUV410P    = ST_AV_GETPIXFMT("yuv410p");
 const AVPixelFormat stAV::PIX_FMT::YUV411P    = ST_AV_GETPIXFMT("yuv411p");
 const AVPixelFormat stAV::PIX_FMT::YUV440P    = ST_AV_GETPIXFMT("yuv440p");
@@ -134,6 +138,7 @@
 const AVPixelFormat stAV::PIX_FMT::BGRA64     = ST_AV_GETPIXFMT("bgra64");
 const AVPixelFormat stAV::PIX_FMT::XYZ12      = ST_AV_GETPIXFMT("xyz12");
 const AVPixelFormat stAV::PIX_FMT::DXVA2_VLD  = ST_AV_GETPIXFMT("dxva2_vld");
+const AVPixelFormat stAV::PIX_FMT::VIDEOTOOLBOX_VLD  = ST_AV_GETPIXFMT("videotoolbox_vld");
 
 // TODO (Kirill Gavrilov#9) remove this stuff
 namespace {
@@ -154,6 +159,8 @@
         return stCString("none");
     } else if(theFrmt == stAV::PIX_FMT::YUV420P) {
         return stCString("yuv420p");
+    } else if(theFrmt == stAV::PIX_FMT::YUVA420P) {
+        return stCString("yuva420p");
     } else if(theFrmt == stAV::PIX_FMT::PAL8) {
         return stCString("pal8");
     } else if(theFrmt == stAV::PIX_FMT::GRAY8) {
@@ -162,8 +169,12 @@
         return stCString("gray16");
     } else if(theFrmt == stAV::PIX_FMT::YUV422P) {
         return stCString("yuv422p");
+    } else if(theFrmt == stAV::PIX_FMT::YUVA422P) {
+        return stCString("yuva422p");
     } else if(theFrmt == stAV::PIX_FMT::YUV444P) {
         return stCString("yuv444p");
+    } else if(theFrmt == stAV::PIX_FMT::YUVA444P) {
+        return stCString("yuva444p");
     } else if(theFrmt == stAV::PIX_FMT::YUV410P) {
         return stCString("yuv410p");
     } else if(theFrmt == stAV::PIX_FMT::YUV411P) {
@@ -263,17 +274,20 @@
 #endif
 
     static bool initOnce() {
+    #if(LIBAVCODEC_VERSION_INT >= AV_VERSION_INT(52, 30, 0)) \
+    && ((LIBAVCODEC_VERSION_INT < AV_VERSION_INT(58, 9, 100)) || defined(ST_LIBAV_FORK))
         // register own mutex to prevent multithreading errors
         // while using FFmpeg functions
-    #if(LIBAVCODEC_VERSION_INT >= AV_VERSION_INT(52, 30, 0))
         stFFMpegLocker.init();
-    #else
-        #warning Ancient FFmpeg used, initialization performed in thread-unsafe manner!
     #endif
+
+    #if(LIBAVFORMAT_VERSION_INT < AV_VERSION_INT(58, 9, 100)) || defined(ST_LIBAV_FORK)
         // Notice, this call is absolutely not thread safe!
         // you should never call it first time from concurrent threads.
         // But after first initialization is done this is safe to call it anyhow
         av_register_all();
+    #endif
+
     #if(LIBAVFORMAT_VERSION_INT >= AV_VERSION_INT(53, 13, 0))
         avformat_network_init();
     #endif
@@ -301,10 +315,13 @@
 
 bool stAV::isFormatYUVPlanar(const AVCodecContext* theCtx) {
     return theCtx->pix_fmt == stAV::PIX_FMT::YUV420P
+        || theCtx->pix_fmt == stAV::PIX_FMT::YUVA420P
         || theCtx->pix_fmt == stAV::PIX_FMT::YUVJ420P
         || theCtx->pix_fmt == stAV::PIX_FMT::YUV422P
+        || theCtx->pix_fmt == stAV::PIX_FMT::YUVA422P
         || theCtx->pix_fmt == stAV::PIX_FMT::YUVJ422P
         || theCtx->pix_fmt == stAV::PIX_FMT::YUV444P
+        || theCtx->pix_fmt == stAV::PIX_FMT::YUVA444P
         || theCtx->pix_fmt == stAV::PIX_FMT::YUVJ444P
         || theCtx->pix_fmt == stAV::PIX_FMT::YUV440P
         || theCtx->pix_fmt == stAV::PIX_FMT::YUVJ440P
@@ -328,6 +345,7 @@
     if(thePixFmt == stAV::PIX_FMT::NONE) {
         return false;
     } else if(thePixFmt == stAV::PIX_FMT::YUV420P
+           || thePixFmt == stAV::PIX_FMT::YUVA420P
            || thePixFmt == stAV::PIX_FMT::YUVJ420P
            || thePixFmt == stAV::PIX_FMT::YUV420P9
            || thePixFmt == stAV::PIX_FMT::YUV420P10
@@ -337,7 +355,9 @@
         theDims.widthU  = theDims.widthV  = theDims.widthY  / 2;
         theDims.heightU = theDims.heightV = theDims.heightY / 2;
         theDims.isFullScale = (thePixFmt == stAV::PIX_FMT::YUVJ420P);
+        theDims.hasAlpha = thePixFmt == stAV::PIX_FMT::YUVA420P;
     } else if(thePixFmt == stAV::PIX_FMT::YUV422P
+           || thePixFmt == stAV::PIX_FMT::YUVA422P
            || thePixFmt == stAV::PIX_FMT::YUVJ422P
            || thePixFmt == stAV::PIX_FMT::YUV422P9
            || thePixFmt == stAV::PIX_FMT::YUV422P10
@@ -346,7 +366,9 @@
         theDims.heightY = theDims.heightU = theDims.heightV = theHeight;
         theDims.widthU  = theDims.widthV  = theDims.widthY  / 2;
         theDims.isFullScale = (thePixFmt == stAV::PIX_FMT::YUVJ422P);
+        theDims.hasAlpha = false;
     } else if(thePixFmt == stAV::PIX_FMT::YUV444P
+           || thePixFmt == stAV::PIX_FMT::YUVA444P
            || thePixFmt == stAV::PIX_FMT::YUVJ444P
            || thePixFmt == stAV::PIX_FMT::YUV444P9
            || thePixFmt == stAV::PIX_FMT::YUV444P10
@@ -354,23 +376,27 @@
         theDims.widthY  = theDims.widthU  = theDims.widthV  = theWidth;
         theDims.heightY = theDims.heightU = theDims.heightV = theHeight;
         theDims.isFullScale = (thePixFmt == stAV::PIX_FMT::YUVJ444P);
+        theDims.hasAlpha = false;
     } else if(thePixFmt == stAV::PIX_FMT::YUV440P
            || thePixFmt == stAV::PIX_FMT::YUVJ440P) {
         theDims.widthY  = theDims.widthU  = theDims.widthV  = theWidth;
         theDims.heightY = theHeight;
         theDims.heightU = theDims.heightV = theDims.heightY / 2;
         theDims.isFullScale = (thePixFmt == stAV::PIX_FMT::YUVJ440P);
+        theDims.hasAlpha = false;
     } else if(thePixFmt == stAV::PIX_FMT::YUV411P) {
         theDims.widthY  = theDims.widthU  = theDims.widthV  = theWidth;
         theDims.heightY = theDims.heightU = theDims.heightV = theHeight;
         theDims.widthU  = theDims.widthV  = theDims.widthY  / 4;
         theDims.isFullScale = false;
+        theDims.hasAlpha = false;
     } else if(thePixFmt == stAV::PIX_FMT::YUV410P) {
         theDims.widthY  = theDims.widthU  = theDims.widthV  = theWidth;
         theDims.heightY = theHeight;
         theDims.widthU  = theDims.widthV  = theDims.widthY  / 4;
         theDims.heightU = theDims.heightV = theDims.heightY / 4;
         theDims.isFullScale = false;
+        theDims.hasAlpha = false;
     } else {
         return false;
     }
@@ -583,7 +609,9 @@
 }
 
 stAV::meta::Dict* stAV::meta::getFrameMetadata(AVFrame* theFrame) {
-#if(LIBAVCODEC_VERSION_INT >= AV_VERSION_INT(54, 38, 100)) && !defined(ST_LIBAV_FORK)
+#if(LIBAVCODEC_VERSION_INT >= AV_VERSION_INT(57, 81, 102)) && !defined(ST_LIBAV_FORK)
+    return theFrame->metadata;
+#elif(LIBAVCODEC_VERSION_INT >= AV_VERSION_INT(54, 38, 100)) && !defined(ST_LIBAV_FORK)
     return av_frame_get_metadata(theFrame);
 #else
     return NULL;
@@ -619,6 +647,16 @@
 #endif
 }
 
+bool stAV::isEnabledInputProtocol(const StString& theProtocol) {
+    void* anOpaque = NULL;
+    for(const char* aName = avio_enum_protocols(&anOpaque, 0); aName != NULL; aName = avio_enum_protocols(&anOpaque, 0)) {
+        if(stAreEqual(theProtocol.toCString(), aName, theProtocol.Size + 1)) {
+            return true;
+        }
+    }
+    return false;
+}
+
 StString stAV::getVersionInfo() {
 #if(LIBAVCODEC_VERSION_INT >= AV_VERSION_INT(57, 24, 0))
     return av_version_info();

sview-17_04.tar.gz/contentiousIntegration/build_sview_android.sh -> sview-20_08.tar.gz/contentiousIntegration/build_sview_android.sh Changed

sview-17_04.tar.gz/contentiousIntegration/build_sview_linux.sh -> sview-20_08.tar.gz/contentiousIntegration/build_sview_linux.sh Changed

sview-17_04.tar.gz/contentiousIntegration/build_sview_osx.sh -> sview-20_08.tar.gz/contentiousIntegration/build_sview_osx.sh Changed

sview-17_04.tar.gz/copy_res.bat -> sview-20_08.tar.gz/copy_res.bat Changed

sview-17_04.tar.gz/copy_res.sh -> sview-20_08.tar.gz/copy_res.sh Changed

sview-17_04.tar.gz/debian/changelog.tmpl -> sview-20_08.tar.gz/debian/changelog.tmpl Changed

@@ -4,6 +4,53 @@
 
  -- Kirill Gavrilov <kirill@sview.ru>  unknown_date
 
+sview (1:20.05-1~unknown_distrib) unknown_distrib; urgency=low
+
+  + Added Spanish translation files.
+  + Image Viewer - added trilinear texture filtering option generating mip-maps.
+  + Image Viewer - support 1x6 cubemap layout.
+  + Image Viewer - panorama is now automatically enabled for JPEG files with GPano:ProjectionType tag.
+  + Image Viewer - panorama is now automatically enabled for JPEG files with 360Stereo/360Mono tags (game screenshots).
+  + Image Viewer - support DDS-packed cubemaps.
+  + Movie Player - image-based subtitles size can be now adjusted.
+  * Movie Player - workaround subtitles seeking issues for attached SRT files.
+  * Movie Player - fixed ASS subtitles formatting issue on files without closure tags.
+  * Movie Player - added handling of image-based subtitles encoded as stereoscopic pair (side-by-side).
+  * Image Viewer - fixed poor quality on saving JPEG (yuv420p) image into PNG (rgb).
+  * Image Viewer - fixed displaying WebP images with alpha channel (yuva pixel formats).
+  * fontconfig library is now used to retrieve paths to system fonts on Linux.
+
+ -- Kirill Gavrilov <kirill@sview.ru>  Wed, 20 May 2020 15:25:33 +0300
+
+sview (1:19.08-2~unknown_distrib) unknown_distrib; urgency=low
+
+  + Support VR180 hemisphere and cylindrical panorama inputs.
+  * Minor corrections/improvements.
+
+ -- Kirill Gavrilov <kirill@sview.ru>  Sun, 04 Aug 2019 20:00:00 +0300
+
+sview (17.10-1~unknown_distrib) unknown_distrib; urgency=low
+
+  + Image Viewer - display Slideshow delay parameter in Settings dialog.
+  + Movie Player - add general information about the stream (bitrate, codec, PAR, DAR) in File Info dialog.
+  * Movie Player - fix seeking to the very beginning of the file.
+  * Movie Player - fix (workaround) displaying attached image within some mp3 files.
+  * Fix text rendering artifacts when using glyphs with kerning defined.
+  * Fix compilation on glibc 2.26+ (Ubuntu 17.10+)
+
+ -- Kirill Gavrilov <kirill@sview.ru>  Mon, 23 Oct 2017 22:29:34 +0300
+
+sview (17.04-1~unknown_distrib) unknown_distrib; urgency=low
+
+  + Movie Player - add audio positioning while playing spheric panorama video.
+  + Movie Player - handle rotation info stored within video stream.
+  + Image Viewer, Movie Player - add overlay control for adjusting image color
+  + Movie Player - add option to force HRTF mixing in OpenAL Soft.
+  * Fix saving PNG images when using up-to-date FFmpeg.
+  * Image Viewer, Movie Player - fix too slow opening File Info dialog in case of long metadata.
+
+ -- Kirill Gavrilov <kirill@sview.ru>  Sun, 16 Apr 2017 21:45:20 +0300
+
 sview (16.04-1~unknown_distrib) unknown_distrib; urgency=low
 
   + Movie Player - implement GPU-accelerated conversion of NV12 and XYZ12 formats.

sview-17_04.tar.gz/debian/control -> sview-20_08.tar.gz/debian/control Changed

sview-17_04.tar.gz/debian/copyright -> sview-20_08.tar.gz/debian/copyright Changed

sview-17_04.tar.gz/distribution/build.bat -> sview-20_08.tar.gz/distribution/build.bat Changed

@@ -25,31 +25,18 @@
 
 if exist "%~dp0env.bat" call "%~dp0env.bat"
 
-set YEAR=%date:~-2,4%
-set MONTH00=%date:~-7,2%
-set MONTH=%date:~-7,2%
-set DAY=%date:~0,2%
-
-rem Remove first zero
-if "%MONTH%"=="01" set MONTH=1
-if "%MONTH%"=="02" set MONTH=2
-if "%MONTH%"=="03" set MONTH=3
-if "%MONTH%"=="04" set MONTH=4
-if "%MONTH%"=="05" set MONTH=5
-if "%MONTH%"=="06" set MONTH=6
-if "%MONTH%"=="07" set MONTH=7
-if "%MONTH%"=="08" set MONTH=8
-if "%MONTH%"=="09" set MONTH=9
-
-if "%DAY%"=="01" set DAY=1
-if "%DAY%"=="02" set DAY=2
-if "%DAY%"=="03" set DAY=3
-if "%DAY%"=="04" set DAY=4
-if "%DAY%"=="05" set DAY=5
-if "%DAY%"=="06" set DAY=6
-if "%DAY%"=="07" set DAY=7
-if "%DAY%"=="08" set DAY=8
-if "%DAY%"=="09" set DAY=9
+for /F "skip=1 delims=" %%F in ('
+  wmic PATH Win32_LocalTime GET Day^,Month^,Year /FORMAT:TABLE
+') do (
+  for /F "tokens=1-3" %%L in ("%%F") do (
+    set DAY=%%L
+    set DAY00=0%%L
+    set MONTH=%%M
+    set MONTH00=0%%M
+    set YEAR=%%N
+  )
+)
+set YEAR=%YEAR:~-2,4%
 
 set SVIEW_DISTR_PATH_X86=%~dp0temp\sView-win-x86
 set SVIEW_DISTR_PATH_AMD64=%~dp0temp\sView-win-amd64
@@ -87,6 +74,8 @@
 
 rem Activate experimental WebP support
 echo #define ST_HAVE_WEBP>> "%SVIEW_BUILD_CONF%"
+rem Activate notifications about sView updates available on sview.ru
+echo #define ST_UPDATES_CHECK>> "%SVIEW_BUILD_CONF%"
 
 rem Create configuration for InnoSetup build script
 echo #define SVIEW_VER      "%YEAR%.%MONTH%.%SVIEW_VER_TYPE_NUM%.%DAY%"> config.iss
@@ -109,9 +98,23 @@
 echo Perform rebuild MSVC x86
 rem www.codeblocks.org
 rem --multiple-instance
-start /WAIT /D "%CB_PATH%" codeblocks.exe --rebuild --target="WIN_vc_x86"   "%~dp0..\workspace.workspace"
+start /WAIT /D "%CB_PATH%" codeblocks.exe --rebuild --target="WIN_vc_x86" "%~dp0..\workspace.workspace"
+if errorlevel 1 (
+  move /Y ..\include\stconfig.conf.buildbak ..\include\stconfig.conf
+  echo Build FAILED
+  pause
+  exit /B
+  goto :eof
+)
 echo Perform rebuild MSVC x86_64
 start /WAIT /D "%CB_PATH%" codeblocks.exe --rebuild --target="WIN_vc_AMD64" "%~dp0..\workspace.workspace"
+if errorlevel 1 (
+  move /Y ..\include\stconfig.conf.buildbak ..\include\stconfig.conf
+  echo Build FAILED
+  pause
+  exit /B
+  goto :eof
+)
 
 rem move default config file back
 move /Y ..\include\stconfig.conf.buildbak ..\include\stconfig.conf

sview-17_04.tar.gz/distribution/build.iss -> sview-20_08.tar.gz/distribution/build.iss Changed

@@ -38,6 +38,7 @@
 SetupIconFile=media\sView_Setup.ico
 WizardImageFile=media\sView_WizImage.bmp
 WizardSmallImageFile=media\sView_WizImageSmall.bmp
+UninstallDisplayIcon={app}\{#SVIEW_EXE_NAME}
 ; Additional requirements
 ChangesAssociations=true
 ChangesEnvironment=true
@@ -54,6 +55,7 @@
 ;InfoBeforeFile: {#SVIEW_DISTR_PATH_x86}\info\ReadMeEn.rtf
 Name: english; MessagesFile: compiler:Default.isl;           LicenseFile: {#SVIEW_DISTR_PATH_x86}\info\license.rtf
 Name: russian; MessagesFile: compiler:Languages\Russian.isl; LicenseFile: {#SVIEW_DISTR_PATH_x86}\info\license.rtf
+Name: spanish; MessagesFile: compiler:Languages\Spanish.isl; LicenseFile: {#SVIEW_DISTR_PATH_x86}\info\license.rtf
 Name: french;  MessagesFile: compiler:Languages\French.isl;  LicenseFile: {#SVIEW_DISTR_PATH_x86}\info\license.rtf
 Name: german;  MessagesFile: compiler:Languages\German.isl;  LicenseFile: {#SVIEW_DISTR_PATH_x86}\info\license.rtf
 Name: korean;  MessagesFile: compiler:Languages\Korean.isl;  LicenseFile: {#SVIEW_DISTR_PATH_x86}\info\license.rtf
@@ -63,11 +65,13 @@
 ; Installation types
 english.FullInstallation=Full Installation
 russian.FullInstallation=Полная установка
+spanish.FullInstallation=Instalación completa
 french.FullInstallation=Installation complète
 german.FullInstallation=Vollständige Installation
 korean.FullInstallation=전체 설치
 chinese.FullInstallation=全部安装
 english.CustomInstallation=Custom Installation
+spanish.CustomInstallation=Instalación personalizada
 russian.CustomInstallation=Выборочная установка
 french.CustomInstallation=Installation personnalisée
 german.CustomInstallation=Benutzerdefinierte Installation
@@ -75,53 +79,72 @@
 chinese.CustomInstallation=自定义安装
 ; Components
 english.StCore=Core files
+spanish.StCore=Archivos compartidos
 russian.StCore=Общие файлы
 german.StCore=Core-Dateien
 english.StBrowserPlugins=NPAPI Browser plugin (Firefox, Google Chrome, Opera,...)
+spanish.StBrowserPlugins=Plugin de navegador NPAPI (Firefox, Google Chrome, Opera,...)
 russian.StBrowserPlugins=NPAPI плагин для браузеров Firefox, Google Chrome, Opera,...
 english.StActiveXPlugin=ActiveX control for Internet Explorer
+spanish.StActiveXPlugin=Control ActiveX para Internet Explorer
 russian.StActiveXPlugin=ActiveX плагин для браузера Internet Explorer
 english.StDrawers=Media types support
+spanish.StDrawers=Soporte de tipos de medios
 russian.StDrawers=Поддержка медиа-типов
 english.StImageViewer=Stereoscopic Image Viewer
+spanish.StImageViewer=Visor de imagen estereoscópica
 russian.StImageViewer=Просмотр стереоизображений
 english.StMoviePlayer=Stereoscopic Movie Player
+spanish.StMoviePlayer=Reproductor de películas estereoscópicas
 russian.StMoviePlayer=Воспроизведение стереовидео
 english.StRenderers=Device support
+spanish.StRenderers=Soporte del dispositivo
 russian.StRenderers=Поддержка устройств стереовывода
 german.StRenderers=Geräteunterstützung
 english.StOutAnaglyph=Anaglyph glasses
+spanish.StOutAnaglyph=Gafas anaglíficas
 russian.StOutAnaglyph=Анаглифные очки
 german.StOutAnaglyph=Anaglyphenbrille
 english.StOutDual=Mirror Displays, Dual Projectors
+spanish.StOutDual=Salida espejo, Salida dual
 russian.StOutDual=Зеркальные системы, 2х-проекторные системы
 english.StOutInterlace=Interlaced Displays, DLP TV
+spanish.StOutInterlace=Filas entrelazadas, DLP TV
 russian.StOutInterlace=Чересстрочные мониторы, DLP ТВ
 english.StOutIZ3D=IZ3D Display
+spanish.StOutIZ3D=Visualización IZ3D
 russian.StOutIZ3D=Монитор IZ3D
 german.StOutIZ3D=iZ3D-Bildschirmen
 english.StOutPageFlip=Shutter glasses
+spanish.StOutPageFlip=Gafas de obturador
 russian.StOutPageFlip=Затворные очки
 german.StOutPageFlip=Shutterbrille
 english.StOutDistorted=Distorted output
+spanish.StOutDistorted=Salida distorsionada
 russian.StOutDistorted=Искажённый вывод
 ; File associations
 english.FileAssociations=File associations
+spanish.FileAssociations=Asociaciones de archivos
 russian.FileAssociations=Файловые ассоциации
 german.FileAssociations=Dateizuordnungen
 english.AssocStereoImages=Associate stereoscopic images with sView (*.jps; *.pns; *.mpo)
+spanish.AssocStereoImages=Asociar imágenes estereoscópicas con sView (*.jps; *.pns; *.mpo)
 russian.AssocStereoImages=Связать с sView стереоизображения (*.jps; *.pns; *.mpo)
 german.AssocStereoImages=Associate stereoskopische Bilder mit sView (*.jps; *.pns; *.mpo)
 english.AssocImages=Associate common images with sView (*.jpg; *.png; *.webp; *.bmp; *.exr; *.hdr; *.tga)
+spanish.AssocImages=Asociar imágenes comunes con sView (*.jpg; *.png; *.webp; *.bmp; *.exr; *.hdr; *.tga)
 russian.AssocImages=Связать с sView обычные изображения (*.jpg; *.png; *.webp; *.bmp; *.exr; *.hdr; *.tga)
 german.AssocImages=Associate normale Bilder mit sView (*.jpg; *.png; *.webp; *.bmp; *.exr; *.hdr; *.tga)
 english.AssocMovies=Associate video files with sView (*.avi; *.mkv; *.mk3d; *.webm; *.wmv; *.ts)
+spanish.AssocMovies=Asociar archivos de video con sView (*.avi; *.mkv; *.mk3d; *.webm; *.wmv; *.ts)
 russian.AssocMovies=Связать с sView видеофайлы (*.avi; *.mkv; *.mk3d; *.webm; *.wmv; *.ts)
 german.AssocMovies=Associate Videodateien mit sView (*.avi; *.mkv; *.mk3d; *.webm; *.wmv; *.ts)
 english.AssocMusic=Associate music files with sView (*.mp3; *.ogg; *.wav; *.flac; *.ape)
+spanish.AssocMusic=Asociar archivos de música con sView (*.mp3; *.ogg; *.wav; *.flac; *.ape)
 russian.AssocMusic=Связать с sView музыкальные файлы (*.mp3; *.ogg; *.wav; *.flac; *.ape)
 german.AssocMusic=Associate Musikdateien mit sView (*.mp3; *.ogg; *.wav; *.flac; *.ape)
 english.AssocPlaylists=Associate playlist files with sView (*.m3u)
+spanish.AssocPlaylists=Asociar archivos de lista de reproducción con sView (*.m3u)
 ; OpenAL soft
 english.OpenALSoft51=OpenAL soft - force 5.1 channel output
 russian.OpenALSoft51=OpenAL soft - force 5.1 channel output
@@ -258,9 +281,7 @@
 Name: {group}\sView - Image Viewer; Filename: {app}\amd64\{#SVIEW_EXE_NAME}; Components: StDrawers\StImageViewer; IconFilename: {app}\amd64\{#SVIEW_EXE_NAME}; Comment: "{cm:StImageViewer}";  IconIndex: 0; Parameters: "--in=image --demo=""{app}\demo.jps"""; Check: IsWin64
 Name: {group}\sView - Movie Player; Filename: {app}\{#SVIEW_EXE_NAME};       Components: StDrawers\StMoviePlayer; IconFilename: {app}\{#SVIEW_EXE_NAME};       Comment: "{cm:StMoviePlayer}";  IconIndex: 0; Parameters: "--in=video"; Check: not IsWin64
 Name: {group}\sView - Movie Player; Filename: {app}\amd64\{#SVIEW_EXE_NAME}; Components: StDrawers\StMoviePlayer; IconFilename: {app}\amd64\{#SVIEW_EXE_NAME}; Comment: "{cm:StMoviePlayer}";  IconIndex: 0; Parameters: "--in=video"; Check: IsWin64
-Name: {group}\Extras\sView - Failsafe;                    Filename: {app}\{#SVIEW_EXE_NAME};       Components: StDrawers\StImageViewer and StRenderers\StOutAnaglyph; IconFilename: {app}\{#SVIEW_EXE_NAME};       Comment: Failsafe sView launch; IconIndex: 0; Parameters: --out=StOutAnaglyph --in=image
 Name: {group}\Extras\sView - Autodetection;               Filename: {app}\{#SVIEW_EXE_NAME};       Components: StDrawers\StImageViewer; IconFilename: {app}\{#SVIEW_EXE_NAME};       Comment: Failsafe sView launch; IconIndex: 0; Parameters: --out=Auto --in=image
-Name: {group}\Extras\sView - Movie Player 32bit;          Filename: {app}\{#SVIEW_EXE_NAME};       Components: StDrawers\StMoviePlayer; IconFilename: {app}\{#SVIEW_EXE_NAME};       Comment: "{cm:StMoviePlayer}";  IconIndex: 0; Parameters: "--in=video";         Check: IsWin64
 Name: {group}\Extras\sView - Movie Player (Last File);    Filename: {app}\{#SVIEW_EXE_NAME};       Components: StDrawers\StMoviePlayer; IconFilename: {app}\{#SVIEW_EXE_NAME};       Comment: "{cm:StMoviePlayer}";  IconIndex: 0; Parameters: "--last";             Check: not IsWin64
 Name: {group}\Extras\sView - Movie Player (Last File);    Filename: {app}\amd64\{#SVIEW_EXE_NAME}; Components: StDrawers\StMoviePlayer; IconFilename: {app}\amd64\{#SVIEW_EXE_NAME}; Comment: "{cm:StMoviePlayer}";  IconIndex: 0; Parameters: "--last";             Check: IsWin64
 Name: {group}\Extras\sView - Diagnostics;                 Filename: {app}\{#SVIEW_EXE_NAME};       Components: StCore;                  IconFilename: {app}\{#SVIEW_EXE_NAME};       Comment: sView Diagnostics;     IconIndex: 0; Parameters: "--in=StDiagnostics"; Check: not IsWin64
@@ -286,6 +307,7 @@
 Root: HKCU; Subkey: SOFTWARE\sView;       ValueType: none; Flags: uninsdeletekey; Tasks: ; Languages: ; ValueData: sView 2011
 Root: HKCU; Subkey: Software\sView\sView; ValueType: string; ValueName: language; ValueData: русский;  Tasks: ; Languages: russian; Flags: uninsdeletekey
 Root: HKCU; Subkey: Software\sView\sView; ValueType: string; ValueName: language; ValueData: English;  Tasks: ; Languages: english; Flags: uninsdeletekey
+Root: HKCU; Subkey: Software\sView\sView; ValueType: string; ValueName: language; ValueData: Español;  Tasks: ; Languages: spanish; Flags: uninsdeletekey
 Root: HKCU; Subkey: Software\sView\sView; ValueType: string; ValueName: language; ValueData: français; Tasks: ; Languages: french;  Flags: uninsdeletekey
 Root: HKCU; Subkey: Software\sView\sView; ValueType: string; ValueName: language; ValueData: Deutsch;  Tasks: ; Languages: german;  Flags: uninsdeletekey
 Root: HKCU; Subkey: Software\sView\sView; ValueType: string; ValueName: language; ValueData: Korean;   Tasks: ; Languages: korean;  Flags: uninsdeletekey

sview-17_04.tar.gz/distribution/buildDebSrc_ppa.sh -> sview-20_08.tar.gz/distribution/buildDebSrc_ppa.sh Changed

@@ -23,14 +23,22 @@
 # Ubuntu 15.10     (Wily Werewolf)
 # Ubuntu 16.04 LTS (Xenial Xerus)
 # Ubuntu 16.10     (Yakkety Yak)
-#aDistribs=("trusty" "vivid" "wily" "xenial" "yakkety")
-aDistribs=("vivid" "wily" "xenial")
+# Ubuntu 17.04     (Zesty Zapus)
+# Ubuntu 17.10     (Artful Aardvark)
+# Ubuntu 18.04 LTS (Bionic Beaver)
+# Ubuntu 18.10     (Cosmic Cuttlefish)
+# Ubuntu 19.04     (Disco Dingo)
+# Ubuntu 19.10
+# Ubuntu 20.04 LTS (Focal Fossa)
+# Ubuntu 20.10     (Groovy Gorilla)
+aDistribs=("xenial" "bionic" "focal")
 
 # Debian
 #aDistribs=("stable" "unstable" "testing-proposed-updates" "experimental")
 
 # remove temporary files
 rm -f temp/*.build
+rm -f temp/*.buildinfo
 rm -f temp/*.changes
 rm -f temp/*.dsc
 rm -f temp/*.tar.gz
@@ -41,18 +49,20 @@
 for aDistr in "${aDistribs[@]}"
 do
   echo "Prepare source package for '$aDistr'"
-  sed "s/unknown_distrib/${aDistr}/g"                "debian/changelog.tmpl" > "debian/changelogtmp1"
-  sed "s/unknown_version/${aDebVersion}~${aDistr}/g" "debian/changelogtmp1"  > "debian/changelogtmp2"
-  sed "s/unknown_date/${aCurrentDate}/g"             "debian/changelogtmp2"  > "debian/changelog"
+  sed "s/unknown_distrib/${aDistr}/g"                  "debian/changelog.tmpl" > "debian/changelogtmp1"
+  sed "s/unknown_version/1:${aDebVersion}~${aDistr}/g" "debian/changelogtmp1"  > "debian/changelogtmp2"
+  sed "s/unknown_date/${aCurrentDate}/g"               "debian/changelogtmp2"  > "debian/changelog"
   rm -f debian/changelogtmp*
 
   mkdir -p ../$aDistr
   debuild -S
-  mv -f ../*.build   ../$aDistr
-  mv -f ../*.changes ../$aDistr
-  mv -f ../*.dsc     ../$aDistr
-  mv -f ../*.tar.gz  ../$aDistr
-  mv -f ../*.tar.xz  ../$aDistr
+  mv -f ../*.build     ../$aDistr
+  mv -f ../*.buildinfo ../$aDistr
+  mv -f ../*.changes   ../$aDistr
+  mv -f ../*.dsc       ../$aDistr
+  mv -f ../*.tar.*z    ../$aDistr
+  #mv -f ../*.tar.gz    ../$aDistr
+  #mv -f ../*.tar.xz    ../$aDistr
 done
 
 #for aDistr in "${aDistribs[@]}"

sview-17_04.tar.gz/distribution/buildMac.sh -> sview-20_08.tar.gz/distribution/buildMac.sh Changed

sview-20_08.tar.gz/distribution/qmake Added

sview-20_08.tar.gz/distribution/qmake/.gitignore Added

sview-20_08.tar.gz/distribution/qmake/custom.pri.template Added

sview-20_08.tar.gz/distribution/qmake/dummy.cpp Added

sview-20_08.tar.gz/distribution/qmake/sView.pro Added

@@ -0,0 +1,29 @@
+# This is a Solution project for sView.
+# It is intended only for code navigation using Qt Creator, not for building project!
+#
+# To use this project, open it in Qt Creator, "Run qmake" once,
+# close the project and open it anew, until the list of sView modules will not appear in Projects list.
+# Then "Run qmake" and "Build Project" which would redirect to Makefile in sView root folder.
+TEMPLATE = subdirs
+
+# Iterate over Modules and generate sub-projects
+aSolTkList = StShared StGLWidgets StCore StOutAnaglyph StOutDual StOutInterlace StOutPageFlip StOutIZ3D StOutDistorted StImageViewer StMoviePlayer StDiagnostics StCADViewer StBrowserPlugin sview StTests
+for (aSolToolkit, aSolTkList) {
+  eval(sviewtkgen_$${aSolToolkit}.input  = $$_PRO_FILE_PWD_/sViewToolkit.pro.in)
+  eval(sviewtkgen_$${aSolToolkit}.output = $$_PRO_FILE_PWD_/$${aSolToolkit}/$${aSolToolkit}.pro)
+  eval(sviewkgen_$${aSolToolkit}.config = verbatim)
+  eval(QMAKE_SUBSTITUTES += sviewtkgen_$${aSolToolkit})
+  SUBDIRS += $${aSolToolkit}
+
+  !equals(aSolToolkit, StShared) {
+    #$${aSolToolkit}.depends += StShared
+  }
+}
+
+aTxtListTxt = $$files($$_PRO_FILE_PWD_/../../license-*.txt)
+aTxtListMd1 = $$files($$_PRO_FILE_PWD_/../../*.md)
+aTxtListMd2 = $$files($$_PRO_FILE_PWD_/../../docs/*.md)
+OTHER_FILES += $$aTxtListTxt
+OTHER_FILES += $$aTxtListMd1
+OTHER_FILES += $$aTxtListMd2
+OTHER_FILES += $$_PRO_FILE_PWD_/../../Makefile

sview-20_08.tar.gz/distribution/qmake/sViewToolkit.pro.in Added

sview-20_08.tar.gz/distribution/qmake/tk.pri Added

@@ -0,0 +1,85 @@
+# This is a project template file defining an sView Toolkit.
+# This project should be included with predefined ST_TOOLKIT_NAME variable.
+
+#TEMPLATE = lib
+TEMPLATE = aux
+
+# Disable some dummy Qt defaults
+QT -= core gui
+CONFIG -= qt app_bundle
+CONFIG -= debug_and_release
+
+sViewRoot = $$_PRO_FILE_PWD_/../../..
+DESTDIR = $$sViewRoot/build
+LIBS += -L$$sViewRoot/build
+exists(custom.pri) { include(custom.pri) }
+
+aSrcListHpp0 = $$files($$sViewRoot/$$ST_TOOLKIT_NAME/*.h,     true)
+aSrcListHpp1 = $$files($$sViewRoot/include/$$ST_TOOLKIT_NAME/*.h)
+aSrcListCpp  = $$files($$sViewRoot/$$ST_TOOLKIT_NAME/*.cpp,   true)
+aSrcListMm   = $$files($$sViewRoot/$$ST_TOOLKIT_NAME/*.mm,    true)
+aSrcListJava = $$files($$sViewRoot/$$ST_TOOLKIT_NAME/*.java,  true)
+aSrcListRc   = $$files($$sViewRoot/$$ST_TOOLKIT_NAME/*.rc,    true)
+aSrcListXml  = $$files($$sViewRoot/$$ST_TOOLKIT_NAME/*.xml,   true)
+aSrcListPlist= $$files($$sViewRoot/$$ST_TOOLKIT_NAME/*.plist, true)
+INCLUDEPATH += $$sViewRoot/include
+INCLUDEPATH += $$sViewRoot/3rdparty/include
+HEADERS     += $$aSrcListHpp0
+HEADERS     += $$aSrcListHpp1
+!equals(TEMPLATE, aux) {
+  SOURCES += $$aSrcListCpp
+  mac { SOURCES += $$aSrcListMm }
+}
+OTHER_FILES += $$aSrcListJava
+OTHER_FILES += $$aSrcListRc
+OTHER_FILES += $$aSrcListXml
+OTHER_FILES += $$aSrcListPlist
+
+aLngList = chinese czech english french german korean russian
+for (aLngIter, aLngList) {
+  aSrcListLng = $$files($$sViewRoot/$$ST_TOOLKIT_NAME/lang/$$aLngIter/*.lng)
+  OTHER_FILES += $$aSrcListLng
+}
+
+equals(ST_TOOLKIT_NAME, StShared) {
+  aSrcListHppX = $$files($$sViewRoot/include/*.h,true)
+  HEADERS += $$aSrcListHppX
+
+  DEFINES += ST_SHARED_DLL
+} else:equals(ST_TOOLKIT_NAME, sview) {
+  # Define sView executable which Qt Creator will automatically use for "Run".
+  # Touch dummy.cpp to force QMAKE_POST_LINK redirecting to main Makefile to be executed within each build.
+  TEMPLATE = app
+  mac {
+    TARGET = sView.app/Contents/MacOS/sView
+  } else {
+    TARGET = sView
+  }
+  SOURCES += $$_PRO_FILE_PWD_/../dummy.cpp
+  QMAKE_POST_LINK += rm $(TARGET); touch $$_PRO_FILE_PWD_/../dummy.cpp;
+
+  # Redirect clean to main Makefile.
+  realclean.commands = $(MAKE) --directory $$sViewRoot clean
+  clean.depends = realclean
+  QMAKE_EXTRA_TARGETS += clean realclean
+
+  # Prepare make arguments
+  aNbJobs = $$system(getconf _NPROCESSORS_ONLN)
+  ST_MAKE_ARGS = -j$$aNbJobs
+  ST_DEBUG = 0
+  CONFIG(debug, debug|release) { ST_DEBUG = 1 }
+
+  #ST_MAKE_TARGET = android
+  !isEmpty(ST_MAKE_TARGET) { ST_MAKE_ARGS += $$ST_MAKE_TARGET }
+  aMakeEnvList = ST_DEBUG ANDROID_NDK ANDROID_BUILD_TOOLS ANDROID_PLATFORM ANDROID_EABI FFMPEG_ROOT FREETYPE_ROOT OPENAL_ROOT LIBCONFIG_ROOT ANDROID_KEY_GUI ANDROID_KEYSTORE ANDROID_KEYSTORE_PASSWORD ANDROID_KEY ANDROID_KEY_PASSWORD
+  for (aMakeEnvIter, aMakeEnvList) {
+    !isEmpty($${aMakeEnvIter}) { ST_MAKE_ARGS += $${aMakeEnvIter}=$$val_escape($${aMakeEnvIter}) }
+  }
+
+  # Redirect build to main Makefile.
+  QMAKE_POST_LINK   += $(MAKE) --directory $$sViewRoot $$ST_MAKE_ARGS;
+  #realbuild.commands = $(MAKE) --directory $$sViewRoot $$ST_MAKE_ARGS
+  #realbuild.target   = realbuild
+  #QMAKE_EXTRA_TARGETS += realbuild
+  #POST_TARGETDEPS     += realbuild
+}

sview-17_04.tar.gz/docs/INSTALL.md -> sview-20_08.tar.gz/docs/INSTALL.md Changed

sview-17_04.tar.gz/include/StAV/StAVFrame.h -> sview-20_08.tar.gz/include/StAV/StAVFrame.h Changed

sview-20_08.tar.gz/include/StAV/StAVIOJniHttpContext.h Added

@@ -0,0 +1,85 @@
+/**
+ * Copyright © 2019 Kirill Gavrilov <kirill@sview.ru>
+ *
+ * Distributed under the Boost Software License, Version 1.0.
+ * See accompanying file license-boost.txt or copy at
+ * http://www.boost.org/LICENSE_1_0.txt
+ */
+
+#ifndef __StAVIOJniHttpContext_h_
+#define __StAVIOJniHttpContext_h_
+
+#include <StJNI/StJNIEnv.h>
+#include <StAV/StAVIOContext.h>
+
+/**
+ * Custom AVIO context for reading http/https file using JNI
+ * (java.net.URLConnection and java.nio.channels.ReadableByteChannel classes).
+ * The main purpose of this class is providing a fallback https protocol support
+ * in case when FFmpeg has been built without this support.
+ */
+class StAVIOJniHttpContext : public StAVIOContext {
+
+        public:
+
+    /**
+     * Empty constructor.
+     * WARNING! av_jni_get_java_vm() will be used to attach current thread to JavaVM and initialize pointers.
+     * Therefore, JavaVM should be set to FFmpeg beforehand, and this context should be used only within the same working thread.
+     */
+    ST_CPPEXPORT StAVIOJniHttpContext();
+
+    /**
+     * Destructor. Closes open stream and detaches current thread from JavaVM.
+     */
+    ST_CPPEXPORT virtual ~StAVIOJniHttpContext();
+
+    /**
+     * Close the file.
+     */
+    ST_CPPEXPORT void close();
+
+    /**
+     * Open specified URL.
+     */
+    ST_CPPEXPORT bool open(const StString& theUrl);
+
+    /**
+     * Read from the file.
+     */
+    ST_CPPEXPORT virtual int read(uint8_t* theBuf,
+                                  int      theBufSize) ST_ATTR_OVERRIDE;
+
+    /**
+     * Writing is not supported.
+     */
+    ST_LOCAL virtual int write(uint8_t* , int ) ST_ATTR_OVERRIDE { return -1; }
+
+    /**
+     * Seek within the file.
+     */
+    ST_CPPEXPORT virtual int64_t seek(int64_t theOffset,
+                                      int     theWhence) ST_ATTR_OVERRIDE;
+
+        private:
+
+    /**
+     * (Re)open HTTPS stream at specific offset.
+     */
+    bool reopenReadChannel(int64_t theOffset);
+    struct FunctionTable;
+
+        protected:
+
+    FunctionTable* myFunctions; //!< JNI function table
+    StJNIEnv myJEnv;        //!< JavaVM environment
+    StString myUrl;         //!< opened URL
+    void*    myReadChannel; //!< pointer to java.nio.channels.ReadableByteChannel
+    int64_t  myContentLen;  //!< file length
+    int64_t  myPosition;    //!< current position within the stream
+
+};
+
+ST_DEFINE_HANDLE(StAVIOJniHttpContext, StAVIOContext);
+
+#endif // __StAVIOJniHttpContext_h_

sview-17_04.tar.gz/include/StAV/StAVImage.h -> sview-20_08.tar.gz/include/StAV/StAVImage.h Changed

@@ -1,5 +1,5 @@
 /**
- * Copyright © 2011-2015 Kirill Gavrilov <kirill@sview.ru>
+ * Copyright © 2011-2020 Kirill Gavrilov <kirill@sview.ru>
  *
  * Distributed under the Boost Software License, Version 1.0.
  * See accompanying file license-boost.txt or copy at
@@ -46,6 +46,9 @@
     ST_CPPEXPORT static bool resize(const StImage& theImageFrom,
                                     StImage&       theImageTo);
 
+    ST_CPPEXPORT static bool resizePlane(const StImagePlane& theImageFrom,
+                                         StImagePlane&       theImageTo);
+
         public:
 
     /**
@@ -59,9 +62,14 @@
     ST_CPPEXPORT virtual ~StAVImage();
 
     /**
+     * Create new instance.
+     */
+    virtual StHandle<StImageFile> createEmpty() const ST_ATTR_OVERRIDE { return new StAVImage(); }
+
+    /**
      * Close currently opened image context and release memory.
      */
-    ST_CPPEXPORT virtual void close();
+    ST_CPPEXPORT virtual void close() ST_ATTR_OVERRIDE;
 
     /**
      * Decode image from specified file or memory pointer.
@@ -77,7 +85,7 @@
      */
     ST_CPPEXPORT virtual bool save(const StString& theFilePath,
                                    ImageType       theImageType,
-                                   StFormat        theSrcFormat = StFormat_AUTO);
+                                   StFormat        theSrcFormat = StFormat_AUTO) ST_ATTR_OVERRIDE;
 
         private:

sview-17_04.tar.gz/include/StAV/StAVPacket.h -> sview-20_08.tar.gz/include/StAV/StAVPacket.h Changed

sview-17_04.tar.gz/include/StAV/stAV.h -> sview-20_08.tar.gz/include/StAV/stAV.h Changed

@@ -1,5 +1,5 @@
 /**
- * Copyright © 2011-2016 Kirill Gavrilov <kirill@sview.ru>
+ * Copyright © 2011-2020 Kirill Gavrilov <kirill@sview.ru>
  *
  * Distributed under the Boost Software License, Version 1.0.
  * See accompanying file license-boost.txt or copy at
@@ -41,6 +41,25 @@
     #include <libavutil/spherical.h>
 #endif
 
+#if(LIBAVFORMAT_VERSION_INT >= AV_VERSION_INT(57, 33, 100))
+    #define ST_AV_NEWCODECPAR
+#endif
+
+#ifndef AV_NUM_DATA_POINTERS
+    #define AV_NUM_DATA_POINTERS 4
+#endif
+
+// Compatibility with older FFmpeg (API change since 2015-07-27 - lavc 56.56.100 / 56.35.0)
+#ifndef AV_INPUT_BUFFER_PADDING_SIZE
+    #define AV_INPUT_BUFFER_PADDING_SIZE FF_INPUT_BUFFER_PADDING_SIZE
+#endif
+#ifndef AV_CODEC_FLAG_GLOBAL_HEADER
+    #define AV_CODEC_FLAG_GLOBAL_HEADER CODEC_FLAG_GLOBAL_HEADER
+#endif
+#ifndef AV_CODEC_FLAG2_IGNORE_CROP
+    #define AV_CODEC_FLAG2_IGNORE_CROP CODEC_FLAG2_IGNORE_CROP
+#endif
+
 #ifdef _MSC_VER
     #pragma warning(default : 4244)
 #endif
@@ -210,8 +229,11 @@
         ST_SHARED_CPPEXPORT AVPixelFormat GRAY16;    //!< Y, 16bpp
         // planar YUV formats
         ST_SHARED_CPPEXPORT AVPixelFormat YUV420P;   //!< planar YUV 4:2:0, 12bpp, (1 Cr & Cb sample per 2x2 Y samples)
+        ST_SHARED_CPPEXPORT AVPixelFormat YUVA420P;  //!< planar YUV 4:2:0, 20bpp, (1 Cr & Cb sample per 2x2 Y & A samples)
         ST_SHARED_CPPEXPORT AVPixelFormat YUV422P;   //!< planar YUV 4:2:2, 16bpp, (1 Cr & Cb sample per 2x1 Y samples)
+        ST_SHARED_CPPEXPORT AVPixelFormat YUVA422P;  //!< planar YUV 4:2:2  24bpp, (1 Cr & Cb sample per 2x1 Y & A samples)
         ST_SHARED_CPPEXPORT AVPixelFormat YUV444P;   //!< planar YUV 4:4:4, 24bpp, (1 Cr & Cb sample per 1x1 Y samples)
+        ST_SHARED_CPPEXPORT AVPixelFormat YUVA444P;  //!< planar YUV 4:4:4  32bpp, (1 Cr & Cb sample per 1x1 Y & A samples)
         ST_SHARED_CPPEXPORT AVPixelFormat YUV410P;   //!< planar YUV 4:1:0,  9bpp, (1 Cr & Cb sample per 4x4 Y samples)
         ST_SHARED_CPPEXPORT AVPixelFormat YUV411P;   //!< planar YUV 4:1:1, 12bpp, (1 Cr & Cb sample per 4x1 Y samples)
         ST_SHARED_CPPEXPORT AVPixelFormat YUV440P;   //!< planar YUV 4:4:0 (1 Cr & Cb sample per 1x2 Y samples)
@@ -244,8 +266,12 @@
         // XYZ formats
         ST_SHARED_CPPEXPORT AVPixelFormat XYZ12;
         // HWAccel formats
-        ST_SHARED_CPPEXPORT AVPixelFormat DXVA2_VLD;
+        ST_SHARED_CPPEXPORT AVPixelFormat DXVA2_VLD; // Windows
+        ST_SHARED_CPPEXPORT AVPixelFormat VIDEOTOOLBOX_VLD; // macOS
 
+        /**
+         * @sa StImage::formatImgPixelFormat()
+         */
         ST_CPPEXPORT StCString getString(const AVPixelFormat theFrmt);
     }
 
@@ -261,6 +287,7 @@
         int  heightV;
         int  bitsPerComp;
         bool isFullScale;
+        bool hasAlpha;
     };
 
     /**
@@ -315,6 +342,39 @@
     }
 
     /**
+     * Return codec context from the stream using deprecated API.
+     * The new API suggests using AVStream::codecpar, but this is confusing.
+     * So we would better waiting until old API is completely removed.
+     */
+    inline AVCodecContext* getCodecCtx(const AVStream* theStream) {
+    ST_DISABLE_DEPRECATION_WARNINGS
+        return theStream->codec;
+    ST_ENABLE_DEPRECATION_WARNINGS
+    }
+
+    /**
+     * Get codec type from the stream.
+     */
+    inline AVMediaType getCodecType(const AVStream* theStream) {
+    #ifdef ST_AV_NEWCODECPAR
+        return theStream->codecpar->codec_type;
+    #else
+        return theStream->codec->codec_type;
+    #endif
+    }
+
+    /**
+     * Get codec id from the stream.
+     */
+    inline AVCodecID getCodecId(const AVStream* theStream) {
+    #ifdef ST_AV_NEWCODECPAR
+        return theStream->codecpar->codec_id;
+    #else
+        return theStream->codec->codec_id;
+    #endif
+    }
+
+    /**
      * av_version_info() wrapper; return FFmpeg version info.
      */
     ST_CPPEXPORT StString getVersionInfo();
@@ -330,6 +390,11 @@
     ST_CPPEXPORT bool setJavaVM(void* theJavaVM);
 
     /**
+     * avio_enum_protocols() wrapper for checking input protocol.
+     */
+    ST_CPPEXPORT bool isEnabledInputProtocol(const StString& theProtocol);
+
+    /**
      * Audio functions
      */
     namespace audio {
@@ -440,6 +505,19 @@
             return readTag(getFrameMetadata(theFrame), theKey, theValue);
         }
 
+        /**
+         * Retrieve language id from the stream.
+         */
+        inline StString readLang(AVStream* theStream) {
+        #if(LIBAVUTIL_VERSION_INT >= AV_VERSION_INT(51, 5, 0))
+            StString aLang;
+            stAV::meta::readTag(theStream, stCString("language"), aLang);
+            return aLang;
+        #else
+            return theStream->language;
+        #endif
+        }
+
     }
 
 #ifdef ST_AV_NEWSTEREO

sview-17_04.tar.gz/include/StCore/StAndroidGlue.h -> sview-20_08.tar.gz/include/StCore/StAndroidGlue.h Changed

@@ -12,6 +12,8 @@
 #ifndef __StAndroidGlue_h_
 #define __StAndroidGlue_h_
 
+#include "StVirtualKeys.h"
+
 #include <StSlots/StSignal.h>
 #include <StStrings/StString.h>
 #include <StThreads/StMutex.h>
@@ -23,6 +25,7 @@
 
 class StAndroidGlue;
 class StApplication;
+class StKeysState;
 
 /**
  * Data associated with an ALooper fd that will be returned as the "outData" when that source has data ready.
@@ -38,50 +41,6 @@
 };
 
 /**
- * The sentry class for attaching the current thread to JavaVM.
- */
-class StJNIEnv {
-
-        public:
-
-    /**
-     * Main constructor, tries to attach JavaVM to the current thread.
-     */
-    ST_CPPEXPORT StJNIEnv(JavaVM* theJavaVM);
-
-    /**
-     * Destructor, automatically detaches JavaVM from current thread.
-     * Has no effect if JavaVM has been attached to the thread before creating this sentry.
-     */
-    ST_CPPEXPORT ~StJNIEnv();
-
-    /**
-     * Detach from current thread right now.
-     * Has no effect if JavaVM has been attached to the thread before creating this sentry.
-     */
-    ST_CPPEXPORT void detach();
-
-    /**
-     * Cast to actual JNIEnv instance.
-     */
-    ST_LOCAL JNIEnv* operator->() const {
-        return myJniEnv;
-    }
-
-    /**
-     * Return true if JNI environment is NULL.
-     */
-    ST_LOCAL bool isNull() const { return myJniEnv == NULL; }
-
-        private:
-
-    JavaVM* myJavaVM;   //!< pointer to global Java VM instance
-    JNIEnv* myJniEnv;   //!< JNI environment for working thread
-    bool    myToDetach; //!< flag to detach
-
-};
-
-/**
  * Interface for the standard glue code of a threaded application.
  */
 class StAndroidGlue {
@@ -201,6 +160,16 @@
     ST_CPPEXPORT void setWindowFlags(const int theFlags);
 
     /**
+     * Setup window title.
+     */
+    ST_CPPEXPORT void setWindowTitle(const StString& theTitle);
+
+    /**
+     * Set/release WAKE_LOCK.
+     */
+    ST_CPPEXPORT void setWakeLock(const StString& theTitle, bool theToLock);
+
+    /**
      * Turn stereo output on using device-specific API.
      */
     ST_CPPEXPORT void setHardwareStereoOn(const bool theToEnable);
@@ -232,10 +201,12 @@
      * @param theNewFile pop onNewIntent() open file event
      * @param theQuaternion device orientation
      * @param theToSwapEyes swap left/right views
+     * @param theKeys       keys state
      */
     ST_CPPEXPORT void fetchState(StString&             theNewFile,
                                  StQuaternion<double>& theQuaternion,
-                                 bool&                 theToSwapEyes);
+                                 bool&                 theToSwapEyes,
+                                 const StKeysState&    theKeys);
 
     /**
      * Return device memory class.
@@ -294,7 +265,7 @@
      * Read the open file from currently set intent.
      * The method calls the Java method readOpenPath() of StActivity which will call setOpenPath().
      */
-    ST_CPPEXPORT void readOpenPath();
+    ST_CPPEXPORT void readOpenPath(bool theToNullifyIntent);
 
     ST_CPPEXPORT void printConfig();
     ST_CPPEXPORT void freeSavedState();
@@ -363,6 +334,11 @@
      */
     ST_LOCAL void setSwapEyes(bool theToSwapLR);
 
+    /**
+     * Return TRUE if key is processed by application.
+     */
+    ST_LOCAL bool isKeyOverridden(int theKeyCode);
+
         private: //! @name ANativeActivity callbacks
 
     ST_LOCAL static void processInputWrapper(StAndroidGlue*       theApp,
@@ -453,7 +429,10 @@
     AInputQueue*            myInputQueuePending;
     ANativeWindow*          myWindow;            //!< native window to draw into
     ANativeWindow*          myWindowPending;
+    StString                myWindowTitle;       //!< window title
+    StString                myWakeLockTitle;     //!< wake lock title
     bool                    myIsChangingSurface; //!< flag indicating surface changing state
+    bool                    myIsWakeLockSet;     //!< flag indicating WAKE_LOCK enabled state
     int                     myWindowFlags;       //!< active window flags
     int                     myActivityState;     //!< Current state of the app's activity (APP_CMD_START, APP_CMD_RESUME, APP_CMD_PAUSE, or APP_CMD_STOP)
     int                     myMemoryClassMiB;    //!< device memory class
@@ -474,7 +453,10 @@
     StAndroidPollSource     myInputPollSource;
 
     StMutex                 myFetchLock;         //!< fetch data lock
+    bool                    myRegKeys[ST_VK_NB]; //!< map of registered (used in hot-key combinations) keys
     StString                myStAppClass;        //!< application class name (e.g. image, video)
+    StString                myBuildModel;        //!< android.os.Build.MODEL
+    StString                myBuildDevice;       //!< android.os.Build.DEVICE
     StString                myStereoApiId;       //!< stereo API identifier
     bool                    myToEnableStereoHW;  //!< on/off state of stereo API
     StString                myDndPath;           //!< intent data string

sview-17_04.tar.gz/include/StCore/StApplication.h -> sview-20_08.tar.gz/include/StCore/StApplication.h Changed

@@ -1,6 +1,6 @@
 /**
  * StCore, window system independent C++ toolkit for writing OpenGL applications.
- * Copyright © 2009-2016 Kirill Gavrilov <kirill@sview.ru>
+ * Copyright © 2009-2017 Kirill Gavrilov <kirill@sview.ru>
  *
  * Distributed under the Boost Software License, Version 1.0.
  * See accompanying file license-boost.txt or copy at
@@ -46,6 +46,27 @@
      */
     ST_CPPEXPORT static StHandle<StOpenInfo> parseProcessArguments();
 
+    /**
+     * Read default drawer from setting.
+     */
+    ST_CPPEXPORT static bool readDefaultDrawer(StHandle<StOpenInfo>& theInfo);
+
+    /**
+     * @return TRUE if specified drawer is set as default in settings.
+     */
+    ST_CPPEXPORT bool isDefaultDrawer(const StString& theDrawer) const;
+
+    /**
+     * Save the drawer as default in settings.
+     */
+    ST_CPPEXPORT void setDefaultDrawer(const StString& theDrawer) const;
+
+    /**
+     * Create a named parameter for setting drawer as default.
+     */
+    ST_CPPEXPORT StHandle<StBoolParamNamed> createDefaultDrawerParam(const StString& theDrawer,
+                                                                     const StString& theTitle) const;
+
         public:
 
     /**
@@ -106,6 +127,11 @@
     ST_CPPEXPORT int exec();
 
     /**
+     * @return file to open in another drawer
+     */
+    const StHandle<StOpenInfo>& getOpenFileInOtherDrawer() const { return myOpenFileOtherApp; }
+
+    /**
      * Return active renderer and main application window.
      */
     ST_CPPEXPORT const StHandle<StWindow>& getMainWindow() const;
@@ -318,6 +344,7 @@
     StHandle<StWindow>    myWindow;                //!< active renderer and main application window
     StHandle<StWindow>    mySwitchTo;              //!< new renderer to switch to
     StHandle<StOpenInfo>  myOpenFileInfo;          //!< file to open
+    StHandle<StOpenInfo>  myOpenFileOtherApp;      //!< file to open in another drawer
     std::map< int, StHandle<StAction> >
                           myActions;               //!< ID -> Action map
     std::map< std::string, int >

sview-17_04.tar.gz/include/StCore/StEvent.h -> sview-20_08.tar.gz/include/StCore/StEvent.h Changed

@@ -71,6 +71,7 @@
     stEvent_TouchMove,  //!< StTouchEvent,  touch moved
     stEvent_TouchCancel,//!< StTouchEvent,  touch cancelled
     stEvent_GestureCancel,     //!< StGestureEvent, abort the gestures
+    stEvent_Gesture1Tap,       //!< StGestureEvent, 1 finger  single tap
     stEvent_Gesture1DoubleTap, //!< StGestureEvent, 1 finger  double tap
     stEvent_Gesture2Move,      //!< StGestureEvent, 2 fingers moving in sync
     stEvent_Gesture2Rotate,    //!< StGestureEvent, 2 fingers rotating
@@ -186,6 +187,65 @@
     float         DeltaY;           //!< precise  delta for vertical   scroll
     bool          IsFromMultiTouch; //!< when true, scrolling is simulated from multi-touch gesture by system (OS X) and touches will come in parallel
 
+    /**
+     * Reset event.
+     */
+    void reset() {
+        Type  = stEvent_Scroll;
+        Time  = 0.0;
+        PointX = 0.0;
+        PointY = 0.0;
+        StepsX = 0;
+        StepsY = 0;
+        DeltaX = 0.0f;
+        DeltaY = 0.0f;
+        IsFromMultiTouch = false;
+    }
+
+    /**
+     * Initialize event.
+     */
+    void init(double theTime,
+              double thePointX,
+              double thePointY,
+              float  theDeltaX,
+              float  theDeltaY,
+              bool   theIsFromMultiTouch) {
+        Type  = stEvent_Scroll;
+        Time  = theTime;
+        PointX = thePointX;
+        PointY = thePointY;
+        StepsX = 0;
+        StepsY = 0;
+        DeltaX = theDeltaX;
+        DeltaY = theDeltaY;
+        IsFromMultiTouch = theIsFromMultiTouch;
+    }
+
+    /**
+     * Compute accumulated integer steps from X scroll event.
+     */
+    int accumulateStepsX(int theInc, int theStepSize) { return accumulateSteps(StepsX, theInc, theStepSize); }
+
+    /**
+     * Compute accumulated integer steps from Y scroll event.
+     */
+    int accumulateStepsY(int theInc, int theStepSize) { return accumulateSteps(StepsY, theInc, theStepSize); }
+
+    /**
+     * Compute accumulated integer steps from scroll event.
+     */
+    static int accumulateSteps(int& theAcc, int theInc, int theStepSize) {
+        theAcc += theInc;
+        int aNbSteps = 0;
+        for(; theAcc <= -theStepSize; theAcc += theStepSize) {
+            --aNbSteps;
+        }
+        for(; theAcc >= theStepSize; theAcc -= theStepSize) {
+            ++aNbSteps;
+        }
+        return aNbSteps;
+    }
 };
 
 /**

sview-17_04.tar.gz/include/StCore/StKeysState.h -> sview-20_08.tar.gz/include/StCore/StKeysState.h Changed

@@ -1,6 +1,6 @@
 /**
  * StCore, window system independent C++ toolkit for writing OpenGL applications.
- * Copyright © 2013 Kirill Gavrilov <kirill@sview.ru>
+ * Copyright © 2013-2017 Kirill Gavrilov <kirill@sview.ru>
  *
  * Distributed under the Boost Software License, Version 1.0.
  * See accompanying file license-boost.txt or copy at
@@ -32,6 +32,26 @@
     ST_CPPEXPORT ~StKeysState();
 
     /**
+     * Reset map of registered keys.
+     */
+    ST_CPPEXPORT void resetRegisteredKeys();
+
+    /**
+     * Return map of registered keys.
+     */
+    ST_LOCAL const bool* getRegisteredKeys() const { return myRegKeys; }
+
+    /**
+     * Register key.
+     */
+    ST_CPPEXPORT void registerKey(StVirtKey theKey);
+
+    /**
+     * Unregister key.
+     */
+    ST_CPPEXPORT void unregisterKey(StVirtKey theKey);
+
+    /**
      * Release all pressed keys (window lost input focus etc.).
      */
     ST_CPPEXPORT void reset();
@@ -83,9 +103,10 @@
 
         private:
 
-    mutable StMutex myLock; //!< mutex for thread-safe access
-    bool    myKeys[256];    //!< virtual keys pressed state
-    double  myTimes[256];   //!< time when key was pressed or released
+    mutable StMutex myLock;              //!< mutex for thread-safe access
+    double          myTimes  [ST_VK_NB]; //!< time when key was pressed or released
+    bool            myKeys   [ST_VK_NB]; //!< virtual keys pressed state
+    bool            myRegKeys[ST_VK_NB]; //!< registered keys (used by some hot-keys)
 
 };

sview-17_04.tar.gz/include/StCore/StMonitor.h -> sview-20_08.tar.gz/include/StCore/StMonitor.h Changed

@@ -118,30 +118,22 @@
     /**
      * @return current vertical refresh rate
      */
-    ST_LOCAL int getFreq() const {
-        return myFreq;
-    }
+    ST_LOCAL float getFreq() const { return myFreq; }
 
     /**
      * @param theFrequency current vertical refresh rate
      */
-    ST_LOCAL void setFreq(const int theFrequency) {
-        myFreq = theFrequency;
-    }
+    ST_LOCAL void setFreq(float theFrequency) { myFreq = theFrequency; }
 
     /**
      * @return maximal vertical refresh rate
      */
-    ST_LOCAL int getFreqMax() const {
-        return myFreqMax;
-    }
+    ST_LOCAL float getFreqMax() const { return myFreqMax; }
 
     /**
      * @param theFrequencyMax maximal vertical refresh rate
      */
-    ST_LOCAL void setFreqMax(const int theFrequencyMax) {
-        myFreqMax = theFrequencyMax;
-    }
+    ST_LOCAL void setFreqMax(float theFrequencyMax) { myFreqMax = theFrequencyMax; }
 
     /**
      * @return GPU to which monitor is connected to
@@ -227,8 +219,8 @@
     StEDIDParser myEdid;    //!< EDID data block if available
     StRectI_t    myRect;    //!< virtual space (rectangle)
     int          mySysId;   //!< monitor id
-    int          myFreq;    //!< frequency in Hertz
-    int          myFreqMax; //!< maximum frequency in Hertz
+    float        myFreq;    //!< frequency in Hertz
+    float        myFreqMax; //!< maximum frequency in Hertz
     float        myScale;   //!< hight pixel density scale factor
     Orientation  myOrient;  //!< monitor orientation

sview-17_04.tar.gz/include/StCore/StVirtualKeys.h -> sview-20_08.tar.gz/include/StCore/StVirtualKeys.h Changed

@@ -1,6 +1,6 @@
 /**
  * StCore, window system independent C++ toolkit for writing OpenGL applications.
- * Copyright © 2007-2015 Kirill Gavrilov <kirill@sview.ru>
+ * Copyright © 2007-2020 Kirill Gavrilov <kirill@sview.ru>
  *
  * Distributed under the Boost Software License, Version 1.0.
  * See accompanying file license-boost.txt or copy at
@@ -299,7 +299,7 @@
     ST_VK_OEM_MINUS  = 0xBD,   // 189 = VK_OEM_MINUS   | '-' any country
     ST_VK_PERIOD     = 0xBE,   // 190 = VK_OEM_PERIOD  | '.' any country
     ST_VK_SLASH      = 0xBF,   // 191 = VK_OEM_2       | '/?' for US
-    ///ST_VK_OEM_3       = 0xC0,  // 192 = VK_OEM_3       | '`~' for US*
+    ST_VK_TILDE      = 0xC0,   // 192 = VK_OEM_3       | '`~' for US*
 
     ST_VK_BRACKETLEFT  = 0xDB, // 219 = VK_OEM_4       | '[{' for US
     ST_VK_BACKSLASH    = 0xDC, // 220 = VK_OEM_5       | '\|' for US
@@ -312,6 +312,21 @@
     ST_VK_FUNCTION     = 0xD9, // 217 | OS X fn key      (NSFunctionKeyMask)
 
 };
+enum {
+    ST_VK_NB = 256 //!< maximum number of virtual keys
+};
+
+/**
+ * Remove modifiers from hot key combination and return the base virtual key.
+ */
+ST_LOCAL inline StVirtKey getBaseKeyFromHotKey(unsigned int theHotKey) {
+    unsigned int aKey = theHotKey & ~(ST_VF_SHIFT | ST_VF_CONTROL | ST_VF_MENU | ST_VF_COMMAND | ST_VF_FUNCTION);
+    if(aKey == 0
+    || aKey >= ST_VK_NB) {
+        return ST_VK_NULL;
+    }
+    return (StVirtKey )aKey;
+}
 
 /**
  * Encode single Virtual Key.

sview-17_04.tar.gz/include/StCore/StWindow.h -> sview-20_08.tar.gz/include/StCore/StWindow.h Changed

@@ -96,6 +96,7 @@
     StWinAttr_SlaveMon,            //!< integer, slave window monitor id, 1 by default
     StWinAttr_SplitCfg,            //!< StWinSplit, split master window
     StWinAttr_ToAlignEven,         //!< boolean, align window position to even numbers, FALSE by default
+    StWinAttr_ExclusiveFullScreen, //!< boolean, exclusive fullscreen mode, FALSE by default
 };
 
 typedef struct tagStSlaveWindowCfg {
@@ -351,7 +352,7 @@
      * @param theWinEnum subwindow ID
      * @return rectangle within window from bottom-left corner (ready for OpenGL calls)
      */
-    ST_CPPEXPORT StGLBoxPx stglViewport(const int theWinEnum) const;
+    ST_CPPEXPORT virtual StGLBoxPx stglViewport(const int theWinEnum) const;
 
     /**
      * @return GUI scale factor for compatibility with low-resolution and high-resolution displays
@@ -420,6 +421,11 @@
     ST_CPPEXPORT void setStereoOutput(bool theStereoState);
 
     /**
+    * Return maximum display update framerate.
+    */
+    ST_CPPEXPORT virtual float getMaximumTargetFps() const;
+
+    /**
      * @return FPS control rule
      */
     ST_CPPEXPORT double getTargetFps() const;
@@ -478,6 +484,11 @@
     ST_CPPEXPORT virtual StQuaternion<double> getDeviceOrientation() const;
 
     /**
+     * Return custom stereo projection frustums.
+     */
+    ST_CPPEXPORT virtual bool getCustomProjection(StRectF_t& theLeft, StRectF_t& theRight) const;
+
+    /**
      * Return TRUE if Left/Right eyes should be swapped by external event.
      */
     ST_CPPEXPORT virtual bool toSwapEyesHW() const;
@@ -573,13 +584,6 @@
     ST_CPPEXPORT void stglSwap(const int theWinEnum);
 
     /**
-     * This method should be called only by inheritors
-     * to override keyboard input logic.
-     * @return cached keyboard keys state for this window
-     */
-    ST_CPPEXPORT StKeysState& changeKeysState();
-
-    /**
      * @return upload time in seconds
      */
     ST_CPPEXPORT double getEventTime(const uint32_t theTime) const;
@@ -608,6 +612,13 @@
 
         public:
 
+    /**
+     * This method should be called only by inheritors
+     * to override keyboard input logic.
+     * @return cached keyboard keys state for this window
+     */
+    ST_CPPEXPORT StKeysState& changeKeysState();
+
     ST_CPPEXPORT void* getNativeOglWin() const;
     ST_CPPEXPORT void* getNativeOglDC()  const;
     ST_CPPEXPORT void* getNativeOglRC()  const;

sview-17_04.tar.gz/include/StFT/StFTFont.h -> sview-20_08.tar.gz/include/StFT/StFTFont.h Changed

@@ -26,13 +26,21 @@
     StString Italic;
     StString BoldItalic;
 
-    ST_LOCAL StFTFontFamily() {}
+    // face index within font container
+    int RegularFace;
+    int BoldFace;
+    int ItalicFace;
+    int BoldItalicFace;
+
+    ST_LOCAL StFTFontFamily() : RegularFace (0), BoldFace (0), ItalicFace (0), BoldItalicFace (0) {}
 };
 
 struct StFTFontPack {
     StFTFontFamily Western;
     StFTFontFamily CJK;
     StFTFontFamily Korean;
+    StFTFontFamily Arabic;      //!< fallback font for Arabic letters
+    StFTFontFamily MiscSymbols; //!< fallback font for Miscellaneous Symbols
 };
 
 /**
@@ -70,8 +78,10 @@
      */
     enum Subset {
         Subset_General,
-        Subset_Korean,  //!< modern Korean letters
-        Subset_CJK,     //!< Chinese characters (Chinese, Japanese, Korean and Vietnam)
+        Subset_Korean,      //!< modern Korean letters
+        Subset_CJK,         //!< Chinese characters (Chinese, Japanese, Korean and Vietnam)
+        Subset_Arabic,      //!< Arabic  characters
+        Subset_MiscSymbols, //!< Miscellaneous Symbols 0x2600 - 0x26FF
         SubsetsNB
     };
 
@@ -83,7 +93,9 @@
             || (theUChar >= 0x04E00 && theUChar <= 0x09FFF)
             || (theUChar >= 0x0F900 && theUChar <= 0x0FAFF)
             || (theUChar >= 0x20000 && theUChar <= 0x2A6DF)
-            || (theUChar >= 0x2F800 && theUChar <= 0x2FA1F);
+            || (theUChar >= 0x2F800 && theUChar <= 0x2FA1F)
+            //
+            || (theUChar >= 0x030A0 && theUChar <= 0x030FF); // Katakana (Japanese) is NOT part of CJK, but CJK fonts usually include these symbols
     }
 
     /**
@@ -96,6 +108,27 @@
     }
 
     /**
+     * @return true if specified character is within subset of Miscellaneous Symbols
+     */
+    ST_LOCAL static bool isMiscSymbol(stUtf32_t theUChar) {
+        return (theUChar >= 0x02600 && theUChar <= 0x026FF);
+    }
+
+    /**
+    * @return true if specified character is within subset of Arabic characters
+    */
+    ST_LOCAL static bool isArabic(stUtf32_t theUChar) {
+      return (theUChar >= 0x00600 && theUChar <= 0x006FF);
+    }
+
+    /**
+     * @return true if specified character should be displayed in Right-to-Left order.
+     */
+    ST_LOCAL static bool isRightToLeft(stUtf32_t theUChar) {
+        return (theUChar >= 0x00600 && theUChar <= 0x006FF); // Arabic
+    }
+
+    /**
      * Determine Unicode subset for specified character
      */
     ST_LOCAL static Subset subset(const stUtf32_t theUChar) {
@@ -103,6 +136,10 @@
             return Subset_CJK;
         } else if(isKorean(theUChar)) {
             return Subset_Korean;
+        } else if(isArabic(theUChar)) {
+            return Subset_Arabic;
+        } else if(isMiscSymbol(theUChar)) {
+          return Subset_MiscSymbols;
         }
         return Subset_General;
     }
@@ -147,11 +184,15 @@
     /**
      * Load the font from specified path.
      * @param theFontPath path to the font
+     * @param theFaceId   face id within the file (0 by default)
      * @param theStyle    the font style
+     * @param theToSyntItalic synthesize italic style
      * @return true on success
      */
-    ST_CPPEXPORT bool load(const StString&       theFontPath,
-                           const StFTFont::Style theStyle);
+    ST_CPPEXPORT bool load(const StString& theFontPath,
+                           const int theFaceId,
+                           const StFTFont::Style theStyle,
+                           const bool theToSyntItalic = false);
 
     /**
      * Load the font from data array.
@@ -231,7 +272,7 @@
      * Assuming text rendered horizontally.
      */
     ST_CPPEXPORT void addAdvanceX(const stUtf32_t  theUCharNext,
-                                  StVec2<GLfloat>& thePen);
+                                  StVec2<GLfloat>& thePen) const;
 
     /**
      * Compute advance to the next character with kerning applied when applicable
@@ -248,7 +289,7 @@
      * Assuming text rendered vertically.
      */
     ST_CPPEXPORT void addAdvanceY(const stUtf32_t  theUCharNext,
-                                  StVec2<GLfloat>& thePen);
+                                  StVec2<GLfloat>& thePen) const;
 
     /**
      * Compute advance to the next character with kerning applied when applicable
@@ -263,7 +304,7 @@
      * Compute advance to the next character with kerning applied when applicable.
      * Assuming text rendered horizontally.
      */
-    ST_CPPEXPORT float getAdvanceX(const stUtf32_t theUCharNext);
+    ST_CPPEXPORT float getAdvanceX(const stUtf32_t theUCharNext) const;
 
     /**
      * Compute advance to the next character with kerning applied when applicable.
@@ -276,7 +317,7 @@
      * Compute advance to the next character with kerning applied when applicable.
      * Assuming text rendered vertically.
      */
-    ST_CPPEXPORT float getAdvanceY(const stUtf32_t theUCharNext);
+    ST_CPPEXPORT float getAdvanceY(const stUtf32_t theUCharNext) const;
 
     /**
      * Compute advance to the next character with kerning applied when applicable.
@@ -307,6 +348,13 @@
     }
 
     /**
+     * @return font face index
+     */
+    ST_LOCAL int getFaceIndex(const StFTFont::Style theStyle) const {
+        return myFontFaces[theStyle];
+    }
+
+    /**
      * @return active font style
      */
     ST_LOCAL StFTFont::Style getActiveStyle() const {
@@ -332,6 +380,13 @@
         return mySubsets[Subset_Korean];
     }
 
+    /**
+     * @return true if this font contains glyphs of specified subset
+     */
+    ST_LOCAL bool hasSubset(Subset theSubset) const {
+        return mySubsets[theSubset];
+    }
+
         protected:
 
     /**
@@ -339,6 +394,13 @@
      */
     ST_CPPEXPORT bool loadGlyph(const stUtf32_t theUChar);
 
+    /**
+     * Wrapper for FT_Get_Kerning - retrieve kerning values.
+     */
+    ST_CPPEXPORT bool getKerning(FT_Vector&      theKern,
+                                 const stUtf32_t theUCharCurr,
+                                 const stUtf32_t theUCharNext) const;
+
         private:
 
     /**
@@ -354,13 +416,13 @@
     StFTFont::Style       myStyle;               //!< active FT face style
     FT_Face               myFTFaces[StylesNB];   //!< FT face objects
     StString              myFontPaths[StylesNB]; //!< font paths
+    int                   myFontFaces[StylesNB]; //!< font face ids
     bool                  mySubsets[SubsetsNB];
     FT_Int32              myLoadFlags;           //!< default load flags
     unsigned int          myGlyphMaxWidth;       //!< maximum glyph width
     unsigned int          myGlyphMaxHeight;      //!< maximum glyph height
 
     StImagePlane          myGlyphImg;            //!< cached glyph plane
-    FT_Vector             myKernAdvance;         //!< buffer variable
     stUtf32_t             myUChar;               //!< currently loaded unicode character
 
 };

sview-17_04.tar.gz/include/StFT/StFTFontRegistry.h -> sview-20_08.tar.gz/include/StFT/StFTFontRegistry.h Changed

sview-17_04.tar.gz/include/StFile/StFileNode.h -> sview-20_08.tar.gz/include/StFile/StFileNode.h Changed

@@ -1,5 +1,5 @@
 /**
- * Copyright © 2010-2013 Kirill Gavrilov <kirill@sview.ru>
+ * Copyright © 2010-2017 Kirill Gavrilov <kirill@sview.ru>
  *
  * Distributed under the Boost Software License, Version 1.0.
  * See accompanying file license-boost.txt or copy at
@@ -10,10 +10,21 @@
 #define __StFileNode_H__
 
 #include <StFile/StNode.h>
-#include <StFile/StMIME.h>
+#include <StFile/StMIMEList.h>
 #include <StTemplates/StHandle.h>
 
-class StMIMEList;
+/**
+ * Structure defining Open File dialog content.
+ */
+struct StOpenFileName {
+    StString   Folder;            //!< folder to open
+    StString   Title;             //!< dialog title
+    StMIMEList Filter;            //!< main file filter
+    StString   FilterTitle;       //!< main file filter title; "All supported" will be displayed when empty
+    StMIMEList ExtraFilter;       //!< extra file filter (optional)
+    StString   ExtraFilterTitle;  //!< extra file filter title
+};
+
 class StFileNode : public StNode {
 
         private:
@@ -205,6 +216,18 @@
     ST_CPPEXPORT static bool isFileExists(const StCString& thePath);
 
     /**
+     * @param thePath file path
+     * @return true if file/folder has read-only flag
+     */
+    ST_CPPEXPORT static bool isFileReadOnly(const StCString& thePath);
+
+    /**
+     * @param thePath file path
+     * @return true if file attributes have been successfully modified
+     */
+    ST_CPPEXPORT static bool removeReadOnlyFlag(const StCString& thePath);
+
+    /**
      * Tries to remove file from filesystem.
      * @return true on success.
      */
@@ -263,18 +286,14 @@
 
     /**
      * Open native system open file dialog.
-     * @param theFolder      path to open
-     * @param theTitle       dialog title
-     * @param theFilter      files filter
-     * @param theOutFilePath file selected by user
-     * @param toSave         flag this dialog to open or save file
+     * @param theFilePath [in] [out] file selected by user
+     * @param theInfo [in] file open dialog definition
+     * @param theToSave [in] flag this dialog to open or save file
      * @return
      */
-    ST_CPPEXPORT static bool openFileDialog(const StString&   theFolder,
-                                            const StString&   theTitle,
-                                            const StMIMEList& theFilter,
-                                            StString&         theOutFilePath,
-                                            bool              toSave);
+    ST_CPPEXPORT static bool openFileDialog(StString& theFilePath,
+                                            const StOpenFileName& theInfo,
+                                            bool theToSave);
 
     /**
      * Function used where not possible use native Unicode paths.

sview-17_04.tar.gz/include/StFile/StFolder.h -> sview-20_08.tar.gz/include/StFile/StFolder.h Changed

sview-17_04.tar.gz/include/StFile/StMIMEList.h -> sview-20_08.tar.gz/include/StFile/StMIMEList.h Changed

sview-17_04.tar.gz/include/StFile/StNode.h -> sview-20_08.tar.gz/include/StFile/StNode.h Changed

sview-17_04.tar.gz/include/StFile/StRawFile.h -> sview-20_08.tar.gz/include/StFile/StRawFile.h Changed

sview-17_04.tar.gz/include/StGL/StGLContext.h -> sview-20_08.tar.gz/include/StGL/StGLContext.h Changed

@@ -1,5 +1,5 @@
 /**
- * Copyright © 2012-2016 Kirill Gavrilov <kirill@sview.ru>
+ * Copyright © 2012-2019 Kirill Gavrilov <kirill@sview.ru>
  *
  * Distributed under the Boost Software License, Version 1.0.
  * See accompanying file license-boost.txt or copy at
@@ -159,13 +159,15 @@
     StGLArbFbo*     arbFbo;     //!< GL_ARB_framebuffer_object
     bool            arbNPTW;    //!< GL_ARB_texture_non_power_of_two
     bool            arbTexRG;   //!< GL_ARB_texture_rg
+    bool            arbTexFloat;//!< GL_ARB_texture_float (on desktop OpenGL - since 3.0 or as extension GL_ARB_texture_float; on OpenGL ES - since 3.0)
     bool            arbTexClear;//!< GL_ARB_clear_texture
-    bool            hasUnpack;  //!< GL_PACK_ROW_LENGTH / GL_UNPACK_ROW_LENGTH can be used - OpenGL ES 3.0+ or any desktop
     bool            hasHighp;   //!< highp in GLSL ES fragment shader is supported
     bool            hasTexRGBA8;//!< always available on desktop; on OpenGL ES - since 3.0 or as extension GL_OES_rgb8_rgba8
     bool            extTexBGRA8;//!< GL_EXT_texture_format_BGRA8888 for OpenGL ES
+    bool            extTexR16;  //!< GL_EXT_texture_norm16 on OpenGL ES
     StGLFunctions*  extAll;     //!< access to ALL extensions for advanced users
     bool            extSwapTear;//!< WGL_EXT_swap_control_tear/GLX_EXT_swap_control_tear
+    bool            khrFlushControl; //!< GL_KHR_context_flush_control / WGL_ARB_context_flush_control / GLX_ARB_context_flush_control / EGL_KHR_context_flush_control
 
         public:    //! @name class interface
 
@@ -243,12 +245,7 @@
     /**
      * Return capabilities of currently active device.
      */
-    ST_LOCAL StGLDeviceCaps getDeviceCaps() const {
-        StGLDeviceCaps aCaps;
-        aCaps.maxTexDim = myMaxTexDim;
-        aCaps.hasUnpack = hasUnpack;
-        return aCaps;
-    }
+    ST_LOCAL const StGLDeviceCaps& getDeviceCaps() const { return myDevCaps; }
 
     ST_LOCAL GLint getVersionMajor() const {
         return myVerMajor;
@@ -266,7 +263,7 @@
      * @return value for GL_MAX_TEXTURE_SIZE.
      */
     ST_LOCAL GLint getMaxTextureSize() const {
-        return myMaxTexDim;
+        return myDevCaps.maxTexDim;
     }
 
     /**
@@ -410,6 +407,18 @@
                                                 int          theLength,
                                                 const char*  theMessage);
 
+        public:
+
+    /**
+     * Return auxiliary temporary image buffer.
+     */
+    ST_LOCAL StImagePlane& getTmpImagePlane1() { return myTmpPlane1; }
+
+    /**
+     * Return auxiliary temporary image buffer.
+     */
+    ST_LOCAL StImagePlane& getTmpImagePlane2() { return myTmpPlane2; }
+
         public: //! @name auxiliary methods
 
     /**
@@ -443,15 +452,18 @@
     StHandle<StResourceManager>
                             myResMgr;             //!< file resources manager
     StHandle<StMsgQueue>    myMsgQueue;           //!< messages queue
+    StGLDeviceCaps          myDevCaps;            //!< device caps
     GlVendor                myGlVendor;           //!< driver vendor
     GPU_Name                myGpuName;            //!< GPU name
     GLint                   myVerMajor;           //!< cached GL version major number
     GLint                   myVerMinor;           //!< cached GL version minor number
-    GLint                   myMaxTexDim;          //!< maximum texture dimension
     BufferBits              myWindowBits;         //!< default buffer (window) bits
     BufferBits              myFBOBits;            //!< FBO bits
     bool                    myWasInit;            //!< initialization state
 
+    StImagePlane            myTmpPlane1;          //!< auxiliary temporary image buffer
+    StImagePlane            myTmpPlane2;          //!< auxiliary temporary image buffer
+
         protected: //! @name current state
 
     std::stack<StGLBoxPx>   myScissorStack;       //!< cached stack of scissor rectangles

sview-17_04.tar.gz/include/StGL/StGLDeviceCaps.h -> sview-20_08.tar.gz/include/StGL/StGLDeviceCaps.h Changed

@@ -1,5 +1,5 @@
 /**
- * Copyright © 2016 Kirill Gavrilov <kirill@sview.ru>
+ * Copyright © 2016-2019 Kirill Gavrilov <kirill@sview.ru>
  *
  * Distributed under the Boost Software License, Version 1.0.
  * See accompanying file license-boost.txt or copy at
@@ -9,7 +9,7 @@
 #ifndef __StGLDeviceCaps_h_
 #define __StGLDeviceCaps_h_
 
-#include <stTypes.h>
+#include <StImage/StImagePlane.h>
 
 /**
  * Structure defining OpenGL device capabilities
@@ -23,13 +23,32 @@
 
     /**
      * Device support data transferring with row unpack size specified.
+     * GL_PACK_ROW_LENGTH / GL_UNPACK_ROW_LENGTH can be used - OpenGL ES 3.0+ or any desktop.
      */
     bool hasUnpack;
 
     /**
+     * Return TRUE if image format can be uploaded into OpenGL texture.
+     */
+    bool isSupportedFormat(StImagePlane::ImgFormat theFormat) const { return mySupportedFormats[theFormat]; }
+
+    /**
+     * Set if image format can be uploaded into OpenGL texture.
+     */
+    void setSupportedFormat(StImagePlane::ImgFormat theFormat, bool theIsSupported) { mySupportedFormats[theFormat] = theIsSupported; }
+
+    /**
      * Empty constructor.
      */
-    ST_LOCAL StGLDeviceCaps() : maxTexDim(0), hasUnpack(true) {}
+    ST_LOCAL StGLDeviceCaps()
+    : maxTexDim(0), hasUnpack(true) {
+        stMemZero(mySupportedFormats, sizeof(mySupportedFormats));
+    }
+
+        private:
+
+    bool mySupportedFormats[StImagePlane::ImgNB];
+
 };
 
 #endif // __StGLDeviceCaps_h_

sview-17_04.tar.gz/include/StGL/StGLFontEntry.h -> sview-20_08.tar.gz/include/StGL/StGLFontEntry.h Changed

sview-17_04.tar.gz/include/StGL/StGLFunctions.h -> sview-20_08.tar.gz/include/StGL/StGLFunctions.h Changed

@@ -39,6 +39,7 @@
 
 // include main OpenGL header provided with system
 #if defined(__APPLE__)
+    #define GL_SILENCE_DEPRECATION
     #include <OpenGL/gl.h>
 #elif defined(ST_HAVE_GLES2) || defined(__ANDROID__)
     #include <GLES2/gl2.h>
@@ -1462,6 +1463,12 @@
                                                          const int* theAttribs);
     wglCreateContextAttribsARB_t wglCreateContextAttribsARB;
 
+        // WGL_ARB_context_flush_control
+
+    #define WGL_CONTEXT_RELEASE_BEHAVIOR_ARB       0x2097
+    #define WGL_CONTEXT_RELEASE_BEHAVIOR_NONE_ARB  0x0000
+    #define WGL_CONTEXT_RELEASE_BEHAVIOR_FLUSH_ARB 0x2098
+
         // WGL_NV_DX_interop
 
     typedef BOOL   (WINAPI *wglDXSetResourceShareHandleNV_t)(void* theObjectD3d, HANDLE theShareHandle);
@@ -1534,6 +1541,14 @@
     typedef int         (*glXSwapIntervalSGI_t)(int theInterval);
     glXSwapIntervalSGI_t glXSwapIntervalSGI;
 
+        public: //! @name GLX_ARB_context_flush_control
+
+#ifndef GLX_CONTEXT_RELEASE_BEHAVIOR_ARB
+    #define GLX_CONTEXT_RELEASE_BEHAVIOR_ARB       0x2097
+    #define GLX_CONTEXT_RELEASE_BEHAVIOR_NONE_ARB  0x0000
+    #define GLX_CONTEXT_RELEASE_BEHAVIOR_FLUSH_ARB 0x2098
+#endif
+
         // GLX_MESA_query_renderer
 
 #ifndef GLX_RENDERER_VENDOR_ID_MESA

sview-17_04.tar.gz/include/StGL/StGLProgram.h -> sview-20_08.tar.gz/include/StGL/StGLProgram.h Changed

sview-17_04.tar.gz/include/StGL/StGLTextFormatter.h -> sview-20_08.tar.gz/include/StGL/StGLTextFormatter.h Changed

sview-17_04.tar.gz/include/StGL/StGLTexture.h -> sview-20_08.tar.gz/include/StGL/StGLTexture.h Changed

@@ -1,5 +1,5 @@
 /**
- * Copyright © 2009-2015 Kirill Gavrilov <kirill@sview.ru>
+ * Copyright © 2009-2019 Kirill Gavrilov <kirill@sview.ru>
  *
  * Distributed under the Boost Software License, Version 1.0.
  * See accompanying file license-boost.txt or copy at
@@ -11,8 +11,8 @@
 
 #include <StGL/StGLResource.h>
 #include <StStrings/StString.h>
+#include <StImage/StImagePlane.h>
 
-class StImagePlane;
 class StGLContext;
 
 #define GL_TEXTURE0 0x84C0
@@ -32,9 +32,9 @@
      * Currently GL_ALPHA is returned for grayscale image data.
      * @return true if internal format was found.
      */
-    ST_CPPEXPORT static bool getInternalFormat(const StGLContext&  theCtx,
-                                               const StImagePlane& theData,
-                                               GLint&              theInternalFormat);
+    ST_CPPEXPORT static bool getInternalFormat(const StGLContext& theCtx,
+                                               const StImagePlane::ImgFormat theFormat,
+                                               GLint& theInternalFormat);
 
     /**
      * Return true for GL_ALPHA / GL_RED formats.
@@ -165,7 +165,17 @@
      * After this call current texture will be undefined.
      */
     ST_CPPEXPORT void setMinMagFilter(StGLContext& theCtx,
-                                      const GLenum theMinMagFilter);
+                                      const GLenum theMinFilter,
+                                      const GLenum theMagFilter);
+
+    /**
+     * Change Min and Mag filter.
+     * After this call current texture will be undefined.
+     */
+    ST_LOCAL void setMinMagFilter(StGLContext& theCtx,
+                                  const GLenum theMinMagFilter) {
+        setMinMagFilter(theCtx, theMinMagFilter, theMinMagFilter);
+    }
 
     ST_LOCAL bool fill(StGLContext&        theCtx,
                        const StImagePlane& theData) {
@@ -190,7 +200,22 @@
                                 const GLenum        theTarget,
                                 const GLsizei       theRowFrom,
                                 const GLsizei       theRowTo,
-                                const GLsizei       theBatchRows = 128);
+                                const GLsizei       theBatchRows);
+
+    /**
+     * Fill the texture with the image plane.
+     * @param theCtx       current context
+     * @param theData      the image plane to copy data from
+     * @param theTarget    texture target
+     * @param theRowFrom   fill data from row (for both - input image plane and the texture!)
+     * @param theRowTo     fill data up to the row (0 means all rows)
+     * @return true on success
+     */
+    ST_CPPEXPORT bool fillPatch(StGLContext&        theCtx,
+                                const StImagePlane& theData,
+                                const GLenum        theTarget,
+                                const GLsizei       theRowFrom,
+                                const GLsizei       theRowTo);
 
     /**
      * @return GL texture ID.
@@ -222,7 +247,9 @@
     GLint   myTextFormat;  //!< texture format - GL_RGB, GL_RGBA,...
     GLuint  myTextureId;   //!< GL texture ID
     GLenum  myTextureUnit; //!< texture unit
-    GLenum  myTextureFilt; //!< current texture filter
+    GLenum  myFilterMin;   //!< current minify  texture filter (GL_TEXTURE_MIN_FILTER)
+    GLenum  myFilterMag;   //!< current magnify texture filter (GL_TEXTURE_MAG_FILTER)
+    int     myHasMipMaps;  //!< indicates if mip levels have been generated
 
         private:

sview-17_04.tar.gz/include/StGL/StParams.h -> sview-20_08.tar.gz/include/StGL/StParams.h Changed

@@ -1,5 +1,5 @@
 /**
- * Copyright © 2009-2017 Kirill Gavrilov <kirill@sview.ru>
+ * Copyright © 2009-2020 Kirill Gavrilov <kirill@sview.ru>
  *
  * Distributed under the Boost Software License, Version 1.0.
  * See accompanying file license-boost.txt or copy at
@@ -18,10 +18,13 @@
  * Surface to map image onto.
  */
 enum StViewSurface {
-    StViewSurface_Plain,   //!< normal 2D image
-    StViewSurface_Cubemap, //!< cubemap texture
-    StViewSurface_Sphere,  //!< spherical panorama
-    //StViewSurface_Cylinder, //!< cylindrical panorama
+    StViewSurface_Plain,      //!< normal 2D image
+    StViewSurface_Theater,    //!< theater panorama
+    StViewSurface_Cubemap,    //!< cubemap texture
+    StViewSurface_Sphere,     //!< spherical panorama, 360 degrees
+    StViewSurface_Hemisphere, //!< spherical panorama, 180 degrees
+    StViewSurface_Cylinder,   //!< cylindrical panorama
+    StViewSurface_CubemapEAC, //!< equi-angular cubemap
 };
 
 /**
@@ -33,9 +36,13 @@
 
     static StString GET_VIEW_MODE_NAME(StViewSurface theViewMode) {
         switch(theViewMode) {
-            case StViewSurface_Cubemap: return "cubemap";
-            case StViewSurface_Sphere:  return "sphere";
-            case StViewSurface_Plain:   return "flat";
+            case StViewSurface_Cubemap:    return "cubemap";
+            case StViewSurface_CubemapEAC: return "eac";
+            case StViewSurface_Sphere:     return "sphere";
+            case StViewSurface_Hemisphere: return "hemisphere";
+            case StViewSurface_Cylinder:   return "cylinder";
+            case StViewSurface_Theater:    return "theater";
+            case StViewSurface_Plain:      return "flat";
         }
         return "flat";
     }
@@ -43,13 +50,43 @@
     static StViewSurface GET_VIEW_MODE_FROM_STRING(const StString& theViewModeStr) {
         if(theViewModeStr.isStartsWithIgnoreCase(stCString("cubemap"))) {
             return StViewSurface_Cubemap;
+        } else if(theViewModeStr.isStartsWithIgnoreCase(stCString("eac"))) {
+            return StViewSurface_CubemapEAC;
         } else if(theViewModeStr.isStartsWithIgnoreCase(stCString("sphere"))) {
             return StViewSurface_Sphere;
+        } else if(theViewModeStr.isStartsWithIgnoreCase(stCString("hemisphere"))) {
+            return StViewSurface_Hemisphere;
+        } else if(theViewModeStr.isStartsWithIgnoreCase(stCString("cylinder"))) {
+            return StViewSurface_Cylinder;
+        } else if(theViewModeStr.isStartsWithIgnoreCase(stCString("theater"))) {
+            return StViewSurface_Theater;
         } else {
             return StViewSurface_Plain;
         }
     }
 
+    /**
+     * Convert panorama mode into surface view.
+     */
+    static StViewSurface getViewSurfaceForPanoramaSource(StPanorama thePano, bool theToFallbackSphere) {
+        switch(thePano) {
+            case StPanorama_Cubemap6_1:
+            case StPanorama_Cubemap1_6:
+            case StPanorama_Cubemap3_2:
+                return StViewSurface_Cubemap;
+            case StPanorama_Cubemap3_2ytb:
+            case StPanorama_Cubemap2_3ytb:
+              return StViewSurface_CubemapEAC;
+            case StPanorama_Sphere:
+                return StViewSurface_Sphere;
+            case StPanorama_Hemisphere:
+                return StViewSurface_Hemisphere;
+            case StPanorama_OFF:
+                break;
+        }
+        return theToFallbackSphere ? StViewSurface_Sphere : StViewSurface_Plain;
+    }
+
         public:
 
     /**
@@ -272,7 +309,11 @@
     void moveToRight(const float theDuration = 0.02f) {
         switch(ViewingMode) {
             case StViewSurface_Sphere:
+            case StViewSurface_Hemisphere:
+            case StViewSurface_Cylinder:
+            case StViewSurface_Theater:
             case StViewSurface_Cubemap:
+            case StViewSurface_CubemapEAC:
                 myPanYaw += 100.0f * theDuration;
                 break;
             case StViewSurface_Plain:
@@ -284,7 +325,11 @@
     void moveToLeft(const float theDuration = 0.02f) {
         switch(ViewingMode) {
             case StViewSurface_Sphere:
+            case StViewSurface_Hemisphere:
+            case StViewSurface_Cylinder:
+            case StViewSurface_Theater:
             case StViewSurface_Cubemap:
+            case StViewSurface_CubemapEAC:
                 myPanYaw -= 100.0f * theDuration;
                 break;
             case StViewSurface_Plain:
@@ -308,7 +353,11 @@
     void moveToDown(const float theDuration = 0.02f) {
         switch(ViewingMode) {
             case StViewSurface_Sphere:
+            case StViewSurface_Hemisphere:
+            case StViewSurface_Cylinder:
+            case StViewSurface_Theater:
             case StViewSurface_Cubemap:
+            case StViewSurface_CubemapEAC:
                 myPanPitch = clipPitch(myPanPitch - 100.0f * theDuration);
                 break;
             case StViewSurface_Plain:
@@ -320,7 +369,11 @@
     void moveToUp(const float theDuration = 0.02f) {
         switch(ViewingMode) {
             case StViewSurface_Sphere:
+            case StViewSurface_Hemisphere:
+            case StViewSurface_Cylinder:
+            case StViewSurface_Theater:
             case StViewSurface_Cubemap:
+            case StViewSurface_CubemapEAC:
                 myPanPitch = clipPitch(myPanPitch + 100.0f * theDuration);
                 break;
             case StViewSurface_Plain:

sview-17_04.tar.gz/include/StGLMesh/StGLMesh.h -> sview-20_08.tar.gz/include/StGLMesh/StGLMesh.h Changed

sview-20_08.tar.gz/include/StGLMesh/StGLUVCylinder.h Added

@@ -0,0 +1,69 @@
+/**
+ * Copyright © 2019-2020 Kirill Gavrilov <kirill@sview.ru>
+ *
+ * Distributed under the Boost Software License, Version 1.0.
+ * See accompanying file license-boost.txt or copy at
+ * http://www.boost.org/LICENSE_1_0.txt
+ */
+
+#ifndef __StGLUVCylinder_h_
+#define __StGLUVCylinder_h_
+
+#include "StGLMesh.h"
+
+class StBndSphere;
+
+/**
+ * Class represents configurable UV cylinder with computed vertices, normales, texture coordinates.
+ */
+class StGLUVCylinder : public StGLMesh {
+
+        public:
+
+    /**
+     * Defines the UV cylinder mesh with specified parameters.
+     */
+    ST_CPPEXPORT StGLUVCylinder(const StGLVec3& theCenter,
+                                const float theHeight,
+                                const float theRadius,
+                                const int theRings);
+
+    /**
+     * Defines the UV cylinder mesh with specified parameters.
+     */
+    ST_CPPEXPORT StGLUVCylinder(const StGLVec3& theCenter,
+                                const float theHeight,
+                                const float theRadius,
+                                const float theAngleFrom,
+                                const float theAngleTo,
+                                const int theRings);
+
+    ST_CPPEXPORT virtual ~StGLUVCylinder();
+
+    /**
+     * Compute the mesh using current configuration.
+     */
+    ST_CPPEXPORT virtual bool computeMesh() ST_ATTR_OVERRIDE;
+
+    ST_LOCAL float getRadius()    const { return myRadius; }
+    ST_LOCAL void  setRadius(float theRadius) { myRadius = theRadius; }
+    ST_LOCAL float getHeight()    const { return myHeight; }
+    ST_LOCAL void  setHeight(float theHeight) { myHeight = theHeight; }
+    ST_LOCAL float getAngleFrom() const { return myAngleFrom; }
+    ST_LOCAL void  setAngleFrom(float theAngle) { myAngleFrom = theAngle; }
+    ST_LOCAL float getAngleTo()   const { return myAngleTo; }
+    ST_LOCAL void  setAngleTo(float theAngle) { myAngleTo = theAngle; }
+    ST_LOCAL float getAngle()     const { return myAngleTo - myAngleFrom; }
+
+        private:
+
+    StGLVec3 myCenter;
+    float    myRadius;
+    float    myHeight;
+    float    myAngleFrom;
+    float    myAngleTo;
+    int      myNbRings;
+
+};
+
+#endif //__StGLUVCylinder_h_

sview-17_04.tar.gz/include/StGLMesh/StGLUVSphere.h -> sview-20_08.tar.gz/include/StGLMesh/StGLUVSphere.h Changed

sview-17_04.tar.gz/include/StGLStereo/StFormatEnum.h -> sview-20_08.tar.gz/include/StGLStereo/StFormatEnum.h Changed

@@ -1,5 +1,5 @@
 /**
- * Copyright © 2009-2015 Kirill Gavrilov <kirill@sview.ru>
+ * Copyright © 2009-2019 Kirill Gavrilov <kirill@sview.ru>
  *
  * Distributed under the Boost Software License, Version 1.0.
  * See accompanying file license-boost.txt or copy at
@@ -41,14 +41,20 @@
 enum StCubemap {
     StCubemap_AUTO = -1, //!< try to detect from metadata
     StCubemap_OFF  =  0, //!< no cubemap data
-    StCubemap_Packed     //!< cubemap data packed into single image frame - 6 horizontally stacked planes
+    StCubemap_Packed,    //!< cubemap data packed into single image frame - 6 horizontally stacked planes
+    StCubemap_PackedEAC  //!< cubemap data packed into single image frame (EAC layout)
 };
 
 enum StPanorama {
-    StPanorama_OFF  =  0,  //!< no cubemap data
-    StPanorama_Sphere,     //!< spherical panorama
-    StPanorama_Cubemap6_1, //!< cubemap data packed into single image frame - 6:1
-    StPanorama_Cubemap3_2  //!< cubemap data packed into single image frame - 3:2
+    StPanorama_OFF  =  0,     //!< no cubemap data
+    StPanorama_Sphere,        //!< spherical panorama 360 degrees - 2:1
+    StPanorama_Hemisphere,    //!< spherical panorama 180 degrees - 1:1
+    StPanorama_Cubemap6_1,    //!< cubemap data packed into single image frame - 6:1 in OpenGL enum order (px nx py ny pz nz)
+    StPanorama_Cubemap1_6,    //!< cubemap data packed into single image frame - 1:6 in OpenGL enum order
+    StPanorama_Cubemap3_2,    //!< cubemap data packed into single image frame - 3:2 in OpenGL enum order
+    StPanorama_Cubemap3_2ytb, //!< cubemap data packed into single image frame - 3:2 in custom order (px nz nx, ny pz py)
+                              //!  one row defines 3 horizontally stacked sides of the cube, and other 3 vertically stacked sides
+    StPanorama_Cubemap2_3ytb  //!< cubemap data packed into single image frame - 2:3 in custom order (90 counterclockwise transposed 3x2 layout)
 };
 
 namespace st {
@@ -96,8 +102,12 @@
      * - half,q    Anamorph suffix
      * or file extension:
      * - jps,pns   SideBySide (Right/Left order)
+     * @param theFileName  [in] file name to parse
+     * @param theToSwapJps [in] if TRUE, then JPS/PNS file extension will be treated as Left/Right instead of Right/Left
+     * @param theIsAnamorph [out] flag indicating anamorphic aspect ratio
      */
     ST_CPPEXPORT StFormat formatFromName(const StString& theFileName,
+                                         const bool      theToSwapJps,
                                          bool&           theIsAnamorph);
 
     /**
@@ -147,9 +157,15 @@
         } else if(theSrc1SizeX / 6 == theSrc1SizeY
                && theSrc2SizeX / 6 == theSrc2SizeY) {
             return StPanorama_Cubemap6_1;
+        } else if(theSrc1SizeY / 6 == theSrc1SizeX
+               && theSrc2SizeY / 6 == theSrc2SizeX) {
+            return StPanorama_Cubemap1_6;
         } else if(theSrc1SizeX / 3 == theSrc1SizeY / 2
                && theSrc2SizeX / 3 == theSrc2SizeY / 2) {
             return StPanorama_Cubemap3_2;
+        } else if(theSrc1SizeX == theSrc1SizeY
+               && theSrc2SizeX == theSrc2SizeY) {
+            return StPanorama_Hemisphere;
         }
         return StPanorama_OFF;
     }

sview-17_04.tar.gz/include/StGLStereo/StGLProjCamera.h -> sview-20_08.tar.gz/include/StGLStereo/StGLProjCamera.h Changed

@@ -38,6 +38,11 @@
     ST_CPPEXPORT StGLProjCamera();
 
     /**
+     * Copy constructor.
+     */
+    ST_CPPEXPORT StGLProjCamera(const StGLProjCamera& theOther);
+
+    /**
      * Custom projection camera.
      */
     ST_CPPEXPORT StGLProjCamera(const GLfloat theFOVy,
@@ -46,6 +51,19 @@
                                 const GLfloat theZScreen);
 
     /**
+     * Copy camera settings.
+     */
+    ST_CPPEXPORT void copyFrom(const StGLProjCamera& theOther);
+
+    /**
+     * Copy camera settings.
+     */
+    ST_LOCAL StGLProjCamera& operator=(const StGLProjCamera& theOther) {
+        copyFrom(theOther);
+        return *this;
+    }
+
+    /**
      * Get projection type.
      */
     inline bool isPerspective() const {
@@ -103,6 +121,7 @@
      */
     inline void setFOVy(const GLfloat theFOVy) {
         myFOVy = theFOVy;
+        updateFrustum();
     }
 
     /**
@@ -234,6 +253,21 @@
     }
 
     /**
+     * Return TRUE if custom stereoscopic projection frustum has been set.
+     */
+    ST_LOCAL bool isCustomProjection() const { return myIsCustomFrust; }
+
+    /**
+     * Unset custom projection.
+     */
+    ST_CPPEXPORT void resetCustomProjection();
+
+    /**
+     * Setup custom projection.
+     */
+    ST_CPPEXPORT void setCustomProjection(const StRectF_t& theLeft, const StRectF_t& theRight);
+
+    /**
      * Returns the string description for the camera.
      * For debug purposes...
      */
@@ -243,6 +277,11 @@
 
     StGLMatrix  myMatrix;     //!< current projection matrix
     StGLMatrix  myMatrixMono; //!< we store mono projection matrix to allow draw special object
+
+    StRectF_t   myVrFrustumL; //!< custom VR projection frustum, left eye
+    StRectF_t   myVrFrustumR; //!< custom VR projection frustum, right eye
+    bool        myIsCustomFrust;
+
     GLfloat     myFOVy;       //!< field of view in y-axis (degrees)
     GLfloat     myZoom;       //!< linear zoom factor (changes the effective FOVy value!)
     GLfloat     myAspect;     //!< screen aspect ratio, recomputed on window size change

sview-17_04.tar.gz/include/StGLStereo/StGLQuadTexture.h -> sview-20_08.tar.gz/include/StGLStereo/StGLQuadTexture.h Changed

@@ -1,5 +1,5 @@
 /**
- * Copyright © 2009-2013 Kirill Gavrilov <kirill@sview.ru>
+ * Copyright © 2009-2020 Kirill Gavrilov <kirill@sview.ru>
  *
  * Distributed under the Boost Software License, Version 1.0.
  * See accompanying file license-boost.txt or copy at
@@ -27,35 +27,49 @@
     /**
      * @return data size in the texture.
      */
-    inline const StGLVec2& getDataSize() {
-        return myDataSize;
-    }
+    ST_LOCAL const StGLVec2& getDataSize() { return myDataSize; }
 
     /**
-     * @param theDataSize - setted data size in the texture.
+     * @param theDataSize - set data size in the texture.
      */
-    inline void setDataSize(const StGLVec2& theDataSize) {
-        myDataSize = theDataSize;
-    }
+    ST_LOCAL void setDataSize(const StGLVec2& theDataSize) { myDataSize = theDataSize; }
 
     /**
      * @return display aspect ratio.
      */
-    inline GLfloat getDisplayRatio() const {
-        return myDisplayRatio;
-    }
+    ST_LOCAL GLfloat getDisplayRatio() const { return myDisplayRatio; }
 
     /**
      * @param theValue - display aspect ratio.
      */
-    inline void setDisplayRatio(const GLfloat theValue) {
-        myDisplayRatio = theValue;
-    }
+    ST_LOCAL void setDisplayRatio(const GLfloat theValue) { myDisplayRatio = theValue; }
+
+    /**
+     * Returns Pixel Aspect Ratio.
+     */
+    ST_LOCAL GLfloat getPixelRatio() const { return myPAR; }
+
+    /**
+     * Sets Pixel Aspect Ratio.
+     */
+    ST_LOCAL void setPixelRatio(const GLfloat thePAR) { myPAR = thePAR; }
+
+    /**
+     * Returns packed panorama format.
+     */
+    ST_LOCAL StPanorama getPackedPanorama() const { return myPanorama; }
+
+    /**
+     * Sets packed panorama format.
+     */
+    ST_LOCAL void setPackedPanorama(StPanorama thePano) { myPanorama = thePano; }
 
         private:
 
-    StGLVec2 myDataSize;     //!< data size in the texture (x()=right and y()=bottom)
-    GLfloat  myDisplayRatio; //!< display aspect ratio
+    StGLVec2   myDataSize;     //!< data size in the texture (x()=right and y()=bottom)
+    float      myDisplayRatio; //!< display aspect ratio
+    float      myPAR;          //!< pixel aspect ratio
+    StPanorama myPanorama;     //!< packed panorama format
 
 };
 
@@ -161,7 +175,17 @@
      * After this call current bound texture will be undefined.
      */
     ST_CPPEXPORT void setMinMagFilter(StGLContext& theCtx,
-                                      const GLenum theMinMagFilter);
+                                      const GLenum theMinFilter,
+                                      const GLenum theMagFilter);
+
+    /**
+     * Change Min and Mag filter.
+     * After this call current bound texture will be undefined.
+     */
+    ST_LOCAL void setMinMagFilter(StGLContext& theCtx,
+                                  const GLenum theMinMagFilter) {
+        setMinMagFilter(theCtx, theMinMagFilter, theMinMagFilter);
+    }
 
         private:
 
@@ -229,7 +253,17 @@
      * After this call current bound texture will be undefined.
      */
     ST_CPPEXPORT void setMinMagFilter(StGLContext& theCtx,
-                                      const GLenum theMinMagFilter);
+                                      const GLenum theMinFilter,
+                                      const GLenum theMagFilter);
+
+    /**
+     * Change Min and Mag filter.
+     * After this call current bound texture will be undefined.
+     */
+    ST_LOCAL void setMinMagFilter(StGLContext& theCtx,
+                                  const GLenum theMinMagFilter) {
+        setMinMagFilter(theCtx, theMinMagFilter, theMinMagFilter);
+    }
 
         private:

sview-17_04.tar.gz/include/StGLStereo/StGLTextureData.h -> sview-20_08.tar.gz/include/StGLStereo/StGLTextureData.h Changed

@@ -1,5 +1,5 @@
 /**
- * Copyright © 2009-2016 Kirill Gavrilov <kirill@sview.ru>
+ * Copyright © 2009-2020 Kirill Gavrilov <kirill@sview.ru>
  *
  * Distributed under the Boost Software License, Version 1.0.
  * See accompanying file license-boost.txt or copy at
@@ -10,6 +10,7 @@
 #define __StGLTextureData_h_
 
 #include <StImage/StImage.h>
+#include <StGLStereo/StGLTextureUploadParams.h>
 #include <StGLStereo/StGLQuadTexture.h>
 #include <StGL/StGLDeviceCaps.h>
 
@@ -38,7 +39,7 @@
     /**
      * Default constructor
      */
-    ST_CPPEXPORT StGLTextureData();
+    ST_CPPEXPORT StGLTextureData(const StHandle<StGLTextureUploadParams>& theUploadParams);
 
     /**
      * Destructor.
@@ -175,6 +176,10 @@
 
     ST_LOCAL void setupAttributes(StGLFrameTextures& stFrameTextures, const StImage& theImage);
 
+    ST_LOCAL void setupDataRectangle(const StImagePlane& theImagePlane,
+                                     const GLfloat       thePixelRatio,
+                                     StGLFrameTexture&   theTextureFrame);
+
         private:
 
     StGLTextureData*         myPrev;          //!< pointer to previous item in the list
@@ -191,6 +196,7 @@
     StFormat                 mySrcFormat;
     StCubemap                myCubemapFormat;
 
+    StHandle<StGLTextureUploadParams> myUploadParams; //!< texture streaming parameters
     GLsizei                  myFillFromRow;
     GLsizei                  myFillRows;

sview-17_04.tar.gz/include/StGLStereo/StGLTextureQueue.h -> sview-20_08.tar.gz/include/StGLStereo/StGLTextureQueue.h Changed

@@ -42,6 +42,11 @@
     ST_CPPEXPORT ~StGLTextureQueue();
 
     /**
+     * Get device capabilities.
+     */
+    ST_LOCAL const StGLDeviceCaps& getDeviceCaps() const { return myDeviceCaps; }
+
+    /**
      * Set device capabilities.
      */
     ST_LOCAL void setDeviceCaps(const StGLDeviceCaps& theCaps) {
@@ -58,6 +63,11 @@
     }
 
     /**
+     * Return texture streaming parameters.
+     */
+    ST_LOCAL StGLTextureUploadParams& getUploadParams() { return *myUploadParams; }
+
+    /**
      * @return input stream connection state
      */
     ST_LOCAL bool hasConnectedStream() const {
@@ -209,7 +219,8 @@
      * This function clean up only requested number of frames but prevents queue emptying.
      * At least one frame will remain in queue.
      */
-    ST_CPPEXPORT void drop(const size_t theCount);
+    ST_CPPEXPORT void drop(const size_t theCount,
+                           double& thePtsFront);
 
     /**
      * Function used to get current showed source format.
@@ -276,6 +287,7 @@
     volatile bool    myHasStream;      //!< flag indicates that some stream connected to this queue
 
     StGLDeviceCaps   myDeviceCaps;     //!< device capabilities
+    StHandle<StGLTextureUploadParams> myUploadParams; //!< texture streaming parameters
 
 };

sview-20_08.tar.gz/include/StGLStereo/StGLTextureUploadParams.h Added

@@ -0,0 +1,39 @@
+/**
+ * Copyright © 2019 Kirill Gavrilov <kirill@sview.ru>
+ *
+ * Distributed under the Boost Software License, Version 1.0.
+ * See accompanying file license-boost.txt or copy at
+ * http://www.boost.org/LICENSE_1_0.txt
+ */
+
+#ifndef __StGLTextureUploadParams_h_
+#define __StGLTextureUploadParams_h_
+
+/**
+ * Structure holding parameters for texture uploading.
+ * Uploading big amounts of data onto GPU leads to frame-rate lags (specifically in case when uploading done within rendering thread);
+ * to smooth this effect, upload process can be split into smaller chunks.
+ *
+ * There are 4 use cases, which are sensitive to texture uploading lags:
+ * - GUI rendering; will be noticeable only for very large uploads.
+ * - 360 panorama with device orientation tracking; will be noticeable due lag on orientation update.
+ * - HMD output with head orientation tracking; same as panorama, but will be noticeable all time (no option disabling head tracking) and can lead to headaches.
+ * - Software PageFlipping (texture uploading lag might lead to missing VSync and swapping Left/Right frames).
+ *
+ * Most optimal case would be defining amount of chunks equal to amount of frames to be rendered before new (uploaded) texture should appear,
+ * in this case average FPS will be close to constant, which is in particular good to preserve GUI interactive.
+ * At the same time, uploading data within more than 1 rendering frame would add a constant time shift to video stream presented to user,
+ * which ideally should be also considered.
+ * At last, the real maximum rendering FPS naturally limited by monitor frequency, can be not achievable due to slow GPU.
+ */
+struct StGLTextureUploadParams {
+
+    int MaxUploadIterations; //!< maximum number of texture upload iterations (frames); 1 means texture should be uploaded immediately
+    int MaxUploadChunkMiB;   //!< maximum number of data in MiB to be uploaded within single iteration; 0 means no limit;
+                             //!  MaxUploadIterations is stronger limit
+
+    StGLTextureUploadParams() : MaxUploadIterations(1), MaxUploadChunkMiB(0) {}
+
+};
+
+#endif // __StGLTextureUploadParams_h_

sview-17_04.tar.gz/include/StGLWidgets/StGLCombobox.h -> sview-20_08.tar.gz/include/StGLWidgets/StGLCombobox.h Changed

sview-17_04.tar.gz/include/StGLWidgets/StGLImageProgram.h -> sview-20_08.tar.gz/include/StGLWidgets/StGLImageProgram.h Changed

@@ -1,6 +1,6 @@
 /**
  * StGLWidgets, small C++ toolkit for writing GUI using OpenGL.
- * Copyright © 2010-2017 Kirill Gavrilov <kirill@sview.ru>
+ * Copyright © 2010-2019 Kirill Gavrilov <kirill@sview.ru>
  *
  * Distributed under the Boost Software License, Version 1.0.
  * See accompanying file license-boost.txt or copy at
@@ -20,14 +20,15 @@
 /**
  * GLSL program for Image Region widget.
  */
-class StGLImageProgram : public StGLProgramMatrix<1, 5, StGLMeshProgram> {
+class StGLImageProgram : public StGLProgramMatrix<1, 6, StGLMeshProgram> {
 
         public:
 
     typedef enum tagTextureFilter {
-        FILTER_NEAREST, //!< ugly filter
-        FILTER_LINEAR,  //!< linear filter
-        FILTER_BLEND,   //!< blend deinterlace filter
+        FILTER_NEAREST,   //!< ugly filter
+        FILTER_LINEAR,    //!< linear filter
+        FILTER_BLEND,     //!< blend deinterlace filter
+        FILTER_TRILINEAR, //!< trilinear filter (generate mip-maps)
     } TextureFilter;
 
     /**
@@ -43,11 +44,12 @@
      * Color conversion options in GLSL Fragment Shader.
      */
     enum FragSection {
-        FragSection_Main = 0, //!< section with main() function
-        FragSection_GetColor, //!< read color values from textures
-        FragSection_ToRgb,    //!< color conversion
-        FragSection_Correct,  //!< color correction
-        FragSection_Gamma,    //!< gamma correction
+        FragSection_Main = 0,     //!< section with main() function
+        FragSection_GetColor,     //!< read color values from textures
+        FragSection_GetTexCoords, //!< EAC texture coordinates correction
+        FragSection_ToRgb,        //!< color conversion
+        FragSection_Correct,      //!< color correction
+        FragSection_Gamma,        //!< gamma correction
         FragSection_NB
     };
 
@@ -70,11 +72,17 @@
         FragToRgb_FromGray,
         FragToRgb_FromXyz,
         FragToRgb_FromYuvFull,
+        FragToRgb_FromYuvaFull,
         FragToRgb_FromYuvMpeg,
+        FragToRgb_FromYuvaMpeg,
         FragToRgb_FromYuv9Full,
+        FragToRgb_FromYuva9Full,
         FragToRgb_FromYuv9Mpeg,
+        FragToRgb_FromYuva9Mpeg,
         FragToRgb_FromYuv10Full,
+        FragToRgb_FromYuva10Full,
         FragToRgb_FromYuv10Mpeg,
+        FragToRgb_FromYuva10Mpeg,
         FragToRgb_FromYuvNvFull,
         FragToRgb_FromYuvNvMpeg,
         FragToRgb_CUBEMAP,
@@ -99,6 +107,15 @@
         FragGamma_NB
     };
 
+    /**
+     * Texture coordinates EAC correction options in GLSL Fragment Shader.
+     */
+    enum FragTexEAC {
+        FragTexEAC_Off = 0,
+        FragTexEAC_On,
+        FragTexEAC_NB
+    };
+
         public:
 
     ST_CPPEXPORT StGLImageProgram();
@@ -114,6 +131,9 @@
     ST_CPPEXPORT void setTextureUVDataSize(StGLContext&    theCtx,
                                            const StGLVec4& theTexDataVec4);
 
+    ST_CPPEXPORT void setTextureADataSize(StGLContext&    theCtx,
+                                          const StGLVec4& theTexDataVec4);
+
     ST_CPPEXPORT void setCubeTextureFlipZ(StGLContext&    theCtx,
                                           bool theToFlip);
 
@@ -128,10 +148,11 @@
     /**
      * Initialize default shaders, nothing more.
      */
-    ST_CPPEXPORT virtual bool init(StGLContext&                 theCtx,
-                                   const StImage::ImgColorModel theColorModel,
-                                   const StImage::ImgColorScale theColorScale,
-                                   const FragGetColor           theFilter);
+    ST_CPPEXPORT bool init(StGLContext&                 theCtx,
+                           const StImage::ImgColorModel theColorModel,
+                           const StImage::ImgColorScale theColorScale,
+                           const FragGetColor           theFilter,
+                           const FragTexEAC theTexCoord = FragTexEAC_Off);
 
         public: //!< Properties
 
@@ -146,8 +167,10 @@
         private: //!< callback Slots
 
     ST_LOCAL void setupCorrection(StGLContext& theCtx);
-    ST_LOCAL void regToRgb(const int       thePartIndex,
+    ST_LOCAL void regToRgb(const StGLContext& theCtx,
+                           const int       thePartIndex,
                            const StString& theText);
+    ST_LOCAL void registerFragments(const StGLContext& theCtx);
 
         protected:
 
@@ -161,6 +184,7 @@
 
     StGLVarLocation uniTexMainDataLoc;
     StGLVarLocation uniTexUVDataLoc;
+    StGLVarLocation uniTexADataLoc;
     StGLVarLocation uniTexSizePxLoc;
     StGLVarLocation uniTexelSizePxLoc;
     StGLVarLocation uniTexCubeFlipZLoc;
@@ -168,6 +192,7 @@
     StGLVarLocation uniGammaLoc;
 
     StGLVec3        myColorScale; //!< scale filter for de-anaglyph processing
+    bool            myIsRegistered;
 
 };

sview-17_04.tar.gz/include/StGLWidgets/StGLImageRegion.h -> sview-20_08.tar.gz/include/StGLWidgets/StGLImageRegion.h Changed

@@ -1,6 +1,6 @@
 /**
  * StGLWidgets, small C++ toolkit for writing GUI using OpenGL.
- * Copyright © 2010-2016 Kirill Gavrilov <kirill@sview.ru>
+ * Copyright © 2010-2020 Kirill Gavrilov <kirill@sview.ru>
  *
  * Distributed under the Boost Software License, Version 1.0.
  * See accompanying file license-boost.txt or copy at
@@ -10,6 +10,7 @@
 #ifndef __StGLImageRegion_h_
 #define __StGLImageRegion_h_
 
+#include <StGLMesh/StGLUVCylinder.h>
 #include <StGLMesh/StGLUVSphere.h>
 #include <StGLMesh/StGLQuads.h>
 
@@ -18,10 +19,12 @@
 #include <StGLStereo/StGLTextureQueue.h>
 
 #include <StGL/StParams.h>
+#include <StGL/StPlayList.h>
 
+#include <StSlots/StAction.h>
 #include <StSettings/StEnumParam.h>
 
-class StAction;
+class StGLIcon;
 
 class StGLImageRegion : public StGLWidget {
 
@@ -87,6 +90,30 @@
                                  const bool  theUsePanningKeys);
 
     /**
+     * Return playlist.
+     */
+    ST_LOCAL const StHandle<StPlayList>& getPlayList() const {
+        return myList;
+    }
+
+    /**
+     * Set playlist.
+     */
+    ST_LOCAL void setPlayList(const StHandle<StPlayList>& theList) {
+        myList = theList;
+    }
+
+    /**
+     * Return icon widget displayed on swipe gesture.
+     */
+    StGLIcon* changeIconPrev() { return myIconPrev; }
+
+    /**
+     * Return icon widget displayed on swipe gesture.
+     */
+    StGLIcon* changeIconNext() { return myIconNext; }
+
+    /**
      * Setup device orientation.
      */
     ST_LOCAL void setDeviceOrientation(const StGLQuaternion& theQ) { myDeviceQuat = theQ; }
@@ -163,6 +190,16 @@
      */
     ST_CPPEXPORT void stglSkipFrames();
 
+    /**
+     * Return sample aspect ratio.
+     */
+    ST_LOCAL float getSampleRatio() const { return mySampleRatio; }
+
+    /**
+    * Return frame dimensions.
+    */
+    ST_LOCAL const StVec2<int>& getFrameSize() const { return myFrameSize; }
+
         public: //! @name Properties
 
     struct {
@@ -185,6 +222,15 @@
 
     } params;
 
+        public:  //! @name Signals
+
+    struct {
+        /**
+         * Emit new item signal.
+         */
+        StSignal<void (void )> onOpenItem;
+    } signals;
+
         private:
 
     /**
@@ -301,23 +347,40 @@
 
     ST_LOCAL void doRightUnclick(const StPointD_t& theCursorZo);
 
+    ST_LOCAL bool stglInitCube(const StGLVec4& theClampUV = StGLVec4(0.0f, 0.0f, 1.0f, 1.0f),
+                               const StPanorama thePano = StPanorama_OFF);
     ST_LOCAL void stglDrawView(unsigned int theView);
 
         private: //! @name private fields
 
     StArrayList< StHandle<StAction> >
                                myActions;        //!< actions list
+    StHandle<StPlayList>       myList;           //!< handle to playlist
+
+    StGLIcon*                  myIconPrev;       //!< icon displayed on swipe gesture
+    StGLIcon*                  myIconNext;       //!< icon displayed on swipe gesture
 
     StGLQuads                  myQuad;           //!< flat quad
-    StGLUVSphere               myUVSphere;       //!< sphere output helper class
+    StGLMesh                   myCube;           //!< cube for drawing cubemap
+    StGLVec4                   myCubeClamp;      //!< cubemap clamping vector
+    StPanorama                 myCubePano;       //!< cubemap panorama format
+    StGLUVSphere               myUVSphere;       //!< sphere mesh object
+    StGLUVSphere               myHemisphere;     //!< hemisphere mesh object
+    StGLUVCylinder             myCylinder;       //!< cylinder mesh object
+    StGLUVCylinder             myTheater;        //!< theater cylinder mesh object
     StGLProjCamera             myProjCam;        //!< copy of projection camera
     StGLImageProgram           myProgram;        //!< GL program to draw flat image
     StHandle<StGLTextureQueue> myTextureQueue;   //!< shared texture queue
     StPointD_t                 myClickPntZo;     //!< remembered mouse click position
     StTimer                    myClickTimer;     //!< timer to delay dragging action
+    StTimer                    myFadeTimer;      //!< timer for transition to the next file
+    StPointD_t                 myFadeFrom;       //!< fade starting delta
     StGLQuaternion             myDeviceQuat;     //!< device orientation
     StVirtFlags                myKeyFlags;       //!< active key flags
     double                     myDragDelayMs;    //!< dragging delay in milliseconds
+    double                     myDragDelayTmpMs; //!< temporary dragging delay
+    StVec2<int>                myFrameSize;      //!< frame dimensions
+    float                      mySampleRatio;    //!< sample aspect ratio
     float                      myRotAngle;       //!< rotation angle gesture progress
     bool                       myIsClickAborted;
     bool                       myToRightRotate;

sview-17_04.tar.gz/include/StGLWidgets/StGLMenuCheckbox.h -> sview-20_08.tar.gz/include/StGLWidgets/StGLMenuCheckbox.h Changed

sview-17_04.tar.gz/include/StGLWidgets/StGLMessageBox.h -> sview-20_08.tar.gz/include/StGLWidgets/StGLMessageBox.h Changed

sview-17_04.tar.gz/include/StGLWidgets/StGLOpenFile.h -> sview-20_08.tar.gz/include/StGLWidgets/StGLOpenFile.h Changed

@@ -1,6 +1,6 @@
 /**
  * StGLWidgets, small C++ toolkit for writing GUI using OpenGL.
- * Copyright © 2015 Kirill Gavrilov <kirill@sview.ru>
+ * Copyright © 2015-2019 Kirill Gavrilov <kirill@sview.ru>
  *
  * Distributed under the Boost Software License, Version 1.0.
  * See accompanying file license-boost.txt or copy at
@@ -13,9 +13,11 @@
 #include <StGLWidgets/StGLMessageBox.h>
 #include <StGLWidgets/StGLRootWidget.h>
 #include <StFile/StMIMEList.h>
+#include <StSettings/StParam.h>
 
 class StGLMenu;
 class StGLMenuItem;
+class StGLMenuCheckbox;
 
 /**
  * Widget for file system navigation.
@@ -39,10 +41,30 @@
     /**
      * Define file filter.
      */
-    ST_CPPEXPORT void setMimeList(const StMIMEList& theFilter);
+    ST_CPPEXPORT void setMimeList(const StMIMEList& theFilter,
+                                  const StString& theName = "",
+                                  const bool theIsExtra = false);
 
     /**
-     * Open new folder.
+     * Check/uncheck extra files.
+     */
+    ST_LOCAL void setDisplayExtra(bool theToDisplay) {
+        myToShowExtraFilter->setValue(theToDisplay);
+    }
+
+    /**
+    * Add checkbox.
+    */
+    ST_CPPEXPORT StGLMenuCheckbox* addHotCheckbox(const StHandle<StBoolParam>& theParam,
+                                                  const StString& theName);
+
+    /**
+     * Add system drives to folders' list.
+     */
+    ST_CPPEXPORT void addSystemDrives();
+
+    /**
+     * Add item to folders' list.
      */
     ST_CPPEXPORT void addHotItem(const StString& theTarget,
                                  const StString& theName = "");
@@ -76,6 +98,11 @@
     ST_CPPEXPORT void doHotItemClick(const size_t theItemId);
 
     /**
+     * Handle filter check.
+     */
+    ST_CPPEXPORT void doFilterCheck(const bool theIsChecked);
+
+    /**
      * Handle item click event - just remember item id.
      */
     ST_CPPEXPORT void doFileItemClick(const size_t theItemId);
@@ -91,16 +118,27 @@
     ST_CPPEXPORT virtual bool tryUnClick(const StClickEvent& theEvent,
                                          bool&               theIsItemUnclicked) ST_ATTR_OVERRIDE;
 
+    /**
+     * Reset extension list.
+     */
+    ST_CPPEXPORT void initExtensions();
+
         protected: //! @name class fields
 
     StHandle<StGLTextureArray> myTextureFolder;
     StHandle<StGLTextureArray> myTextureFile;
     StGLTextArea*              myCurrentPath;
+    StGLScrollArea*            myHotListContent;
     StGLMenu*                  myHotList;       //!< widget containing the list of predefined libraries
     StGLMenu*                  myList;          //!< widget containing the file list of currently opened folder
+    StGLMenuCheckbox*          myMainFilterCheck;  //!< main  file filter checkbox
+    StGLMenuCheckbox*          myExtraFilterCheck; //!< extra file filter checkbox
+    StHandle<StBoolParam>      myToShowMainFilter;
+    StHandle<StBoolParam>      myToShowExtraFilter;
     StArrayList<StString>      myHotPaths;      //!< array of hot-links
     StHandle<StFolder>         myFolder;        //!< currently opened folder
     StMIMEList                 myFilter;        //!< file filter
+    StMIMEList                 myExtraFilter;   //!< extra file filter
     StArrayList<StString>      myExtensions;    //!< extensions filter
     StString                   myItemToLoad;    //!< new item to open

sview-17_04.tar.gz/include/StGLWidgets/StGLRootWidget.h -> sview-20_08.tar.gz/include/StGLWidgets/StGLRootWidget.h Changed

@@ -1,6 +1,6 @@
 /**
  * StGLWidgets, small C++ toolkit for writing GUI using OpenGL.
- * Copyright © 2009-2017 Kirill Gavrilov <kirill@sview.ru>
+ * Copyright © 2009-2020 Kirill Gavrilov <kirill@sview.ru>
  *
  * Distributed under the Boost Software License, Version 1.0.
  * See accompanying file license-boost.txt or copy at
@@ -410,10 +410,6 @@
         return myScrDispX;
     }
 
-    inline GLfloat getLensDist() const {
-        return myLensDist;
-    }
-
     inline void setLensDist(const GLfloat theLensDist) {
         myLensDist = theLensDist;
     }
@@ -451,8 +447,20 @@
      * @param theRect        Rectangle in window coordinates
      * @param theScissorRect Scissor rectangle for glScissor() call
      */
-    ST_CPPEXPORT void stglScissorRect(const StRectI_t& theRect,
-                                      StGLBoxPx&       theScissorRect) const;
+    ST_LOCAL void stglScissorRect2d(const StRectI_t& theRect,
+                                    StGLBoxPx& theScissorRect) const {
+        stglScissorRectInternal(theRect, true, theScissorRect);
+    }
+
+    /**
+     * Computes scissor rectangle in OpenGL viewport.
+     * @param theRect        Rectangle in window coordinates
+     * @param theScissorRect Scissor rectangle for glScissor() call
+     */
+    ST_LOCAL void stglScissorRect3d(const StRectI_t& theRect,
+                                    StGLBoxPx& theScissorRect) const {
+        stglScissorRectInternal(theRect, false, theScissorRect);
+    }
 
     /**
      * Append widget to destroy list.
@@ -485,6 +493,16 @@
 
     ST_LOCAL void setupTextures();
 
+    /**
+    * Computes scissor rectangle in OpenGL viewport.
+    * @param theRect [in] Rectangle in window coordinates
+    * @param theIs2d [in] 2d/3d flag
+    * @param theScissorRect [out] Scissor rectangle for glScissor() call
+    */
+    ST_CPPEXPORT void stglScissorRectInternal(const StRectI_t& theRect,
+                                              const bool theIs2d,
+                                              StGLBoxPx& theScissorRect) const;
+
         private:
 
     StGLSharePointer**        myShareArray;    //!< resources shared within GL context (commonly used)

sview-17_04.tar.gz/include/StGLWidgets/StGLScrollArea.h -> sview-20_08.tar.gz/include/StGLWidgets/StGLScrollArea.h Changed

sview-17_04.tar.gz/include/StGLWidgets/StGLSubtitles.h -> sview-20_08.tar.gz/include/StGLWidgets/StGLSubtitles.h Changed

@@ -1,6 +1,6 @@
 /**
  * StGLWidgets, small C++ toolkit for writing GUI using OpenGL.
- * Copyright © 2010-2015 Kirill Gavrilov <kirill@sview.ru>
+ * Copyright © 2010-2020 Kirill Gavrilov <kirill@sview.ru>
  *
  * Distributed under the Boost Software License, Version 1.0.
  * See accompanying file license-boost.txt or copy at
@@ -20,6 +20,8 @@
 template<>
 inline void StArray<StHandle <StSubItem> >::sort() {}
 
+class StGLImageRegion;
+
 /**
  * Subtitles widget.
  */
@@ -37,6 +39,7 @@
 
         StString     Text;  //!< active string representation
         StImagePlane Image; //!< active image  representation
+        float        Scale; //!< image scale factor
 
             public:
 
@@ -61,14 +64,17 @@
 
         public:
 
-    ST_CPPEXPORT StGLSubtitles(StGLWidget*                     theParent,
+    /**
+     * Main constructor.
+     */
+    ST_CPPEXPORT StGLSubtitles(StGLImageRegion* theParent,
                                const StHandle<StSubQueue>&     theSubQueue,
                                const StHandle<StInt32Param>&   thePlace,
-                               const StHandle<StFloat32Param>& theTopDY,
-                               const StHandle<StFloat32Param>& theBottomDY,
-                               const StHandle<StFloat32Param>& theFontSize,
-                               const StHandle<StFloat32Param>& theParallax,
-                               const StHandle<StEnumParam>&    theParser);
+                               const StHandle<StFloat32Param>& theFontSize);
+
+    /**
+     * Destructor.
+     */
     ST_CPPEXPORT virtual ~StGLSubtitles();
     ST_CPPEXPORT virtual bool stglInit() ST_ATTR_OVERRIDE;
     ST_CPPEXPORT virtual void stglUpdate(const StPointD_t& thePointZo,
@@ -86,14 +92,22 @@
      */
     ST_CPPEXPORT void setPTS(const double thePTS);
 
+        public: //! @name Properties
+
+    struct {
+
+        StHandle<StInt32Param>     Place;         //!< placement
+        StHandle<StFloat32Param>   TopDY;         //!< displacement
+        StHandle<StFloat32Param>   BottomDY;      //!< displacement
+        StHandle<StFloat32Param>   FontSize;      //!< font size parameter
+        StHandle<StFloat32Param>   Parallax;      //!< text parallax
+        StHandle<StEnumParam>      Parser;        //!< text parser option
+        StHandle<StBoolParamNamed> ToApplyStereo; //!< apply stereoscopic format of video to image subtitles
+
+    } params;
+
         private:
 
-    StHandle<StInt32Param>   myPlace;     //!< placement
-    StHandle<StFloat32Param> myTopDY;     //!< displacement
-    StHandle<StFloat32Param> myBottomDY;  //!< displacement
-    StHandle<StFloat32Param> myFontSize;  //!< font size parameter
-    StHandle<StFloat32Param> myParallax;  //!< text parallax
-    StHandle<StEnumParam>    myParser;    //!< text parser option
     StGLTexture              myTexture;   //!< texture for image-based subtitles
     StGLVertexBuffer         myVertBuf;   //!< vertex buffer for image-based subtitles
     StGLVertexBuffer         myTCrdBuf;   //!< texture coordinates buffer for image-based subtitles

sview-17_04.tar.gz/include/StGLWidgets/StGLTable.h -> sview-20_08.tar.gz/include/StGLWidgets/StGLTable.h Changed

sview-17_04.tar.gz/include/StGLWidgets/StGLTextArea.h -> sview-20_08.tar.gz/include/StGLWidgets/StGLTextArea.h Changed

sview-17_04.tar.gz/include/StGLWidgets/StGLTextBorderProgram.h -> sview-20_08.tar.gz/include/StGLWidgets/StGLTextBorderProgram.h Changed

@@ -1,6 +1,6 @@
 /**
  * StGLWidgets, small C++ toolkit for writing GUI using OpenGL.
- * Copyright © 2009-2015 Kirill Gavrilov <kirill@sview.ru>
+ * Copyright © 2009-2020 Kirill Gavrilov <kirill@sview.ru>
  *
  * Distributed under the Boost Software License, Version 1.0.
  * See accompanying file license-boost.txt or copy at
@@ -46,12 +46,14 @@
                                  const StGLMatrix& theProjMat);
 
     /**
-     * Setup model-view matrix.
-     * @param theCtx      active GL context
-     * @param theModelMat model-view matrix
+     * Setup components of model-view matrix.
+     * @param theCtx   active GL context
+     * @param theDisp  translation vector
+     * @param theScale scale factor
      */
-    ST_CPPEXPORT void setModelMat(StGLContext&      theCtx,
-                                  const StGLMatrix& theModelMat);
+    ST_CPPEXPORT void setDisplacement(StGLContext& theCtx,
+                                      const StGLVec3& theDisp,
+                                      const float theScale);
 
     /**
      * Setup text color.
@@ -71,7 +73,7 @@
         private:
 
     StGLVarLocation myUniformProjMat;  //!< location of uniform variable of projection matrix
-    StGLVarLocation myUniformModelMat; //!< location of uniform variable of model view matrix
+    StGLVarLocation myUniformDispl;    //!< location of uniform variable of displacement vector
     StGLVarLocation myUniformColor;    //!< location of uniform variable of color value
 
 };

sview-17_04.tar.gz/include/StGLWidgets/StGLTextProgram.h -> sview-20_08.tar.gz/include/StGLWidgets/StGLTextProgram.h Changed

@@ -1,6 +1,6 @@
 /**
  * StGLWidgets, small C++ toolkit for writing GUI using OpenGL.
- * Copyright © 2009-2015 Kirill Gavrilov <kirill@sview.ru>
+ * Copyright © 2009-2020 Kirill Gavrilov <kirill@sview.ru>
  *
  * Distributed under the Boost Software License, Version 1.0.
  * See accompanying file license-boost.txt or copy at
@@ -53,12 +53,14 @@
                                  const StGLMatrix& theProjMat);
 
     /**
-     * Setup model-view matrix.
-     * @param theCtx      active GL context
-     * @param theModelMat model-view matrix
+     * Setup components of model-view matrix.
+     * @param theCtx   active GL context
+     * @param theDisp  translation vector
+     * @param theScale scale factor
      */
-    ST_CPPEXPORT void setModelMat(StGLContext&      theCtx,
-                                  const StGLMatrix& theModelMat);
+    ST_CPPEXPORT void setDisplacement(StGLContext& theCtx,
+                                      const StGLVec3& theDisp,
+                                      const float theScale);
 
     /**
      * Setup text color.
@@ -78,7 +80,7 @@
         private:
 
     StGLVarLocation myUniformProjMat;  //!< location of uniform variable of projection matrix
-    StGLVarLocation myUniformModelMat; //!< location of uniform variable of model view matrix
+    StGLVarLocation myUniformDispl;    //!< location of uniform variable of displacement vector
     StGLVarLocation myUniformColor;    //!< location of uniform variable of color value
 
 };

sview-17_04.tar.gz/include/StGLWidgets/StGLWidget.h -> sview-20_08.tar.gz/include/StGLWidgets/StGLWidget.h Changed

sview-17_04.tar.gz/include/StGLWidgets/StSubQueue.h -> sview-20_08.tar.gz/include/StGLWidgets/StSubQueue.h Changed

sview-17_04.tar.gz/include/StImage/StDevILImage.h -> sview-20_08.tar.gz/include/StImage/StDevILImage.h Changed

sview-17_04.tar.gz/include/StImage/StExifDir.h -> sview-20_08.tar.gz/include/StImage/StExifDir.h Changed

sview-17_04.tar.gz/include/StImage/StExifTags.h -> sview-20_08.tar.gz/include/StImage/StExifTags.h Changed

sview-17_04.tar.gz/include/StImage/StFreeImage.h -> sview-20_08.tar.gz/include/StImage/StFreeImage.h Changed

sview-17_04.tar.gz/include/StImage/StImage.h -> sview-20_08.tar.gz/include/StImage/StImage.h Changed

@@ -1,5 +1,5 @@
 /**
- * Copyright © 2010-2015 Kirill Gavrilov <kirill@sview.ru>
+ * Copyright © 2010-2019 Kirill Gavrilov <kirill@sview.ru>
  *
  * Distributed under the Boost Software License, Version 1.0.
  * See accompanying file license-boost.txt or copy at
@@ -54,6 +54,7 @@
         ImgColor_RGBA,    //!< same as RGB but has Alpha channel to perform color blending with background
         ImgColor_GRAY,    //!< just gray scale
         ImgColor_YUV,     //!< luma/brightness (Y) + chrominance (UV color plane) - widely used in cinema
+        ImgColor_YUVA,    //!< luma/brightness (Y) + chrominance (UV color plane) + Alpha
         ImgColor_XYZ,     //!< XYZ
         ImgColor_CMYK,    //!< Cyan, Magenta, Yellow and Black - generally used in printing process
         ImgColor_HSV,     //!< Hue, Saturation, Value (also known as HSB - Hue, Saturation, Brightness)
@@ -75,6 +76,12 @@
     ST_CPPEXPORT static StString formatImgColorModel(ImgColorModel theColorModel);
     ST_LOCAL inline StString formatImgColorModel() const { return formatImgColorModel(myColorModel); }
 
+    /**
+     * Format image pixel format.
+     * @sa stAV::PIX_FMT::getString()
+     */
+    ST_CPPEXPORT const char* formatImgPixelFormat() const;
+
         public: //! @name initializers
 
     /**

sview-17_04.tar.gz/include/StImage/StImageFile.h -> sview-20_08.tar.gz/include/StImage/StImageFile.h Changed

@@ -1,5 +1,5 @@
 /**
- * Copyright © 2011-2015 Kirill Gavrilov <kirill@sview.ru>
+ * Copyright © 2011-2020 Kirill Gavrilov <kirill@sview.ru>
  *
  * Distributed under the Boost Software License, Version 1.0.
  * See accompanying file license-boost.txt or copy at
@@ -44,6 +44,7 @@
         ST_TYPE_HDR, //!< Radiance High Dynamic Range - .hdr extension
         ST_TYPE_WEBP,
         ST_TYPE_WEBPLL,
+        ST_TYPE_DDS,
     } ImageType;
 
     typedef enum tagImageClass {
@@ -51,6 +52,7 @@
         ST_DEVIL,
         ST_FREEIMAGE,
         ST_WEBP,
+        ST_STB,
     } ImageClass;
 
         public:
@@ -72,6 +74,8 @@
     ST_CPPEXPORT static StHandle<StImageFile> create(ImageClass      thePreferred = ST_LIBAV,
                                                      ImageType       theImgType = ST_TYPE_NONE);
 
+        public:
+
     /**
      * Empty constructor.
      */
@@ -107,11 +111,19 @@
         myMetadata = theDict;
     }
 
+    /**
+     * Return stereoscopic format stored in the file or StFormat_AUTO if undefined.
+     */
     ST_LOCAL StFormat getFormat() const {
         return mySrcFormat;
     }
 
     /**
+     * Return panorama format stored in the file or StPanorama_OFF if undefined.
+     */
+    ST_LOCAL StPanorama getPanoramaFormat() const { return mySrcPanorama; }
+
+    /**
      * Returns the number of frames in multi-page image.
      */
     ///virtual size_t getFramesCount() const = 0;
@@ -124,9 +136,9 @@
      * @param theDataSize  size of data in memory
      * @return true on success
      */
-    bool load(const StString& theFilePath,
-              ImageType theImageType = ST_TYPE_NONE,
-              uint8_t* theDataPtr = NULL, int theDataSize = 0) { return loadExtra(theFilePath, theImageType, theDataPtr, theDataSize, false); }
+    ST_CPPEXPORT bool load(const StString& theFilePath,
+                           ImageType theImageType = ST_TYPE_NONE,
+                           uint8_t* theDataPtr = NULL, int theDataSize = 0);
 
     /**
      * This virtual function should be implemented by inheritors.
@@ -161,11 +173,17 @@
                       ImageType       theImageType,
                       StFormat        theSrcFormat) = 0;
 
+    /**
+     * Create new instance of this class.
+     */
+    virtual StHandle<StImageFile> createEmpty() const = 0;
+
         protected:
 
     StDictionary myMetadata;
     StString     myStateDescr;
     StFormat     mySrcFormat;
+    StPanorama   mySrcPanorama;
 
 };

sview-17_04.tar.gz/include/StImage/StImagePlane.h -> sview-20_08.tar.gz/include/StImage/StImagePlane.h Changed

@@ -1,5 +1,5 @@
 /**
- * Copyright © 2010-2016 Kirill Gavrilov <kirill@sview.ru>
+ * Copyright © 2010-2020 Kirill Gavrilov <kirill@sview.ru>
  *
  * Distributed under the Boost Software License, Version 1.0.
  * See accompanying file license-boost.txt or copy at
@@ -23,7 +23,7 @@
     /**
      * This enumeration define packed image plane formats.
      */
-    typedef enum tagFormat {
+    enum ImgFormat {
         ImgUNKNOWN = 0, //!< not supported or unknown format
         ImgGray    = 1, //!< 1 byte  per pixel (1-component plane, could be part of multiple-plane image)
         ImgGray16,      //!< 2 bytes per pixel (1-component plane)
@@ -41,7 +41,8 @@
         ImgRGBAF,       //!< 4 floats (16-bytes) RGBA image plane
         ImgBGRAF,       //!< same as RGBAF but with different components order
         ImgUV,          //!< 2 bytes packed UV image plane
-    } ImgFormat;
+    };
+    enum { ImgNB = ImgUV + 1 };
 
     ST_CPPEXPORT static StString formatImgFormat(ImgFormat theImgFormat);
     inline StString formatImgFormat() const { return formatImgFormat(myImgFormat); }
@@ -259,6 +260,12 @@
                                const bool          theIsCompact);
 
     /**
+     * Initialize as transposed copy.
+     */
+    ST_CPPEXPORT bool initTransposedCopy(const StImagePlane& theCopy,
+                                         const bool theIsClockwise);
+
+    /**
      * Initialize as wrapper (data will not be copied).
      */
     ST_CPPEXPORT bool initWrapper(const StImagePlane& theCopy);

sview-17_04.tar.gz/include/StImage/StJpegParser.h -> sview-20_08.tar.gz/include/StImage/StJpegParser.h Changed

@@ -75,6 +75,11 @@
         ST_CPPEXPORT StString getDateTime() const;
 
         /**
+         * Read 360Mono and 360Stereo EXIF property.
+         */
+        ST_CPPEXPORT bool get360PanoMakerNote(bool& theIsStereo) const;
+
+        /**
          * Reads the parallax information from EXIF (currently - only for Fujifilm MPO).
          * @param theParallax the parallax in per cents
          * @return true if tag found
@@ -171,6 +176,11 @@
     }
 
     /**
+     * @return XMP
+     */
+    ST_LOCAL const StString& getXMP() const { return myXMP; }
+
+    /**
      * @return stereo format stored in file
      */
     ST_LOCAL StFormat getSrcFormat() const {
@@ -178,6 +188,11 @@
     }
 
     /**
+     * Return panorama format.
+     */
+    ST_LOCAL StPanorama getPanorama() const { return myPanorama; }
+
+    /**
      * Parse the structure.
      */
     ST_CPPEXPORT bool parse();
@@ -228,7 +243,9 @@
                                   //!< array of offsets in image data, starting from session lenght (zero offset is invalid)
     StString        myComment;    //!< string stored in COM segment (directly in JPEG, NOT inside EXIF)
     StString        myJpsComment; //!< string stored in JPS segment
+    StString        myXMP;        //!< string stored in XMP segment
     StFormat        myStFormat;   //!< stereo format
+    StPanorama      myPanorama;   //!< panorama format
 
 };

sview-20_08.tar.gz/include/StImage/StStbImage.h Added

@@ -0,0 +1,54 @@
+/**
+ * Copyright © 2019 Kirill Gavrilov <kirill@sview.ru>
+ *
+ * Distributed under the Boost Software License, Version 1.0.
+ * See accompanying file license-boost.txt or copy at
+ * http://www.boost.org/LICENSE_1_0.txt
+ */
+
+#ifndef __StStbImage_h_
+#define __StStbImage_h_
+
+#include "StImageFile.h"
+
+// define StHandle template specialization
+class StStbImage;
+ST_DEFINE_HANDLE(StStbImage, StImageFile);
+
+/**
+ * This class implements image load/save operations using STB library.
+ */
+class StStbImage : public StImageFile {
+
+        public:
+
+    /**
+     * Should be called at application start.
+     */
+    ST_CPPEXPORT static bool init();
+
+        public:
+
+    ST_CPPEXPORT StStbImage();
+    ST_CPPEXPORT virtual ~StStbImage();
+
+    ST_LOCAL virtual StHandle<StImageFile> createEmpty() const ST_ATTR_OVERRIDE { return new StStbImage(); }
+
+    ST_CPPEXPORT virtual void close() ST_ATTR_OVERRIDE;
+    ST_CPPEXPORT virtual bool loadExtra(const StString& theFilePath,
+                                        ImageType       theImageType,
+                                        uint8_t*        theDataPtr,
+                                        int             theDataSize,
+                                        bool            theIsOnlyRGB) ST_ATTR_OVERRIDE;
+    ST_CPPEXPORT virtual bool save(const StString& theFilePath,
+                                   ImageType       theImageType,
+                                   StFormat        theSrcFormat) ST_ATTR_OVERRIDE;
+
+
+        private:
+
+     void* myStbImage;
+
+};
+
+#endif //__StStbImage_h_

sview-17_04.tar.gz/include/StImage/StWebPImage.h -> sview-20_08.tar.gz/include/StImage/StWebPImage.h Changed

sview-20_08.tar.gz/include/StJNI Added

sview-20_08.tar.gz/include/StJNI/StJNIEnv.h Added

@@ -0,0 +1,66 @@
+/**
+ * Copyright © 2019 Kirill Gavrilov <kirill@sview.ru>
+ *
+ * Distributed under the Boost Software License, Version 1.0.
+ * See accompanying file license-boost.txt or copy at
+ * http://www.boost.org/LICENSE_1_0.txt
+ */
+
+#ifndef __StJNIEnv_h__
+#define __StJNIEnv_h__
+
+#include <StStrings/StString.h>
+
+//#include <jni.h>
+
+struct _JNIEnv;
+struct _JavaVM;
+typedef _JNIEnv JNIEnv;
+typedef _JavaVM JavaVM;
+
+/**
+ * The sentry class for attaching the current thread to JavaVM.
+ */
+class StJNIEnv {
+
+        public:
+
+    /**
+     * Main constructor, tries to attach JavaVM to the current thread.
+     */
+    ST_CPPEXPORT StJNIEnv(JavaVM* theJavaVM);
+
+    /**
+     * Destructor, automatically detaches JavaVM from current thread.
+     * Has no effect if JavaVM has been attached to the thread before creating this sentry.
+     */
+    ST_CPPEXPORT ~StJNIEnv();
+
+    /**
+     * Detach from current thread right now.
+     * Has no effect if JavaVM has been attached to the thread before creating this sentry.
+     */
+    ST_CPPEXPORT void detach();
+
+    /**
+     * Cast to actual JNIEnv instance.
+     */
+    ST_LOCAL JNIEnv* operator->() const {
+        return myJniEnv;
+    }
+
+    /**
+     * Return true if JNI environment is NULL.
+     */
+    ST_LOCAL bool isNull() const { return myJniEnv == NULL; }
+
+        private:
+
+    JavaVM* myJavaVM;   //!< pointer to global Java VM instance
+    JNIEnv* myJniEnv;   //!< JNI environment for working thread
+    size_t  myThreadId; //!< attached thread id
+    bool    myToDetach; //!< flag to detach
+
+};
+
+#endif //__StJNIEnv_h__

sview-17_04.tar.gz/include/StSettings/StFloat32Param.h -> sview-20_08.tar.gz/include/StSettings/StFloat32Param.h Changed

@@ -1,5 +1,5 @@
 /**
- * Copyright © 2011-2016 Kirill Gavrilov
+ * Copyright © 2011-2017 Kirill Gavrilov
  *
  * Distributed under the Boost Software License, Version 1.0.
  * See accompanying file license-boost.txt or copy at
@@ -93,6 +93,20 @@
     }
 
     /**
+     * @return parameter format
+     */
+    ST_LOCAL const StString& getFormat() const {
+        return myParamFormat;
+    }
+
+    /**
+     * Set new parameter format.
+     */
+    ST_LOCAL void setFormat(const StString& theFormat) {
+        myParamFormat = theFormat;
+    }
+
+    /**
      * Return true if parameter defines minimum value limit.
      */
     ST_LOCAL bool hasMinValue() const {
@@ -330,7 +344,12 @@
 
     StString myParamKey;    //!< parameter key (id)
     StString myParamName;   //!< parameter name (label)
+    StString myParamFormat; //!< parameter format
 
 };
 
+// define StHandle template specialization
+ST_DEFINE_HANDLE(StParam<float>, StParamBase);
+ST_DEFINE_HANDLE(StFloat32Param, StParam<float>);
+
 #endif // __StFloat32Param_h_

sview-17_04.tar.gz/include/StSlots/StAction.h -> sview-20_08.tar.gz/include/StSlots/StAction.h Changed

@@ -1,5 +1,5 @@
 /**
- * Copyright © 2013 Kirill Gavrilov <kirill@sview.ru>
+ * Copyright © 2013-2017 Kirill Gavrilov <kirill@sview.ru>
  *
  * Distributed under the Boost Software License, Version 1.0.
  * See accompanying file license-boost.txt or copy at
@@ -39,75 +39,75 @@
     virtual void doTrigger(const StEvent* theEvent) = 0;
 
     /**
-     * @return hot key 1 to trigger action
+     * @return hot key to trigger action
      */
-    ST_LOCAL unsigned int getHotKey1() const {
-        return myHotKey1;
+    ST_LOCAL unsigned int getHotKey(int theIndex) const {
+        ST_DEBUG_ASSERT(theIndex >= 0 && theIndex <= 1)
+        return myHotKeys[theIndex];
     }
 
     /**
      * @return hot key 1 to trigger action
      */
-    ST_LOCAL unsigned int& changeHotKey1() {
-        return myHotKey1;
+    ST_LOCAL unsigned int getHotKey1() const { return myHotKeys[0]; }
+
+    /**
+     * @return hot key 1 to trigger action
+     */
+    ST_LOCAL unsigned int& changeHotKey1() { return myHotKeys[0]; }
+
+    /**
+     * @param theKey hot key to trigger action
+     */
+    ST_LOCAL void setHotKey(int theIndex, unsigned int theKey) {
+        ST_DEBUG_ASSERT(theIndex >= 0 && theIndex <= 1)
+        myHotKeys[theIndex] = theKey;
     }
 
     /**
      * @param theKey hot key 1 to trigger action
      */
-    ST_LOCAL void setHotKey1(unsigned int theKey) {
-        myHotKey1 = theKey;
-    }
+    ST_LOCAL void setHotKey1(unsigned int theKey) { myHotKeys[0] = theKey; }
 
     /**
      * Default value of hot key 1.
      */
-    ST_LOCAL unsigned int getDefaultHotKey1() const {
-        return myDefaultHotKey1;
-    }
+    ST_LOCAL unsigned int getDefaultHotKey1() const { return myHotKeysDef[0]; }
 
     /**
      * @param theKey default value of hot key 1
      */
     ST_LOCAL void setDefaultHotKey1(unsigned int theKey) {
-        myDefaultHotKey1 = theKey;
-        myHotKey1        = theKey;
+        myHotKeysDef[0] = theKey;
+        myHotKeys[0]    = theKey;
     }
 
     /**
      * @return hot key 2 to trigger action
      */
-    ST_LOCAL unsigned int getHotKey2() const {
-        return myHotKey2;
-    }
+    ST_LOCAL unsigned int getHotKey2() const { return myHotKeys[1]; }
 
     /**
      * @return hot key 2 to trigger action
      */
-    ST_LOCAL unsigned int& changeHotKey2() {
-        return myHotKey2;
-    }
+    ST_LOCAL unsigned int& changeHotKey2() { return myHotKeys[1]; }
 
     /**
      * @param theKey hot key 2 to trigger action
      */
-    ST_LOCAL void setHotKey2(unsigned int theKey) {
-        myHotKey2 = theKey;
-    }
+    ST_LOCAL void setHotKey2(unsigned int theKey) { myHotKeys[1] = theKey; }
 
     /**
      * Default value of hot key 2.
      */
-    ST_LOCAL unsigned int getDefaultHotKey2() const {
-        return myDefaultHotKey2;
-    }
+    ST_LOCAL unsigned int getDefaultHotKey2() const { return myHotKeysDef[1]; }
 
     /**
      * @param theKey default value of hot key 2
      */
     ST_LOCAL void setDefaultHotKey2(unsigned int theKey) {
-        myDefaultHotKey2 = theKey;
-        myHotKey2        = theKey;
+        myHotKeysDef[1] = theKey;
+        myHotKeys[1]    = theKey;
     }
 
     /**
@@ -133,12 +133,10 @@
 
         protected:
 
-    StString     myName;           //!< action name
-    unsigned int myHotKey1;        //!< key combination to execute action
-    unsigned int myHotKey2;        //!< key combination to execute action (extra)
-    unsigned int myDefaultHotKey1; //!< default value of hot-key1
-    unsigned int myDefaultHotKey2; //!< default value of hot-key2
-    bool         myToHoldKey;      //!< this action process key hold event
+    StString     myName;          //!< action name
+    unsigned int myHotKeys[2];    //!< key combination to execute action
+    unsigned int myHotKeysDef[2]; //!< default value of hot-key1
+    bool         myToHoldKey;     //!< this action process key hold event
 
 };

sview-17_04.tar.gz/include/StStrings/StStringStream.h -> sview-20_08.tar.gz/include/StStrings/StStringStream.h Changed

sview-17_04.tar.gz/include/StStrings/StStringUnicode.h -> sview-20_08.tar.gz/include/StStrings/StStringUnicode.h Changed

sview-17_04.tar.gz/include/StStrings/StStringUnicode.inl -> sview-20_08.tar.gz/include/StStrings/StStringUnicode.inl Changed

@@ -181,14 +181,7 @@
     this->Size   = 0;
     this->Length = 0;
     char aBuff[32];
-#if defined(_MSC_VER)
-    stsprintf(aBuff, 32, "%I64i", theInt64);
-#elif (defined(_WIN64) || defined(__WIN64__)\
-   ||  defined(_LP64)  || defined(__LP64__))
-    stsprintf(aBuff, 32, "%li",   theInt64);
-#else
-    stsprintf(aBuff, 32, "%lli",  theInt64);
-#endif
+    stsprintf(aBuff, 32, "%" PRId64, theInt64);
     fromUnicode(aBuff);
 }
 
@@ -198,14 +191,7 @@
     this->Size   = 0;
     this->Length = 0;
     char aBuff[32];
-#if defined(_MSC_VER)
-    stsprintf(aBuff, 32, "%I64u", theUInt64);
-#elif (defined(_WIN64) || defined(__WIN64__)\
-   ||  defined(_LP64)  || defined(__LP64__))
-    stsprintf(aBuff, 32, "%lu",   theUInt64);
-#else
-    stsprintf(aBuff, 32, "%llu",  theUInt64);
-#endif
+    stsprintf(aBuff, 32, "%" PRIu64, theUInt64);
     fromUnicode(aBuff);
 }
 
@@ -216,14 +202,7 @@
     this->Size   = 0;
     this->Length = 0;
     char aBuff[32];
-#if defined(_MSC_VER)
-    stsprintf(aBuff, 32, "%I64i", theInt64);
-#elif (defined(_WIN64) || defined(__WIN64__)\
-   ||  defined(_LP64)  || defined(__LP64__))
-    stsprintf(aBuff, 32, "%li",   theInt64);
-#else
-    stsprintf(aBuff, 32, "%lli",  theInt64);
-#endif
+    stsprintf(aBuff, 32, "%" PRId64,  (int64_t )theInt64);
     fromUnicode(aBuff);
 }
 
@@ -233,14 +212,7 @@
     this->Size   = 0;
     this->Length = 0;
     char aBuff[32];
-#if defined(_MSC_VER)
-    stsprintf(aBuff, 32, "%I64u", theUInt64);
-#elif (defined(_WIN64) || defined(__WIN64__)\
-   ||  defined(_LP64)  || defined(__LP64__))
-    stsprintf(aBuff, 32, "%lu",   theUInt64);
-#else
-    stsprintf(aBuff, 32, "%llu",  theUInt64);
-#endif
+    stsprintf(aBuff, 32, "%" PRIu64, (uint64_t )theUInt64);
     fromUnicode(aBuff);
 }
 #endif
@@ -713,9 +685,13 @@
 template<typename Type> inline
 StStringUnicode<Type> StStringUnicode<Type>::replace(const StStringUnicode<Type>& theSubString,
                                                      const StStringUnicode<Type>& theReplacer) const {
-    if(theSubString.isEmpty() || this->isEmpty() || theSubString.Size >= this->Size) {
+    if(theSubString.isEmpty() || this->isEmpty() || theSubString.Size > this->Size) {
         // just make a copy
         return *this;
+    } else if(theSubString.Size == this->Size) {
+        if(theSubString.isEquals(*this)) {
+            return theReplacer;
+        }
     }
     StUtfIterator<Type> anIter(this->String);
     StStringUnicode<Type> aResult;
@@ -761,6 +737,23 @@
 }
 
 template<typename Type> inline
+void StStringUnicode<Type>::leftAdjust() {
+    if(this->Length == 0) {
+        return;
+    }
+    for(size_t anIter = 0; anIter < this->Size / sizeof(Type); ++anIter) {
+      if(this->String[anIter] != (Type )' '
+      && this->String[anIter] != (Type )'\t') {
+          if(anIter != 0) {
+              StStringUnicode<Type> aCopy(&this->String[anIter]);
+              *this = aCopy;
+          }
+          return;
+      }
+    }
+}
+
+template<typename Type> inline
 void StStringUnicode<Type>::rightAdjust() {
     if(this->Length == 0) {
         return;

sview-17_04.tar.gz/include/StStrings/StUtfIterator.h -> sview-20_08.tar.gz/include/StStrings/StUtfIterator.h Changed

sview-17_04.tar.gz/include/StTemplates/StRect.h -> sview-20_08.tar.gz/include/StTemplates/StRect.h Changed

sview-17_04.tar.gz/include/StTemplates/StTemplates.h -> sview-20_08.tar.gz/include/StTemplates/StTemplates.h Changed

sview-17_04.tar.gz/include/StTemplates/StVec2.h -> sview-20_08.tar.gz/include/StTemplates/StVec2.h Changed

@@ -234,6 +234,43 @@
                       v[1] / theInvFactor);
     }
 
+    /**
+     * Return component-wise minimum of two vectors.
+     */
+    StVec2 cwiseMin(const StVec2& theVec) const {
+        return StVec2(v[0] < theVec.v[0] ? v[0] : theVec.v[0],
+                      v[1] < theVec.v[1] ? v[1] : theVec.v[1]);
+    }
+
+    /**
+     * Return component-wise maximum of two vectors.
+     */
+    StVec2 cwiseMax(const StVec2& theVec) const {
+        return StVec2(v[0] > theVec.v[0] ? v[0] : theVec.v[0],
+                      v[1] > theVec.v[1] ? v[1] : theVec.v[1]);
+    }
+
+    /**
+     * Compute component-wise modulus of the vector.
+     */
+    StVec2 cwiseAbs() const {
+        return StVec2(std::abs(v[0]), std::abs(v[1]));
+    }
+
+    /**
+     * Compute maximum component of the vector.
+     */
+    Element_t maxComp() const {
+        return v[0] > v[1] ? v[0] : v[1];
+    }
+
+    /**
+     * Compute minimum component of the vector.
+     */
+    Element_t minComp() const {
+        return v[0] < v[1] ? v[0] : v[1];
+    }
+
 };
 
 // help structures

sview-17_04.tar.gz/include/StTemplates/StVec3.h -> sview-20_08.tar.gz/include/StTemplates/StVec3.h Changed

@@ -306,6 +306,47 @@
     }
 
     /**
+     * Return component-wise minimum of two vectors.
+     */
+    StVec3 cwiseMin(const StVec3& theVec) const {
+        return StVec3(v[0] < theVec.v[0] ? v[0] : theVec.v[0],
+                      v[1] < theVec.v[1] ? v[1] : theVec.v[1],
+                      v[2] < theVec.v[2] ? v[2] : theVec.v[2]);
+    }
+
+    /**
+     * Return component-wise maximum of two vectors.
+     */
+    StVec3 cwiseMax(const StVec3& theVec) const {
+        return StVec3(v[0] > theVec.v[0] ? v[0] : theVec.v[0],
+                      v[1] > theVec.v[1] ? v[1] : theVec.v[1],
+                      v[2] > theVec.v[2] ? v[2] : theVec.v[2]);
+    }
+
+    /**
+     * Return component-wise modulus of the vector.
+     */
+    StVec3 cwiseAbs() const {
+        return StVec3(std::abs (v[0]), std::abs (v[1]), std::abs (v[2]));
+    }
+
+    /**
+     * Return maximum component of the vector.
+     */
+    Element_t maxComp() const {
+        return v[0] > v[1] ? (v[0] > v[2] ? v[0] : v[2])
+                           : (v[1] > v[2] ? v[1] : v[2]);
+    }
+
+    /**
+     * Return minimum component of the vector.
+     */
+    Element_t minComp() const {
+        return v[0] < v[1] ? (v[0] < v[2] ? v[0] : v[2])
+                           : (v[1] < v[2] ? v[1] : v[2]);
+    }
+
+    /**
      * Compute linear interpolation between to vectors.
      * @param theT (const Element_t ) - interpolation coefficient 0..1;
      * @return interpolation result.

sview-17_04.tar.gz/include/StTemplates/StVec4.h -> sview-20_08.tar.gz/include/StTemplates/StVec4.h Changed

@@ -290,6 +290,51 @@
         return StString('(') + x() + "; " + y() + "; " + z() + "; " + w() + ')';
     }
 
+    /**
+     * Return component-wise minimum of two vectors.
+     */
+    StVec4 cwiseMin(const StVec4& theVec) const {
+        return StVec4(v[0] < theVec.v[0] ? v[0] : theVec.v[0],
+                      v[1] < theVec.v[1] ? v[1] : theVec.v[1],
+                      v[2] < theVec.v[2] ? v[2] : theVec.v[2],
+                      v[3] < theVec.v[3] ? v[3] : theVec.v[3]);
+    }
+
+    /**
+     * Return component-wise maximum of two vectors.
+     */
+    StVec4 cwiseMax(const StVec4& theVec) const {
+        return StVec4(v[0] > theVec.v[0] ? v[0] : theVec.v[0],
+                      v[1] > theVec.v[1] ? v[1] : theVec.v[1],
+                      v[2] > theVec.v[2] ? v[2] : theVec.v[2],
+                      v[3] > theVec.v[3] ? v[3] : theVec.v[3]);
+    }
+
+    /**
+     * Return component-wise modulus of the vector.
+     */
+    StVec4 cwiseAbs() const {
+        return StVec4(std::abs (v[0]), std::abs (v[1]), std::abs (v[2]), std::abs (v[3]));
+    }
+
+    /**
+     * Return maximum component of the vector.
+     */
+    Element_t maxComp() const {
+        const Element_t aMax1 = v[0] > v[1] ? v[0] : v[1];
+        const Element_t aMax2 = v[2] > v[3] ? v[2] : v[3];
+        return aMax1 > aMax2 ? aMax1 : aMax2;
+    }
+
+    /**
+     * Return minimum component of the vector.
+     */
+    Element_t minComp() const {
+        const Element_t aMin1 = v[0] < v[1] ? v[0] : v[1];
+        const Element_t aMin2 = v[2] < v[3] ? v[2] : v[3];
+        return aMin1 < aMin2 ? aMin1 : aMin2;
+    }
+
 };
 
 /**

sview-17_04.tar.gz/include/StThreads/StResourceManager.h -> sview-20_08.tar.gz/include/StThreads/StResourceManager.h Changed

sview-17_04.tar.gz/include/StThreads/StThread.h -> sview-20_08.tar.gz/include/StThreads/StThread.h Changed

sview-17_04.tar.gz/include/StThreads/StTimer.h -> sview-20_08.tar.gz/include/StThreads/StTimer.h Changed

sview-17_04.tar.gz/include/stTypes.h -> sview-20_08.tar.gz/include/stTypes.h Changed

@@ -1,5 +1,5 @@
 /**
- * Copyright © 2009-2014 Kirill Gavrilov <kirill@sview.ru>
+ * Copyright © 2009-2017 Kirill Gavrilov <kirill@sview.ru>
  *
  * Distributed under the Boost Software License, Version 1.0.
  * See accompanying file license-boost.txt or copy at
@@ -47,14 +47,31 @@
     #define ST_ATTR_DEPRECATED
 #endif
 
+// Disable deprecation warnings.
+#if defined(__ICL) || defined (__INTEL_COMPILER)
+    #define ST_DISABLE_DEPRECATION_WARNINGS __pragma(warning(push)) __pragma(warning(disable:1478))
+    #define ST_ENABLE_DEPRECATION_WARNINGS  __pragma(warning(pop))
+#elif defined(_MSC_VER)
+    #define ST_DISABLE_DEPRECATION_WARNINGS __pragma(warning(push)) __pragma(warning(disable:4996))
+    #define ST_ENABLE_DEPRECATION_WARNINGS  __pragma(warning(pop))
+#elif (defined(__GNUC__) && __GNUC__ > 4 || (__GNUC__ == 4 && __GNUC_MINOR__ >= 6)) || defined(__clang__)
+    // available since at least gcc 4.2 (maybe earlier), however only gcc 4.6+ supports this pragma inside the function body
+    // CLang also supports this gcc syntax (in addition to "clang diagnostic ignored")
+    #define ST_DISABLE_DEPRECATION_WARNINGS _Pragma("GCC diagnostic ignored \"-Wdeprecated-declarations\"")
+    #define ST_ENABLE_DEPRECATION_WARNINGS  _Pragma("GCC diagnostic warning \"-Wdeprecated-declarations\"")
+#else
+    #define ST_DISABLE_DEPRECATION_WARNINGS
+    #define ST_ENABLE_DEPRECATION_WARNINGS
+#endif
+
 #if defined(__cplusplus) && (__cplusplus >= 201100L)
-  // part of C++11 standard
-  #define ST_ATTR_OVERRIDE override
+    // part of C++11 standard
+    #define ST_ATTR_OVERRIDE override
 #elif defined(_MSC_VER) && (_MSC_VER >= 1700)
-  // versions before VS2012 emits warning as MSVC-specific extension
-  #define ST_ATTR_OVERRIDE override
+    // versions before VS2012 emits warning as MSVC-specific extension
+    #define ST_ATTR_OVERRIDE override
 #else
-  #define ST_ATTR_OVERRIDE
+    #define ST_ATTR_OVERRIDE
 #endif
 
 #if defined(_MSC_VER)
@@ -67,6 +84,32 @@
 #include <cstddef>     // size_t, NULL
 #include <cstdlib>
 #include <cstring>     // for memcpy
+
+#if(defined(_MSC_VER) && (_MSC_VER < 1800))
+    // only Visual Studio 2013+ (vc12) provides <cinttypes> header
+    #define PRId64 "I64d"
+    #define PRIu64 "I64u"
+    #define SCNd64 "I64d"
+    #define SCNu64 "I64u"
+    #ifdef _WIN64
+        #define PRIdPTR "I64d"
+        #define PRIuPTR "I64u"
+        #define SCNdPTR "I64d"
+        #define SCNuPTR "I64u"
+    #else
+        #define PRIdPTR "d"
+        #define PRIuPTR "u"
+        #define SCNdPTR "d"
+        #define SCNuPTR "u"
+    #endif
+#else
+    // use <inttypes.h< (C99) instead of <cinttypes> (C++11) for compatibility
+    #ifndef __STDC_FORMAT_MACROS
+        #define __STDC_FORMAT_MACROS
+    #endif
+    #include <inttypes.h>
+#endif
+
 #if defined(__i386) || defined(__x86_64) || defined(_M_IX86) || defined(_M_X64) || defined(_M_AMD64)
     #include <xmmintrin.h> // for memory alignment
 #endif
@@ -355,10 +398,16 @@
                                const size_t& theAlign = ST_ALIGNMENT) {
 #if defined(_MSC_VER)
     return _aligned_malloc(theNbBytes, theAlign);
-#elif defined(__ANDROID__)
+#elif defined(__ANDROID__) || defined(__QNX__)
     return memalign(theAlign, theNbBytes);
-#else
+#elif (defined(__GNUC__) && __GNUC__ >= 4 && __GNUC_MINOR__ >= 1 && (defined(__i386) || defined(__x86_64)))
     return _mm_malloc(theNbBytes, theAlign);
+#else
+    void* aPtr;
+    if(posix_memalign(&aPtr, theAlign, theNbBytes)) {
+        return NULL;
+    }
+    return aPtr;
 #endif
 }
 
@@ -374,16 +423,6 @@
     return aPtr;
 }
 
-inline void* stMemReallocAligned(void* thePtrAligned, const size_t& theNbBytes,
-                                 const size_t& theAlign = ST_ALIGNMENT) {
-#if defined(_MSC_VER)
-    return _aligned_realloc(thePtrAligned, theNbBytes, theAlign);
-#else
-    /// TODO (Kirill Gavrilov#4) what should we call here???
-    return realloc(thePtrAligned, theNbBytes);
-#endif
-}
-
 /**
  * Deallocate space in memory.
  * @param ptr (void* ) - pointer to a memory block previously allocated with stMemAllocAligned() to be deallocated.
@@ -391,10 +430,12 @@
 inline void stMemFreeAligned(void* thePtrAligned) {
 #if defined(_MSC_VER)
     _aligned_free(thePtrAligned);
-#elif defined(__ANDROID__)
+#elif defined(__ANDROID__) || defined(__QNX__)
     free(thePtrAligned);
-#else
+#elif (defined(__GNUC__) && __GNUC__ >= 4 && __GNUC_MINOR__ >= 1 && (defined(__i386) || defined(__x86_64)))
     _mm_free(thePtrAligned);
+#else
+    free(thePtrAligned);
 #endif
 }

sview-17_04.tar.gz/include/stconfig.conf -> sview-20_08.tar.gz/include/stconfig.conf Changed

sview-17_04.tar.gz/sview/AndroidManifest.xml -> sview-20_08.tar.gz/sview/AndroidManifest.xml Changed

@@ -1,18 +1,25 @@
 <?xml version="1.0" encoding="utf-8"?>
 <manifest xmlns:android="http://schemas.android.com/apk/res/android"
           package="com.sview"
-          android:versionCode="16"
-          android:versionName="16.12"
+          android:versionCode="44"
+          android:versionName="20.01"
           android:installLocation="auto">
     <application android:label="@string/app_name"
                  android:hasCode="true"
                  android:icon="@drawable/ic_launcher">
         <uses-library android:name="com.s3dv.s3dvsurface" android:required="false" />
+
+        
+        <service android:name="com.sview.StMovieService"
+                 android:exported="false"
+                 android:description="@string/app_movie_service_desc" />
+
         
         <activity android:name="com.sview.StMovieActivity"
                   android:label="@string/app_movie_name"
                   android:launchMode="singleTask"
                   android:alwaysRetainTaskState="true"
+                  android:resizeableActivity="true"
                   android:configChanges="orientation|keyboardHidden|screenSize"
                   android:theme="@android:style/Theme.NoTitleBar.Fullscreen">
                   
@@ -171,6 +178,7 @@
         <activity android:name="com.sview.StImageActivity"
                   android:label="@string/app_image_name"
                   android:launchMode="singleTask"
+                  android:resizeableActivity="true"
                   android:configChanges="orientation|keyboardHidden|screenSize"
                   android:theme="@android:style/Theme.NoTitleBar.Fullscreen">
                   
@@ -227,8 +235,10 @@
         <activity android:name="com.sview.CrashReportActivity" android:label="@string/app_crash_name" android:configChanges="orientation|keyboardHidden"><intent-filter><action android:name="android.intent.action.MAIN" /><category android:name="android.intent.category.DEFAULT" /></intent-filter></activity>
     </application>
 
-    <uses-sdk android:minSdkVersion="15" />
+    <uses-sdk android:minSdkVersion="15" android:targetSdkVersion="28" />
     <uses-feature android:glEsVersion="0x00020000"/>
     <uses-permission android:name="android.permission.INTERNET" />
     <uses-permission android:name="android.permission.WRITE_EXTERNAL_STORAGE" />
+    <uses-permission android:name="android.permission.WAKE_LOCK" />
+    <uses-permission android:name="android.permission.FOREGROUND_SERVICE" />
 </manifest>

sview-17_04.tar.gz/sview/Contents/Info.plist -> sview-20_08.tar.gz/sview/Contents/Info.plist Changed

sview-17_04.tar.gz/sview/Resources/English.lproj/MainMenu.xib -> sview-20_08.tar.gz/sview/Resources/English.lproj/MainMenu.xib Changed

sview-17_04.tar.gz/sview/StMultiApp.cpp -> sview-20_08.tar.gz/sview/StMultiApp.cpp Changed

@@ -17,7 +17,7 @@
 static StString getAbout() {
     StString anAboutString =
         StString("sView ") + StVersionInfo::getSDKVersionString() + '\n'
-        + "Copyright (C) 2007-2016 Kirill Gavrilov (kirill@sview.ru).\n"
+        + "Copyright (C) 2007-2020 Kirill Gavrilov (kirill@sview.ru).\n"
         + "Usage: sView [options] - file\n"
         + "Available options:\n"
           "  --fullscreen         Open fullscreen\n"
@@ -31,6 +31,7 @@
           "  --slideshow          Start slideshow\n"
           "  --last               Open last file\n"
           "  --paused             Open file in paused state\n"
+          "  --seek=SECONDS       Seek to specified position\n"
           "  --in=image,video     Application to open (predefined values: image, video, diag)\n"
           "  --out=RENDERER       Stereoscopic output module (auto, StOutAnaglyph, StOutDual,...)\n"
           "  --imageLib=IMGLIB    Setup 3rd-party library for image processing (FFmpeg, FreeImage, DevIL)\n"
@@ -54,6 +55,7 @@
           "                       mute - mute/unmute audio\n"
           "                       vol?VOLUME - specify volume in percents\n"
           "                       prev,next - play previous/next item in playlist\n"
+          "                       seek?SECONDS - specify volume in percents\n"
           "                       fastbwd,fastfwd - seek backward/forward\n"
           "                       quit - close the program\n"
           "                       current?title - print title of currently played item\n"
@@ -110,7 +112,7 @@
         } else if(anActLow == "currenttitle") {
             anAction = "current?title";
         } else if(anAction.isContains('?')) {
-            anAction = anAction;
+            //anAction = anAction;
         } else if(anActLow == "fastbwd") {
             anAction = "action?DoSeekLeft";
         } else if(anActLow == "fastfwd") {
@@ -145,6 +147,10 @@
     // select application
     const StString ARGUMENT_DRAWER = "in";
     StArgument anArgDrawer = anArgs[ARGUMENT_DRAWER];
+    if(!anInfo->hasPath() && !anArgDrawer.isValid()) {
+        StApplication::readDefaultDrawer(anInfo);
+        anArgDrawer = anInfo->getArgumentsMap()[ARGUMENT_DRAWER];
+    }
     if(anArgDrawer.isValid()) {
         if(anArgDrawer.getValue() == "image"
         || anArgDrawer.getValue() == "StImageViewer") {

sview-17_04.tar.gz/sview/main.ObjC.mm -> sview-20_08.tar.gz/sview/main.ObjC.mm Changed

@@ -181,9 +181,12 @@
                 }
             }
         }
-        if(TheOpenInfo->hasPath()
-        || anArgsNb > 1) {
-            // create StApplication instance only if we know which drawer plugin to launch
+
+        // create StApplication instance only if we know which drawer plugin to launch
+        bool toStart = true;
+        //bool toStart = TheOpenInfo->hasPath() || anArgsNb > 1;
+        //if(!toStart) { toStart = StApplication::readDefaultDrawer(TheOpenInfo); }
+        if(toStart) {
             [self launchSelf: NULL];
         }
         myIsStarted = true;
@@ -250,6 +253,16 @@
         }
 
         if(myStApp->closingDown()) {
+            StHandle<StOpenInfo> anOther = myStApp->getOpenFileInOtherDrawer();
+            if(!anOther.isNull()) {
+                myStApp.nullify();
+                StHandle<StResourceManager> aResMgr = new StResourceManager();
+                myStApp = StMultiApp::getInstance(aResMgr, anOther);
+                if(!myStApp.isNull() && myStApp->open()) {
+                    return true;
+                }
+            }
+
             myStApp.nullify();
 
             // this will call exit(), so code below has no effect

sview-17_04.tar.gz/sview/main.cpp -> sview-20_08.tar.gz/sview/main.cpp Changed

sview-20_08.tar.gz/sview/res/drawable-hdpi/ic_media_play.png Added

sview-20_08.tar.gz/sview/res/drawable-mdpi/ic_media_play.png Added

sview-20_08.tar.gz/sview/res/drawable-xhdpi/ic_media_play.png Added

sview-20_08.tar.gz/sview/res/drawable-xxhdpi/ic_media_play.png Added

sview-17_04.tar.gz/sview/res/values/strings.xml -> sview-20_08.tar.gz/sview/res/values/strings.xml Changed

sview-17_04.tar.gz/sview/src/com/sview/StActivity.java -> sview-20_08.tar.gz/sview/src/com/sview/StActivity.java Changed

@@ -146,6 +146,11 @@
         myContext = new ContextWrapper(this);
         myContext.getExternalFilesDir(null);
 
+        askUserPermission(android.Manifest.permission.WRITE_EXTERNAL_STORAGE, null);
+
+        android.os.PowerManager aPowerManager = (android.os.PowerManager)getSystemService(Context.POWER_SERVICE);
+        myWakeLock = aPowerManager.newWakeLock(android.os.PowerManager.PARTIAL_WAKE_LOCK, "sView.PartialWakeLock");
+
         mySensorMgr = (SensorManager )getSystemService(Context.SENSOR_SERVICE);
         mySensorOri = mySensorMgr.getDefaultSensor(Sensor.TYPE_ROTATION_VECTOR);
         if(mySensorOri == null) {
@@ -165,11 +170,64 @@
             anInfo.append("Error: native library can not be loaded for security reasons:\n  " + theError.getMessage());
             StActivity.exitWithError(this, "Broken apk?\n" + anInfo);
         } catch(Exception theError) {
-            anInfo.append("Error: unhandled exception:\n  " + theError.getMessage());
+            java.io.StringWriter aStringWriter = new java.io.StringWriter();
+            theError.printStackTrace (new java.io.PrintWriter (aStringWriter));
+            anInfo.append("Error: unhandled exception:\n  " + theError.getMessage()
+                        + "\nCall stack:\n" + aStringWriter.toString());
             StActivity.exitWithError(this, "Broken apk?\n" + anInfo);
         }
 
         updateHideSystemBars(myToHideStatusBar, myToHideNavBar);
+
+        // readOpenPath(false) should be called - NULLify intent afterwards
+        setIntent(null);
+    }
+
+    /**
+     * Request user permission.
+     */
+    protected void askUserPermission(String thePermission, String theRationale) {
+        // Dynamically load methods introduced by API level 23.
+        // On older system this permission is granted by user during application installation.
+        java.lang.reflect.Method aMetPtrCheckSelfPermission, aMetPtrRequestPermissions, aMetPtrShouldShowRequestPermissionRationale;
+        try {
+            aMetPtrCheckSelfPermission = myContext.getClass().getMethod("checkSelfPermission", String.class);
+            aMetPtrRequestPermissions = getClass().getMethod("requestPermissions", String[].class, int.class);
+            aMetPtrShouldShowRequestPermissionRationale = getClass().getMethod("shouldShowRequestPermissionRationale", String.class);
+        } catch(SecurityException theError) {
+            //postMessage("Unable to find permission methods:\n" + theError.getMessage());
+            return;
+        } catch(NoSuchMethodException theError) {
+            //postMessage("Unable to find permission methods:\n" + theError.getMessage());
+            return;
+        }
+
+        try {
+            //int isAlreadyGranted = myContext.checkSelfPermission(thePermission);
+            int isAlreadyGranted = (Integer )aMetPtrCheckSelfPermission.invoke(myContext, thePermission);
+            if(isAlreadyGranted == android.content.pm.PackageManager.PERMISSION_GRANTED) {
+                return;
+            }
+
+            //boolean toShowInfo = shouldShowRequestPermissionRationale(thePermission);
+            boolean toShowInfo = theRationale != null && (Boolean )aMetPtrShouldShowRequestPermissionRationale.invoke(this, thePermission);
+            if(toShowInfo) {
+                postMessage(theRationale);
+            }
+
+            // show dialog to user
+            //requestPermissions (new String[]{thePermission}, 0);
+            aMetPtrRequestPermissions.invoke(this, new String[]{thePermission}, 0);
+        } catch(IllegalArgumentException theError) {
+            postMessage("Internal error: Unable to call permission method:\n" + theError.getMessage());
+            return;
+        } catch(IllegalAccessException theError) {
+            postMessage("Internal error: Unable to call permission method:\n" + theError.getMessage());
+            return;
+        } catch(java.lang.reflect.InvocationTargetException theError) {
+            postMessage("Internal error: Unable to call permission method:\n" + theError.getMessage());
+            return;
+        }
     }
 
     /**
@@ -222,6 +280,17 @@
         }
     }
 
+    /**
+     * Redirect key event to C++ level.
+     */
+    @Override
+    public boolean dispatchKeyEvent(android.view.KeyEvent theEvent) {
+        if(super.dispatchKeyEvent(theEvent)) {
+            return true;
+        }
+        return myCppGlue != 0 && cppIsKeyOverridden(myCppGlue, theEvent.getKeyCode());
+    }
+
     @Override
     public void surfaceCreated(SurfaceHolder theHolder) {
         super.surfaceCreated(theHolder);
@@ -294,20 +363,61 @@
 //region Auxiliary methods
 
     /**
+     * Action to play/pause.
+     */
+    public static final String THE_ACTION_PLAY_PAUSE = "ACTION_PLAY_PAUSE";
+
+    /**
+     * Action to open previous item in playlist.
+     */
+    public static final String THE_ACTION_PLAY_PREV = "ACTION_PLAY_PREV";
+
+    /**
+     * Action to open next item in playlist.
+     */
+    public static final String THE_ACTION_PLAY_NEXT = "ACTION_PLAY_NEXT";
+
+    /**
+     * Set playback action.
+     */
+    public boolean setPlaybackAction(Intent theIntent) {
+        if(myCppGlue == 0 || theIntent == null) {
+            return false;
+        }
+
+        if(THE_ACTION_PLAY_PAUSE.equals(theIntent.getAction())) {
+            cppSetOpenPath(myCppGlue, THE_ACTION_PLAY_PAUSE, "", false);
+            return true;
+        } else if(THE_ACTION_PLAY_PREV.equals(theIntent.getAction())) {
+            cppSetOpenPath(myCppGlue, THE_ACTION_PLAY_PREV, "", false);
+            return true;
+        } else if(THE_ACTION_PLAY_NEXT.equals(theIntent.getAction())) {
+            cppSetOpenPath(myCppGlue, THE_ACTION_PLAY_NEXT, "", false);
+            return true;
+        }
+        return false;
+    }
+
+    /**
      * Read the open path from current intent and nullify it.
      * This method is called by StAndroidGlue from C++.
      */
-    protected void readOpenPath() {
+    protected void readOpenPath(boolean theToNullifyIntent) {
         if(myCppGlue == 0) {
             return;
         }
 
         Intent anIntent = getIntent();
-        setIntent(null);
+        if(theToNullifyIntent) {
+            setIntent(null);
+        }
         if(anIntent == null) {
             cppSetOpenPath(myCppGlue, "", "", false);
             return;
         }
+        if(setPlaybackAction(anIntent)) {
+            return;
+        }
 
         String anOpenPath = anIntent.getDataString();
         String anOpenMime = anIntent.getType();
@@ -443,6 +553,36 @@
     }
 
     /**
+     * Set new activity title.
+     */
+    public void setWindowTitle(String theTitle) {
+        if(android.os.Build.VERSION.SDK_INT < 21) {
+            return;
+        }
+
+        final String aTitle = theTitle;
+        this.runOnUiThread (new Runnable() { public void run() {
+            //setTitle(aTitle); // sets window title, which we don't have...
+            setTaskDescription(new android.app.ActivityManager.TaskDescription(aTitle));
+        }});
+    }
+
+    /**
+     * Keep CPU on.
+     */
+    public void setPartialWakeLockOn(String theTitle, boolean theToLock) {
+        if(myWakeLock == null) {
+            return;
+        }
+
+        if(theToLock) {
+            myWakeLock.acquire();
+        } else if(myWakeLock.isHeld()) {
+            myWakeLock.release();
+        }
+    }
+
+    /**
      * Method to turn stereo output on or off.
      */
     public void setHardwareStereoOn(boolean theToEnable) {
@@ -598,6 +738,12 @@
     private native void cppSetSwapEyes(long theCppPtr,
                                        boolean theToSwap);
 
+    /**
+     * Return TRUE if key is processed by application.
+     */
+    private native boolean cppIsKeyOverridden(long theCppPtr,
+                                              int theKeyCode);
+
 //endregion
 
     @SuppressWarnings("deprecation")
@@ -606,6 +752,8 @@
 //region class fields
 
     protected ContextWrapper myContext;
+    protected android.os.PowerManager.WakeLock myWakeLock;
+
     protected SensorManager  mySensorMgr;
     protected Sensor         mySensorOri;
     protected float          myQuat[] = { 0.0f, 0.0f, 0.0f, 1.0f };

sview-17_04.tar.gz/sview/src/com/sview/StMovieActivity.java -> sview-20_08.tar.gz/sview/src/com/sview/StMovieActivity.java Changed

@@ -13,6 +13,11 @@
 public class StMovieActivity extends StActivity {
 
     /**
+     * Global reference to activity for managing by background service.
+     */
+    public static StMovieActivity backgroundActivity;
+
+    /**
      * Virtual method defining StApplication class.
      */
     @Override
@@ -21,6 +26,13 @@
     }
 
     /**
+     * Return current title.
+     */
+    public String getCurrentTitle() {
+        return myCurrentTitle;
+    }
+
+    /**
      * Create activity.
      */
     @Override
@@ -28,4 +40,43 @@
         super.onCreate(theSavedInstanceState);
     }
 
+    /**
+     * Keep CPU on.
+     */
+    @Override
+    public void setPartialWakeLockOn(String theTitle, boolean theToLock) {
+        if(myWakeLock == null) {
+            return;
+        }
+
+        super.setPartialWakeLockOn(theTitle, theToLock);
+        if(android.os.Build.VERSION.SDK_INT < 24) {
+            return;
+        }
+
+        final String  aTitle = theTitle;
+        final boolean toLock = theToLock;
+        final StMovieActivity aThis = this;
+        this.runOnUiThread(new Runnable() { public void run() {
+            // start a dummy foreground service, which actually does nothing but shows a system notification;
+            // this service (but the very existance) prevents system closing/suspending sView working threads playing audio in background
+            myCurrentTitle = aTitle;
+            android.content.Intent anIntent = new android.content.Intent(aThis, StMovieService.class);
+            if(toLock) {
+                backgroundActivity = aThis;
+                anIntent.setAction(toLock ? StMovieService.THE_ACTION_START_SERVICE : StMovieService.THE_ACTION_STOP_SERVICE);
+                if(android.os.Build.VERSION.SDK_INT >= 26) {
+                    startForegroundService(anIntent);
+                } else {
+                    startService(anIntent);
+                }
+            } else {
+                backgroundActivity = null;
+                stopService(anIntent);
+            }
+        }});
+    }
+
+    private String myCurrentTitle;
+
 }

sview-20_08.tar.gz/sview/src/com/sview/StMovieService.java Added

@@ -0,0 +1,190 @@
+/**
+ * This is source code for sView
+ *
+ * Copyright © Kirill Gavrilov, 2019
+ */
+package com.sview;
+
+import android.os.Bundle;
+
+/**
+ * Dummy foreground service for playing audio in background.
+ * Does nothing but shows a notification.
+ */
+public class StMovieService extends android.app.Service  {
+
+    /**
+     * Action to start service.
+     */
+    public static final String THE_ACTION_START_SERVICE = "ACTION_START_SERVICE";
+
+    /**
+     * Action to stop service.
+     */
+    public static final String THE_ACTION_STOP_SERVICE = "ACTION_STOP_SERVICE";
+
+    /**
+     * Custom channel ID.
+     */
+    private final String THE_SVIEW_AUDIO_CHANNEL_ID = "com.sview.audio_channel";
+
+    /**
+     * Empty constructor.
+     */
+    public StMovieService() {
+        //
+    }
+
+    /**
+     * Create service.
+     */
+    @Override
+    public void onCreate() {
+        super.onCreate();
+        createNotificationChannel();
+        // should be started within several seconds, or will be killed by system
+        startForegroundService();
+    }
+
+    /**
+     * Destroy service.
+     */
+    @Override
+    public void onDestroy() {
+        //
+    }
+
+    /**
+     * Create binding.
+     */
+    @Override
+    public android.os.IBinder onBind(android.content.Intent theIntent) {
+        // we don't provide binding, so return null
+        return null;
+    }
+
+    /**
+     * Start a command.
+     */
+    @Override
+    public int onStartCommand(android.content.Intent theIntent, int theFlags, int theStartId) {
+        String anAction = theIntent != null ? theIntent.getAction() : THE_ACTION_STOP_SERVICE;
+        //android.widget.Toast.makeText(this, " @@ " + anAction, android.widget.Toast.LENGTH_LONG).show();
+        switch(anAction) {
+            case THE_ACTION_START_SERVICE: {
+                // if we get killed, after returning from here, restart
+                startForegroundService();
+                return START_STICKY;
+            }
+            case THE_ACTION_STOP_SERVICE: {
+                stopForegroundService();
+                return START_NOT_STICKY;
+            }
+            case StActivity.THE_ACTION_PLAY_PREV:
+            case StActivity.THE_ACTION_PLAY_NEXT:
+            case StActivity.THE_ACTION_PLAY_PAUSE: {
+                //android.widget.Toast.makeText(this, " $$ " + anAction, android.widget.Toast.LENGTH_LONG).show();
+                final StMovieActivity aMainActivity = StMovieActivity.backgroundActivity;
+                if(aMainActivity != null) {
+                    aMainActivity.setPlaybackAction(theIntent);
+                }
+                return START_NOT_STICKY;
+            }
+        }
+        return START_NOT_STICKY;
+    }
+
+    /**
+     * Start foreground service - create notification.
+     */
+    private void startForegroundService() {
+        final StMovieActivity aMainActivity = StMovieActivity.backgroundActivity;
+        String anActiveItem = "Audio playback";
+        if(aMainActivity != null) {
+            anActiveItem = aMainActivity.getCurrentTitle();
+        }
+
+        android.content.Intent anIntent = new android.content.Intent(this, StMovieActivity.class);
+        android.app.PendingIntent aPendingIntent = android.app.PendingIntent.getActivity(this, 0, anIntent, 0);
+
+        android.app.Notification.Builder aNoti;
+        if(android.os.Build.VERSION.SDK_INT >= 26) {
+            aNoti = new android.app.Notification.Builder(this, THE_SVIEW_AUDIO_CHANNEL_ID);
+        } else {
+            aNoti = new android.app.Notification.Builder(this);
+        }
+        aNoti.setPriority(android.app.Notification.PRIORITY_LOW); // Android 8.0+ will use Notification Channel importance instead
+        //aNoti.setAutoCancel(true);
+        aNoti.setContentIntent(aPendingIntent); // intent on tapping notification
+        aNoti.setContentTitle(anActiveItem);
+        //aNoti.setContentText("");
+        aNoti.setSmallIcon(com.sview.R.drawable.ic_media_play);
+        //aNoti.setLargeIcon(aBitmap);
+
+        // add buttons (note that Android 7.0+ will NOT show action icons!)
+        {
+            android.content.Intent aPlayIntent = new android.content.Intent(this, StMovieService.class);
+            aPlayIntent.setAction(StActivity.THE_ACTION_PLAY_PREV);
+            android.app.PendingIntent aPendingPlayIntent = android.app.PendingIntent.getService(this, 0, aPlayIntent, 0);
+            aNoti.addAction(new android.app.Notification.Action(android.R.drawable.ic_media_previous,
+                                                                android.os.Build.VERSION.SDK_INT >= 24
+                                                              ? "    \u23EE    "
+                                                              : "PREV",
+                                                                aPendingPlayIntent));
+        }
+        {
+            android.content.Intent aPlayIntent = new android.content.Intent(this, StMovieService.class);
+            aPlayIntent.setAction(StActivity.THE_ACTION_PLAY_PAUSE);
+            android.app.PendingIntent aPendingPlayIntent = android.app.PendingIntent.getService(this, 0, aPlayIntent, 0);
+            aNoti.addAction(new android.app.Notification.Action(android.R.drawable.ic_media_pause,
+                                                                android.os.Build.VERSION.SDK_INT >= 24
+                                                              ? "    \u23F9    " // "    \u23F8    "
+                                                              : "PAUSE", aPendingPlayIntent));
+        }
+        {
+            android.content.Intent aPlayIntent = new android.content.Intent(this, StMovieService.class);
+            aPlayIntent.setAction(StActivity.THE_ACTION_PLAY_NEXT);
+            android.app.PendingIntent aPendingPlayIntent = android.app.PendingIntent.getService(this, 0, aPlayIntent, 0);
+            aNoti.addAction(new android.app.Notification.Action(android.R.drawable.ic_media_next,
+                                                                android.os.Build.VERSION.SDK_INT >= 24
+                                                              ? "    \u23ED    "
+                                                              : "NEXT",
+                                                                aPendingPlayIntent));
+        }
+        final int aNotifId = 1; // unique ID, should not be 0
+        try {
+            startForeground(aNotifId, aNoti.build());
+        } catch(SecurityException theError) {
+            android.widget.Toast.makeText(this,
+                                          "Internal error: unable to start StMovieService.startForeground() due to security reasons:\n  " + theError.getMessage(),
+                                          android.widget.Toast.LENGTH_LONG).show();
+        }
+    }
+
+    /**
+     * Stop foreground service and remove the notification.
+     */
+    private void stopForegroundService() {
+        stopForeground(true);
+        stopSelf();
+    }
+
+    /**
+     * Create the NotificationChannel (adjust settings of the channel).
+     */
+    private void createNotificationChannel() {
+        if(android.os.Build.VERSION.SDK_INT < 26) {
+            return;
+        }
+
+        android.app.NotificationChannel aChannel = new android.app.NotificationChannel(THE_SVIEW_AUDIO_CHANNEL_ID,
+                                                                                       THE_SVIEW_AUDIO_CHANNEL_ID,
+                                                                                       android.app.NotificationManager.IMPORTANCE_LOW);
+        aChannel.enableLights(false);
+        aChannel.enableVibration(false);
+        aChannel.setSound(null, null);
+        android.app.NotificationManager aNotifMgr = getSystemService(android.app.NotificationManager.class);
+        aNotifMgr.createNotificationChannel(aChannel);
+    }
+
+}

sview-17_04.tar.gz/sview/sview.cbp -> sview-20_08.tar.gz/sview/sview.cbp Changed

sview-17_04.tar.gz/sview/sview.rc -> sview-20_08.tar.gz/sview/sview.rc Changed

Overview

Request 5437 (accepted)

Request History