Fix AC3 dowmix

Support for LIBPLACEBO with opengl -> needs API >= 106

Makefile

@@ -1,6 +1,6 @@
 #
 # Makefile for a Video Disk Recorder plugin
-#
+# 
 # $Id: 2a41981a57e5e83036463c6a08c84b86ed9d2be3 $
 
 # The official name of this plugin.
@@ -11,23 +11,32 @@
 ### Configuration (edit this for your needs)
 #  comment out if not needed
 
-# what kind of driver do we make -
-# if VAAPI is enabled the drivername is softhdvaapi
-# if CUVID is enabled the drivername is softhdcuvid
-#VAAPI=1
-CUVID=1
+# what kind of decoder do we make - 
+# if VAAPI is enabled the pluginname is softhdvaapi
+# if CUVID is enabled the pluginname is softhdcuvid
+# if DRM   is enabled the pluginname is softhddrm
+VAAPI ?= 0
+CUVID ?= 0
 
-# use libplacebo - available for both drivers
-#LIBPLACEBO=1
+# if you enable DRM then the plugin will only run without X server
+# only valid for VAAPI 
+DRM ?= 0
+
+
+# use libplacebo - 
+# available for all decoders but for DRM you need LIBPLACEBO_GL  
+LIBPLACEBO ?= 1
+LIBPLACEBO_GL ?= 0
 
 # use YADIF deint - only available with cuvid
 #YADIF=1
 
+# use gamma correction
+#GAMMA ?= 0
 
 
 
-
-
+CONFIG :=  #-DDEBUG 		# remove # to enable debug output
 
 
 
@@ -35,6 +44,42 @@ CUVID=1
 
 
 #--------------------- no more config needed past this point--------------------------------
+
+# sanitize selections --------
+ifneq "$(MAKECMDGOALS)" "clean"
+ifneq "$(MAKECMDGOALS)" "indent"
+
+ifeq ($(VAAPI),0)
+ifeq ($(CUVID),0)
+ifeq ($(DRM),0)
+$(error Please define a plugin in the Makefile)
+exit 1;
+endif
+endif
+endif
+
+
+ifeq ($(CUVID),1)
+ifeq ($(DRM),1)
+$(error Missmatch in Plugin selection)
+exit 1;
+endif
+endif
+
+
+ifeq ($(CUVID),1)
+ifeq ($(VAAPI),1)
+$(error Missmatch in Plugin selection)
+exit 1;
+endif
+endif
+
+endif # MAKECMDGOALS!=indent
+endif # MAKECMDGOALS!=clean
+#--------------------------
+
+
+
 PLUGIN = softhdcuvid
 
 # support OPENGLOSD always needed
@@ -60,7 +105,6 @@ SWRESAMPLE = 1
 #AVRESAMPLE = 1
 #endif
 
-CONFIG :=  #-DDEBUG #-DOSD_DEBUG	# enable debug output+functions
 CONFIG += -DHAVE_GL			# needed for mpv libs
 #CONFIG += -DSTILL_DEBUG=2		# still picture debug verbose level
 CONFIG += -DAV_INFO -DAV_INFO_TIME=3000	# info/debug a/v sync
@@ -92,7 +136,7 @@ TMPDIR ?= /tmp
 
 ### The compiler options:
 
-export CFLAGS   = $(call PKGCFG,cflags)
+export CFLAGS	= $(call PKGCFG,cflags) 
 export CXXFLAGS = $(call PKGCFG,cxxflags)
 
 ifeq ($(CFLAGS),)
@@ -136,32 +180,51 @@ endif
 ifeq ($(OPENGL),1)
 CONFIG += -DUSE_GLX
 _CFLAGS += $(shell pkg-config --cflags gl glu glew)
-#LIBS += $(shell pkg-config --libs glu glew)
+#LIBS += $(shell pkg-config --libs glu  glew)
 _CFLAGS += $(shell pkg-config --cflags freetype2)
 LIBS   += $(shell pkg-config --libs freetype2)
 endif
 
 ifeq ($(VAAPI),1)
-CONFIG += -DVAAPI
+CONFIG += -DVAAPI 
 #LIBPLACEBO=1
 PLUGIN = softhdvaapi
-LIBS += -lEGL
+endif
+
+ifeq ($(LIBPLACEBO_GL),1)
+CONFIG += -DPLACEBO_GL -DPLACEBO
+LIBS += -lepoxy  
+LIBS += -lplacebo 
+else
+LIBS += -lEGL  
 endif
 
 ifeq ($(LIBPLACEBO),1)
 CONFIG += -DPLACEBO
+LIBS += -lEGL  
+LIBS += -lplacebo 
 endif
 
+ifeq ($(DRM),1)
+PLUGIN = softhddrm
+CONFIG += -DUSE_DRM -DVAAPI
+_CFLAGS += $(shell pkg-config --cflags libdrm)
+LIBS += -lgbm -ldrm -lEGL
+endif
+
+
 ifeq ($(CUVID),1)
 CONFIG += -DUSE_PIP			# PIP support
 CONFIG += -DCUVID			# enable CUVID decoder
-LIBS += -lEGL -lGL
+LIBS += -lEGL -lGL 
 ifeq ($(YADIF),1)
 CONFIG += -DYADIF			# Yadif only with CUVID
 endif
 endif
 
-
+ifeq ($(GAMMA),1)
+CONFIG  += -DGAMMA
+endif
 
 
 ARCHIVE = $(PLUGIN)-$(VERSION)
@@ -173,7 +236,7 @@ SOFILE = libvdr-$(PLUGIN).so
 
 
 #
-# Test that libswresample is available
+# Test that libswresample is available 
 #
 #ifneq (exists, $(shell pkg-config libswresample && echo exists))
 #  $(warning ******************************************************************)
@@ -182,7 +245,7 @@ SOFILE = libvdr-$(PLUGIN).so
 #endif
 
 #
-# Test and set config for libavutil
+# Test and set config for libavutil 
 #
 ifneq (exists, $(shell pkg-config libavutil && echo exists))
   $(warning ******************************************************************)
@@ -193,7 +256,7 @@ _CFLAGS += $(shell pkg-config --cflags libavutil)
 LIBS += $(shell pkg-config --libs libavutil)
 
 #
-# Test and set config for libswscale
+# Test and set config for libswscale 
 #
 ifneq (exists, $(shell pkg-config libswscale && echo exists))
   $(warning ******************************************************************)
@@ -233,24 +296,19 @@ endif
 
 #_CFLAGS += $(shell pkg-config --cflags libavcodec x11 x11-xcb xcb xcb-icccm)
 #LIBS += -lrt $(shell pkg-config --libs libavcodec x11 x11-xcb xcb xcb-icccm)
-_CFLAGS += $(shell pkg-config --cflags x11 x11-xcb xcb xcb-icccm)
-LIBS += -lrt $(shell pkg-config --libs x11 x11-xcb xcb xcb-icccm)
+_CFLAGS += $(shell pkg-config --cflags  x11 x11-xcb xcb xcb-icccm)
+LIBS += -lrt $(shell pkg-config --libs  x11 x11-xcb xcb xcb-icccm)
 
-_CFLAGS += -I/usr/local/cuda/include
 _CFLAGS += -I./opengl -I./
 
 LIBS += -L/usr/lib64
-LIBS += -L/usr/local/cuda/lib64
 
-ifeq ($(LIBPLACEBO),1)
-LIBS += -lplacebo 
-endif
 
 ifeq ($(CUVID),1)
-LIBS += -lcuda -L/usr/local/cuda/targets/x86_64-linux/lib -lcudart -lnvcuvid
+LIBS +=  -lcuda  -lnvcuvid  
 endif
 
-LIBS += -lGLEW -lGLU  -ldl -lglut
+LIBS += -lGLEW -lGLU  -ldl -lglut 
 ### Includes and Defines (add further entries here):
 
 INCLUDES +=
@@ -261,19 +319,24 @@ DEFINES += -DPLUGIN_NAME_I18N='"$(PLUGIN)"' -D_GNU_SOURCE $(CONFIG) \
 ### Make it standard
 
 override CXXFLAGS += $(_CFLAGS) $(DEFINES) $(INCLUDES) \
-    -g -Wextra -Winit-self -Werror=overloaded-virtual -std=c++0x
-override CFLAGS   += $(_CFLAGS) $(DEFINES) $(INCLUDES) \
+    -g  -W -Wextra -Winit-self -Werror=overloaded-virtual  -Wno-unused-parameter 
+override CFLAGS	  += $(_CFLAGS) $(DEFINES) $(INCLUDES) \
     -g -W  -Wextra -Winit-self -Wdeclaration-after-statement
 
 
 ### The object files (add further files here):
 
-OBJS = softhdcuvid.o softhddev.o video.o audio.o codec.o ringbuffer.o
-ifeq ($(OPENGLOSD),1)
-OBJS += openglosd.o
+OBJS = softhdcuvid.o softhddev.o video.o audio.o codec.o ringbuffer.o openglosd.o 
+ifeq ($(GAMMA),1)
+OBJS += colorramp.o 
+ifeq ($(DRM),1)
+OBJS += gamma-drm.o
+else
+OBJS += gamma-vidmode.o
+endif
 endif
 
-SRCS = $(wildcard $(OBJS:.o=.c)) softhdcuvid.cpp
+SRCS = $(wildcard $(OBJS:.o=.c)) *.cpp
 
 ### The main target:
 
@@ -290,11 +353,11 @@ $(DEPFILE): Makefile
 
 ### Internationalization (I18N):
 
-PODIR     = po
-I18Npo    = $(wildcard $(PODIR)/*.po)
-I18Nmo    = $(addsuffix .mo, $(foreach file, $(I18Npo), $(basename $(file))))
+PODIR	  = po
+I18Npo	  = $(wildcard $(PODIR)/*.po)
+I18Nmo	  = $(addsuffix .mo, $(foreach file, $(I18Npo), $(basename $(file))))
 I18Nmsgs  = $(addprefix $(DESTDIR)$(LOCDIR)/, $(addsuffix /LC_MESSAGES/vdr-$(PLUGIN).mo, $(notdir $(foreach file, $(I18Npo), $(basename $(file))))))
-I18Npot   = $(PODIR)/$(PLUGIN).pot
+I18Npot	  = $(PODIR)/$(PLUGIN).pot
 
 %.mo: %.po
 	msgfmt -c -o $@ $<
@@ -322,7 +385,7 @@ $(OBJS): Makefile
 
 
 $(SOFILE): $(OBJS) shaders.h
-	$(CXX) $(CXXFLAGS) $(LDFLAGS) -shared  $(OBJS) $(LIBS) -o $@
+	$(CXX) $(CXXFLAGS) $(LDFLAGS) -shared  $(OBJS) $(LIBS)  -o $@
 
 install-lib: $(SOFILE)
 	install -D $^ $(DESTDIR)$(LIBDIR)/$^.$(APIVERSION)
@@ -343,11 +406,13 @@ clean:
 
 ## Private Targets:
 
-HDRS=   $(wildcard *.h)
+HDRS=	$(wildcard *.h)
 
 indent:
 	for i in $(SRCS) $(HDRS); do \
 		indent $$i; \
+		unexpand -a $$i | sed -e s/constconst/const/ > $$i.up; \
+		mv $$i.up $$i; \
 	done
 
 video_test: video.c Makefile

README.md

@@ -23,8 +23,8 @@ $Id: 5267da021a68b4a727b479417334bfbe67bbba14 $
 
 A software and GPU emulated UHD output device plugin for VDR.
 
-    o Video decoder CPU / VDPAU
-    o Video output opengl
+    o Video decoder CUVID or VAAPI
+    o Video output opengl or DRM
     o Audio FFMpeg / Alsa / Analog
     o Audio FFMpeg / Alsa / Digital
     o Audio FFMpeg / OSS / Analog
@@ -32,9 +32,10 @@ A software and GPU emulated UHD output device plugin for VDR.
     o Software volume, compression, normalize and channel resample
     o VDR ScaleVideo API
     o CUDA deinterlacer
-    o Autocrop
     o Suspend / Dettach
-    o PIP (Picture-in-Picture) (not working yet)
+    o Support for ambilight
+    o Support for Screencopy
+    o PIP (Picture-in-Picture) (only for CUVID)
 
 
 To compile you must have the 'requires' installed.
@@ -47,34 +48,20 @@ Current Status NVIDIA:
 The CUDA driver supports HEVC with 8 Bit and 10 Bit up to UHD resolution. Opengl is able to output also 10 Bit, but NVIDIA does not support to output 10 Bit via HDMI.
 Only via DisplayPort you can get 10 Bit output to a compatible screen. This is a restriction from NVIDIA.
 
-Current Status with VAAPI
-You need libplacebo.
-It is still beta and I tested it with Intel VAAPI. If you have problmes with the shaders then copy the drirc file in your home directory as .drirc
-AMD VAAPI is broken by AMD and will not work currently. The vaapi_deinterlace is broken and the amdgpu driver is instable. I have not testet with amdgpupro
+Current Status with VAAPI:
+I tested it with Intel VAAPI. If you have problmes with the shaders then copy the drirc file in your home directory as .drirc
+AMD VAAPI is broken by AMD and will not work currently.
 
 You have to adapt the Makefile to your needs. I use FFMPEG 4.0
-The Makefile expects the CUDA SDK in /usr/local/cuda. Currently it is tested with CUDA 10
-
-Unfortunatly older FFMEGs has a bug with deinterlacing cuda frames. Best to get the latest FFMPEG Version.
-
-Otherwise  you have to patch the file in libavcodec/cuviddec.c
-Somewhere near line 860 and 1066 depending on your release:
-old:
-     ctx->frame_queue = av_fifo_alloc(ctx->nb_surfaces * sizeof(CuvidParsedFrame));
-
-new:
-     ctx->frame_queue = av_fifo_alloc((ctx->nb_surfaces + 2 ) * sizeof(CuvidParsedFrame));
 
 This Version supports building with libplacebo. https://github.com/haasn/libplacebo
 You have to enable it in the Makefile and install libplacebo yourself.
-At the moment this is Work in progress.
+
 It also needs the NVIDIA driver 410.48 or newer as well as CUDA 10.
 
-In the settings you can enable a correction for Colorblindness. First you have to decide what kind of colorblindness to use. And then the faktor of correction. If the faktor is negativ than the selected type of colorblindness is simulated. If the faktor is positiv then the colors are enhanced to try to correct the deficiency.
+I recommend to use libplacebo. It has much better scaler and does colorconversion for HDR the correct way.
 
-Also you can enable a Scaler Test feature. When enabled then the screen is split.On the left half you will see the scaler defined by Scaler Test and on the right side you will see the scaler defined at the Resolution setting. There is as small black line between the halfs to remaind you that Scaler Test is activ.
-
-If your FFMEG supports it then you can enable YADIF in the Makefile and select btween the buildin NVIDIA CUDA deinterlacer and the YADIF cuda deinterlacer.
+If your FFMEG supports it then you can enable YADIF in the Makefile and select between the buildin NVIDIA CUDA deinterlacer and the YADIF cuda deinterlacer.
 
 Good luck
 jojo61
@@ -82,7 +69,17 @@ jojo61
 Quickstart:
 -----------
 
-Just type make and use.
+You have to adapt the Makefile. There are 3 possible Version that you can build:
+
+    softhdcuvid
+    This is for NVIDA cards and uses cuvid as decoder. It uses xcb for output and needs a X Server to run.
+
+    softhdvaapi
+    This is for INTEL cards and uses Vaapi as decoder. It uses xcb for output and needs a X Server to run.
+
+    softhddrm
+    This is for INTEL cards and also uses Vaapi as decoder. It uses the DRM API for output and
+    runs without X Server. There are several commandline options to select the resolution and refresh rate.
 
 Install:
 --------
@@ -98,6 +95,34 @@ Install:
 
 	You have to start vdr with -P 'softhdcuvid -d :0.0  ..<more option>.. '
 
+Beginners Guide for libplacebo:
+-------------------------------
+    When using libplacebo you will find several config options.
+
+    First of all you need to set the right scaler for each resolution:
+    Best you beginn with setting all to "bilinear". If that works ok for you, you can try to change them
+    for more advanced scaler. I use ewa_robidouxsharp on my GTX1050, but your mileage may vary.
+    Unfortunatly on INTEL not all scalers may work or crash.
+
+    You can enable a Scaler Test feature. When enabled then the screen is split.On the left half you will
+    see the scaler defined by Scaler Test and on the right side you will see the scaler defined at the
+    Resolution setting. There is as small black line between the halfs to remaind you that Scaler Test
+    is activ.
+
+    Then you should set the Monitor Colorspace to "sRGB". This guarantees you the best colors on your screen.
+    At the moment all calculations internaly are done in RGB space and all cards output also RGB.
+
+    If you are colorblind you could try to remedy this with the Colorblind Settings. Realy only needed
+    in rare cases.
+
+    All other settings can be in their default state.
+    
+    Beginning with libplacebo API 58 user shaders from mpv are supported. Use -S parameter to set the shader.
+    The plugins searches the shaders in $ConfigDir/plugins/shaders for the shaders. One example shader is 
+    provided in the shader subdirectory. Copy it to e.g.: /etc/vdr/plugins/shaders and then start  
+    vdr -P 'softhdcuvid -S filmgrain.glsl ...'
+
+
 
 Setup:	environment
 ------
@@ -211,18 +236,6 @@ Setup: /etc/vdr/setup.conf
 	0 = default (336 ms)
 	1 - 1000 = size of the buffer in ms
 
-	softhddevice.AutoCrop.Interval = 0
-	0 disables auto-crop
-	n each 'n' frames auto-crop is checked.
-
-	softhddevice.AutoCrop.Delay = 0
-	if auto-crop is over 'n' intervals the same, the cropping is
-	used.
-
-	softhddevice.AutoCrop.Tolerance = 0
-	if detected crop area is too small, cut max 'n' pixels at top and
-	bottom.
-
 	softhddevice.Background = 0
 	32bit RGBA background color
 	(Red * 16777216 +  Green * 65536 + Blue * 256 + Alpha)
@@ -262,11 +275,13 @@ Setup: /etc/vdr/setup.conf
 	0 pan and scan
 	1 letter box
 	2 center cut-out
+	3 original
 
 	softhddevice.VideoOtherDisplayFormat = 1
 	0 pan and scan
 	1 pillar box
 	2 center cut-out
+	3 original
 
 	softhddevice.pip.X = 79
 	softhddevice.pip.Y = 78
@@ -293,22 +308,6 @@ Setup: /etc/vdr/setup.conf
 	PIP alternative video window position and size in percent.
 
 
-Setup: /etc/vdr/remote.conf
-------
-
-	Add "XKeySym." definitions to /etc/vdr/remote.conf to control
-	the vdr and plugin with the connected input device.
-
-	fe.
-	XKeySym.Up	Up
-	XKeySym.Down	Down
-	...
-
-	Additional to the x11 input sends the window close button "Close".
-
-	fe.
-	XKeySym.Power	Close
-
 Commandline:
 ------------
 
@@ -356,25 +355,4 @@ Running:
 
 Known Bugs:
 -----------
-	SD Stream not working very well
-	RESUME starts wirh black screen (channelswitch needed)
-
-Requires:
----------
-	media-video/vdr (version >=1.7.xx)
-		Video Disk Recorder - turns a pc into a powerful set top box
-		for DVB.
-		http://www.tvdr.de/
-
-	media-video/ffmpeg (version >=0.7)
-		Complete solution to record, convert and stream audio and
-		video. Includes libavcodec and libswresample.
-		http://ffmpeg.org
-	media-libs/alsa-lib
-		Advanced Linux Sound Architecture Library
-		http://www.alsa-project.org
-    or
-	kernel support for oss/oss4 or alsa oss emulation
-
-
-Optional:
+	SD Streams not working very well on vaapi

audio.c

@@ -86,6 +86,8 @@
 #define __USE_GNU
 #endif
 #include <pthread.h>
+#include <sys/syscall.h>
+#include <sys/resource.h>
 #ifndef HAVE_PTHREAD_NAME
 /// only available with newer glibc
 #define pthread_setname_np(thread, name)
@@ -144,7 +146,6 @@ static volatile char AudioRunning;      ///< thread running / stopped
 static volatile char AudioPaused;       ///< audio paused
 static volatile char AudioVideoIsReady; ///< video ready start early
 static int AudioSkip;                   ///< skip audio to sync to video
-int AudioDelay;                         /// delay audio to sync to video
 
 static const int AudioBytesProSample = 2;   ///< number of bytes per sample
 
@@ -688,7 +689,7 @@ static int AudioRingAdd(unsigned sample_rate, int channels, int passthrough)
     AudioRing[AudioRingWrite].InChannels = channels;
     AudioRing[AudioRingWrite].HwSampleRate = sample_rate;
     AudioRing[AudioRingWrite].HwChannels = AudioChannelMatrix[u][channels];
-    AudioRing[AudioRingWrite].PTS = INT64_C(0x8000000000000000);
+    AudioRing[AudioRingWrite].PTS = AV_NOPTS_VALUE;
     RingBufferReset(AudioRing[AudioRingWrite].RingBuffer);
 
     Debug(3, "audio: %d ring buffer prepared\n", atomic_read(&AudioRingFilled) + 1);
@@ -1156,7 +1157,7 @@ static int64_t AlsaGetDelay(void)
         //Debug(3, "audio/alsa: %ld frames delay ok, but not running\n", delay);
 #endif
     }
-    //Debug(3, "audio/alsa: %ld frames hw delay\n", delay);
+    Debug(4, "audio/alsa: %ld frames hw delay\n", delay);
 
     // delay can be negative, when underrun occur
     if (delay < 0) {
@@ -1291,7 +1292,6 @@ static int AlsaSetup(int *freq, int *channels, int passthrough)
         Info(_("audio/alsa: start delay %ums\n"), (AudioStartThreshold * 1000)
             / (*freq * *channels * AudioBytesProSample));
     }
-
     return 0;
 }
 
@@ -1989,7 +1989,7 @@ static int AudioNextRing(void)
 
     // stop, if not enough in next buffer
     used = RingBufferUsedBytes(AudioRing[AudioRingRead].RingBuffer);
-    if (AudioStartThreshold * 10 < used || (AudioVideoIsReady && AudioStartThreshold < used)) {
+    if (AudioStartThreshold * 4 < used || (AudioVideoIsReady && AudioStartThreshold < used)) {
         return 0;
     }
     return 1;
@@ -2004,6 +2004,7 @@ static void *AudioPlayHandlerThread(void *dummy)
 {
     Debug(3, "audio: play thread started\n");
     prctl(PR_SET_NAME, "cuvid audio", 0, 0, 0);
+
     for (;;) {
         // check if we should stop the thread
         if (AudioThreadStop) {
@@ -2020,9 +2021,10 @@ static void *AudioPlayHandlerThread(void *dummy)
         } while (!AudioRunning);
         pthread_mutex_unlock(&AudioMutex);
 
-        Debug(3, "audio: ----> %dms start\n", (AudioUsedBytes() * 1000)
+        Debug(3, "audio: ----> %dms %d start\n", (AudioUsedBytes() * 1000)
             / (!AudioRing[AudioRingWrite].HwSampleRate + !AudioRing[AudioRingWrite].HwChannels +
-                AudioRing[AudioRingWrite].HwSampleRate * AudioRing[AudioRingWrite].HwChannels * AudioBytesProSample));
+                AudioRing[AudioRingWrite].HwSampleRate * AudioRing[AudioRingWrite].HwChannels * AudioBytesProSample),
+            AudioUsedBytes());
 
         do {
             int filled;
@@ -2056,10 +2058,8 @@ static void *AudioPlayHandlerThread(void *dummy)
                 AudioUsedModule->FlushBuffers();
                 atomic_sub(flush, &AudioRingFilled);
                 if (AudioNextRing()) {
-                    Debug(3, "audio: HandlerThread break after flush\n");
                     break;
                 }
-                Debug(3, "audio: continue after flush\n");
             }
             // try to play some samples
             err = 0;
@@ -2284,18 +2284,18 @@ void AudioEnqueue(const void *samples, int count)
         }
         // forced start or enough video + audio buffered
         // for some exotic channels * 4 too small
-        if (AudioStartThreshold * 10 < n || (AudioVideoIsReady
+        if (AudioStartThreshold * 4 < n || (AudioVideoIsReady
                 //  if ((AudioVideoIsReady
                 && AudioStartThreshold < n)) {
             // restart play-back
             // no lock needed, can wakeup next time
             AudioRunning = 1;
             pthread_cond_signal(&AudioStartCond);
-            Debug(3, "Start on AudioEnque\n");
+            Debug(3, "Start on AudioEnque Threshold %d n %d\n", AudioStartThreshold, n);
         }
     }
     // Update audio clock (stupid gcc developers thinks INT64_C is unsigned)
-    if (AudioRing[AudioRingWrite].PTS != (int64_t) INT64_C(0x8000000000000000)) {
+    if (AudioRing[AudioRingWrite].PTS != (int64_t) AV_NOPTS_VALUE) {
         AudioRing[AudioRingWrite].PTS += ((int64_t) count * 90 * 1000)
             / (AudioRing[AudioRingWrite].HwSampleRate * AudioRing[AudioRingWrite].HwChannels * AudioBytesProSample);
     }
@@ -2311,13 +2311,13 @@ void AudioVideoReady(int64_t pts)
     int64_t audio_pts;
     size_t used;
 
-    if (pts == (int64_t) INT64_C(0x8000000000000000)) {
+    if (pts == (int64_t) AV_NOPTS_VALUE) {
         Debug(3, "audio: a/v start, no valid video\n");
         return;
     }
     // no valid audio known
     if (!AudioRing[AudioRingWrite].HwSampleRate || !AudioRing[AudioRingWrite].HwChannels
-        || AudioRing[AudioRingWrite].PTS == (int64_t) INT64_C(0x8000000000000000)) {
+        || AudioRing[AudioRingWrite].PTS == (int64_t) AV_NOPTS_VALUE) {
         Debug(3, "audio: a/v start, no valid audio\n");
         AudioVideoIsReady = 1;
         return;
@@ -2340,9 +2340,9 @@ void AudioVideoReady(int64_t pts)
 
         // buffer ~15 video frames
         // FIXME: HDTV can use smaller video buffer
-        skip = pts - 15 * 20 * 90 - AudioBufferTime * 90 - audio_pts + VideoAudioDelay;
+        skip = pts - 0 * 20 * 90 - AudioBufferTime * 90 - audio_pts + VideoAudioDelay;
 #ifdef DEBUG
-        fprintf(stderr, "%dms %dms %dms\n", (int)(pts - audio_pts) / 90, VideoAudioDelay / 90, skip / 90);
+        //      fprintf(stderr, "a/v-diff %dms a/v-delay %dms skip %dms  Audiobuffer %d\n", (int)(pts - audio_pts) / 90, VideoAudioDelay / 90, skip / 90,AudioBufferTime);
 #endif
         // guard against old PTS
         if (skip > 0 && skip < 4000 * 90) {
@@ -2353,9 +2353,9 @@ void AudioVideoReady(int64_t pts)
                 AudioSkip = skip - used;
                 skip = used;
             }
-            Debug(3, "audio: sync advance %dms %d/%zd\n",
+            Debug(3, "audio: sync advance %dms %d/%zd  Rest %d\n",
                 (skip * 1000) / (AudioRing[AudioRingWrite].HwSampleRate * AudioRing[AudioRingWrite].HwChannels *
-                    AudioBytesProSample), skip, used);
+                    AudioBytesProSample), skip, used, AudioSkip);
             RingBufferReadAdvance(AudioRing[AudioRingWrite].RingBuffer, skip);
 
             used = RingBufferUsedBytes(AudioRing[AudioRingWrite].RingBuffer);
@@ -2363,7 +2363,6 @@ void AudioVideoReady(int64_t pts)
             Debug(3, "No audio skip -> should skip %d\n", skip / 90);
         }
         // FIXME: skip<0 we need bigger audio buffer
-
         // enough video + audio buffered
         if (AudioStartThreshold < used) {
             AudioRunning = 1;
@@ -2373,38 +2372,7 @@ void AudioVideoReady(int64_t pts)
     }
 
     AudioVideoIsReady = 1;
-#if 0
-    if (AudioRing[AudioRingWrite].HwSampleRate && AudioRing[AudioRingWrite].HwChannels) {
-        if (pts != (int64_t) INT64_C(0x8000000000000000)
-            && AudioRing[AudioRingWrite].PTS != (int64_t) INT64_C(0x8000000000000000)) {
-            Debug(3, "audio: a/v %d %s\n", (int)(pts - AudioRing[AudioRingWrite].PTS) / 90,
-                AudioRunning ? "running" : "stopped");
-        }
-        Debug(3, "audio: start %4zdms %s|%s video ready\n",
-            (RingBufferUsedBytes(AudioRing[AudioRingWrite].RingBuffer) * 1000)
-            / (AudioRing[AudioRingWrite].HwSampleRate * AudioRing[AudioRingWrite].HwChannels * AudioBytesProSample),
-            Timestamp2String(pts), Timestamp2String(AudioRing[AudioRingWrite].PTS));
 
-        if (!AudioRunning) {
-            size_t used;
-
-            used = RingBufferUsedBytes(AudioRing[AudioRingWrite].RingBuffer);
-            // enough video + audio buffered
-            if (AudioStartThreshold < used) {
-                // too much audio buffered, skip it
-                if (AudioStartThreshold < used) {
-                    Debug(3, "audio: start %4zdms skip video ready\n", ((used - AudioStartThreshold) * 1000)
-                        / (AudioRing[AudioRingWrite].HwSampleRate * AudioRing[AudioRingWrite].HwChannels *
-                            AudioBytesProSample));
-                    RingBufferReadAdvance(AudioRing[AudioRingWrite].RingBuffer, used - AudioStartThreshold);
-                }
-                AudioRunning = 1;
-                pthread_cond_signal(&AudioStartCond);
-            }
-        }
-    }
-    AudioVideoIsReady = 1;
-#endif
 }
 
 /**
@@ -2439,7 +2407,7 @@ void AudioFlushBuffers(void)
     AudioRing[AudioRingWrite].HwChannels = AudioRing[old].HwChannels;
     AudioRing[AudioRingWrite].InSampleRate = AudioRing[old].InSampleRate;
     AudioRing[AudioRingWrite].InChannels = AudioRing[old].InChannels;
-    AudioRing[AudioRingWrite].PTS = INT64_C(0x8000000000000000);
+    AudioRing[AudioRingWrite].PTS = AV_NOPTS_VALUE;
     RingBufferReadAdvance(AudioRing[AudioRingWrite].RingBuffer,
         RingBufferUsedBytes(AudioRing[AudioRingWrite].RingBuffer));
     Debug(3, "audio: reset video ready\n");
@@ -2529,6 +2497,7 @@ void AudioSetClock(int64_t pts)
         Debug(4, "audio: set clock %s -> %s pts\n", Timestamp2String(AudioRing[AudioRingWrite].PTS),
             Timestamp2String(pts));
     }
+//  printf("Audiosetclock                  pts %#012" PRIx64 " %d\n",pts,RingBufferUsedBytes(AudioRing[AudioRingWrite].RingBuffer));
     AudioRing[AudioRingWrite].PTS = pts;
 }
 
@@ -2540,7 +2509,7 @@ void AudioSetClock(int64_t pts)
 int64_t AudioGetClock(void)
 {
     // (cast) needed for the evil gcc
-    if (AudioRing[AudioRingRead].PTS != (int64_t) INT64_C(0x8000000000000000)) {
+    if (AudioRing[AudioRingRead].PTS != (int64_t) AV_NOPTS_VALUE) {
         int64_t delay;
 
         // delay zero, if no valid time stamp
@@ -2551,7 +2520,7 @@ int64_t AudioGetClock(void)
             return AudioRing[AudioRingRead].PTS + 0 * 90 - delay;
         }
     }
-    return INT64_C(0x8000000000000000);
+    return AV_NOPTS_VALUE;
 }
 
 /**

drm.c

@@ -0,0 +1,628 @@
+#include <unistd.h>
+#include <gbm.h>
+#include <sys/mman.h>
+#include <xf86drm.h>
+#include <xf86drmMode.h>
+#include <drm_fourcc.h>
+#include <xf86drm.h>
+#include <xf86drmMode.h>
+
+#define  DRM_DEBUG
+
+//----------------------------------------------------------------------------
+//  DRM
+//----------------------------------------------------------------------------
+
+struct _Drm_Render_
+{
+    int fd_drm;
+    drmModeModeInfo mode;
+    drmModeCrtc *saved_crtc;
+//    drmEventContext ev;
+    int bpp;
+    uint32_t connector_id, crtc_id, video_plane;
+    uint32_t hdr_metadata;
+    uint32_t mmWidth,mmHeight;   // Size in mm
+	uint32_t hdr_blob_id;
+
+};
+typedef struct _Drm_Render_ VideoRender;
+
+struct {
+    struct gbm_device *dev;
+    struct gbm_surface *surface;
+} gbm;
+
+VideoRender *render;
+
+//----------------------------------------------------------------------------
+//  Helper functions
+//----------------------------------------------------------------------------
+#ifndef ARRAY_SIZE
+#define ARRAY_SIZE(a) (sizeof(a) / sizeof((a)[0]))
+#endif
+struct type_name {
+    unsigned int type;
+    const char *name;
+};
+
+static const char *util_lookup_type_name(unsigned int type,
+                     const struct type_name *table,
+                     unsigned int count)
+{
+    unsigned int i;
+
+    for (i = 0; i < count; i++)
+        if (table[i].type == type)
+            return table[i].name;
+
+    return NULL;
+}
+
+static const struct type_name connector_type_names[] = {
+    { DRM_MODE_CONNECTOR_Unknown, "unknown" },
+    { DRM_MODE_CONNECTOR_VGA, "VGA" },
+    { DRM_MODE_CONNECTOR_DVII, "DVI-I" },
+    { DRM_MODE_CONNECTOR_DVID, "DVI-D" },
+    { DRM_MODE_CONNECTOR_DVIA, "DVI-A" },
+    { DRM_MODE_CONNECTOR_Composite, "composite" },
+    { DRM_MODE_CONNECTOR_SVIDEO, "s-video" },
+    { DRM_MODE_CONNECTOR_LVDS, "LVDS" },
+    { DRM_MODE_CONNECTOR_Component, "component" },
+    { DRM_MODE_CONNECTOR_9PinDIN, "9-pin DIN" },
+    { DRM_MODE_CONNECTOR_DisplayPort, "DP" },
+    { DRM_MODE_CONNECTOR_HDMIA, "HDMI-A" },
+    { DRM_MODE_CONNECTOR_HDMIB, "HDMI-B" },
+    { DRM_MODE_CONNECTOR_TV, "TV" },
+    { DRM_MODE_CONNECTOR_eDP, "eDP" },
+    { DRM_MODE_CONNECTOR_VIRTUAL, "Virtual" },
+    { DRM_MODE_CONNECTOR_DSI, "DSI" },
+    { DRM_MODE_CONNECTOR_DPI, "DPI" },
+};
+
+const char *util_lookup_connector_type_name(unsigned int type)
+{
+    return util_lookup_type_name(type, connector_type_names,
+                     ARRAY_SIZE(connector_type_names));
+}
+
+static uint64_t GetPropertyValue(int fd_drm, uint32_t objectID,
+                        uint32_t objectType, const char *propName)
+{
+    uint32_t i;
+    int found = 0;
+    uint64_t value = 0;
+    drmModePropertyPtr Prop;
+    drmModeObjectPropertiesPtr objectProps =
+        drmModeObjectGetProperties(fd_drm, objectID, objectType);
+
+    for (i = 0; i < objectProps->count_props; i++) {
+        if ((Prop = drmModeGetProperty(fd_drm, objectProps->props[i])) == NULL)
+            fprintf(stderr, "GetPropertyValue: Unable to query property.\n");
+
+        if (strcmp(propName, Prop->name) == 0) {
+            value = objectProps->prop_values[i];
+            found = 1;
+        }
+
+        drmModeFreeProperty(Prop);
+
+        if (found)
+            break;
+    }
+
+    drmModeFreeObjectProperties(objectProps);
+
+#ifdef DRM_DEBUG
+    if (!found)
+        fprintf(stderr, "GetPropertyValue: Unable to find value for property \'%s\'.\n",
+            propName);
+#endif
+    return value;
+}
+static uint32_t GetPropertyID(int fd_drm, uint32_t objectID,
+                        uint32_t objectType, const char *propName)
+{
+    uint32_t i;
+    int found = 0;
+    uint32_t value = -1;
+    drmModePropertyPtr Prop;
+    drmModeObjectPropertiesPtr objectProps =
+        drmModeObjectGetProperties(fd_drm, objectID, objectType);
+
+    for (i = 0; i < objectProps->count_props; i++) {
+        if ((Prop = drmModeGetProperty(fd_drm, objectProps->props[i])) == NULL)
+            fprintf(stderr, "GetPropertyValue: Unable to query property.\n");
+
+        if (strcmp(propName, Prop->name) == 0) {
+            value = objectProps->props[i];
+            found = 1;
+        }
+        drmModeFreeProperty(Prop);
+        if (found)
+            break;
+    }
+    drmModeFreeObjectProperties(objectProps);
+
+#ifdef DRM_DEBUG
+    if (!found)
+        Debug(3,"GetPropertyValue: Unable to find ID for property \'%s\'.\n",propName);
+#endif
+    return value;
+}
+
+static int SetPropertyRequest(drmModeAtomicReqPtr ModeReq, int fd_drm,
+                    uint32_t objectID, uint32_t objectType,
+                    const char *propName, uint64_t value)
+{
+    uint32_t i;
+    uint64_t id = 0;
+    drmModePropertyPtr Prop;
+    drmModeObjectPropertiesPtr objectProps =
+        drmModeObjectGetProperties(fd_drm, objectID, objectType);
+
+    for (i = 0; i < objectProps->count_props; i++) {
+        if ((Prop = drmModeGetProperty(fd_drm, objectProps->props[i])) == NULL)
+            printf( "SetPropertyRequest: Unable to query property.\n");
+
+        if (strcmp(propName, Prop->name) == 0) {
+            id = Prop->prop_id;
+            drmModeFreeProperty(Prop);
+            break;
+        }
+
+        drmModeFreeProperty(Prop);
+    }
+
+    drmModeFreeObjectProperties(objectProps);
+
+    if (id == 0)
+        printf( "SetPropertyRequest: Unable to find value for property \'%s\'.\n",
+            propName);
+
+    return drmModeAtomicAddProperty(ModeReq, objectID, id, value);
+}
+
+static void CuvidSetVideoMode(void);
+void set_video_mode(int width, int height)
+{
+	drmModeConnector *connector;
+	drmModeModeInfo *mode;
+	int ii;
+	if (height != 1080 && height != 2160)
+		return;
+	connector = drmModeGetConnector(render->fd_drm, render->connector_id);
+	for (ii = 0; ii < connector->count_modes; ii++) {
+		mode = &connector->modes[ii];
+		printf("Mode %d %dx%d Rate %d\n",ii,mode->hdisplay,mode->vdisplay,mode->vrefresh);
+		if (width == mode->hdisplay &&
+				height == mode->vdisplay &&
+				mode->vrefresh == DRMRefresh &&
+				render->mode.hdisplay != width &&
+		        render->mode.vdisplay != height &&
+				!(mode->flags & DRM_MODE_FLAG_INTERLACE)) {
+			memcpy(&render->mode, mode, sizeof(drmModeModeInfo));
+			VideoWindowWidth = mode->hdisplay;
+            VideoWindowHeight = mode->vdisplay;
+			eglDestroySurface (eglDisplay, eglSurface);
+			EglCheck();
+    		gbm_surface_destroy (gbm.surface);
+			InitBo(render->bpp);
+			CuvidSetVideoMode();
+			Debug(3,"Set new mode %d:%d\n",mode->hdisplay,mode->vdisplay);
+			break;
+		}
+	}
+}
+
+static int FindDevice(VideoRender * render)
+{
+    drmVersion *version;
+    drmModeRes *resources;
+    drmModeConnector *connector;
+    drmModeEncoder *encoder = 0;
+    drmModeModeInfo *mode;
+    drmModePlane *plane;
+    drmModePlaneRes *plane_res;
+    drmModeObjectPropertiesPtr props;
+    uint32_t j, k;
+    uint64_t has_dumb;
+    uint64_t has_prime;
+    int i,ii=0;
+    char connectorstr[10];
+    int found = 0;
+#ifdef RASPI
+    render->fd_drm = open("/dev/dri/card1", O_RDWR);
+#else
+	render->fd_drm = open("/dev/dri/card0", O_RDWR);
+#endif
+    if (render->fd_drm < 0) {
+        fprintf(stderr, "FindDevice: cannot open /dev/dri/card0: %m\n");
+        return -errno;
+    }
+	
+	int ret = drmSetMaster(render->fd_drm);
+ 	
+	if (ret < 0)
+	{
+		drm_magic_t magic;
+
+		ret = drmGetMagic(render->fd_drm, &magic);
+		if (ret < 0)
+		{
+		  Debug(3, "drm:%s - failed to get drm magic: %s\n", __FUNCTION__, strerror(errno));
+		  return -1;
+		}
+
+		ret = drmAuthMagic(render->fd_drm, magic);
+		if (ret < 0)
+		{
+		  Debug(3, "drm:%s - failed to authorize drm magic: %s\n", __FUNCTION__, strerror(errno));
+		  return -1;
+		}
+	}
+    
+    version = drmGetVersion(render->fd_drm);
+    fprintf(stderr, "FindDevice: open /dev/dri/card0:  %s\n",  version->name);
+
+    // check capability
+    if (drmGetCap(render->fd_drm, DRM_CAP_DUMB_BUFFER, &has_dumb) < 0 || has_dumb == 0)
+        fprintf(stderr, "FindDevice: drmGetCap DRM_CAP_DUMB_BUFFER failed or doesn't have dumb buffer\n");
+
+    if (drmSetClientCap(render->fd_drm, DRM_CLIENT_CAP_UNIVERSAL_PLANES, 1) != 0)
+        fprintf(stderr, "FindDevice: DRM_CLIENT_CAP_UNIVERSAL_PLANES not available.\n");
+
+    if (drmSetClientCap(render->fd_drm, DRM_CLIENT_CAP_ATOMIC, 1) != 0)
+        fprintf(stderr, "FindDevice: DRM_CLIENT_CAP_ATOMIC not available.\n");
+
+    if (drmGetCap(render->fd_drm, DRM_CAP_PRIME, &has_prime) < 0)
+        fprintf(stderr, "FindDevice: DRM_CAP_PRIME not available.\n");
+
+    if (drmGetCap(render->fd_drm, DRM_PRIME_CAP_EXPORT, &has_prime) < 0)
+        fprintf(stderr, "FindDevice: DRM_PRIME_CAP_EXPORT not available.\n");
+
+    if (drmGetCap(render->fd_drm, DRM_PRIME_CAP_IMPORT, &has_prime) < 0)
+        fprintf(stderr, "FindDevice: DRM_PRIME_CAP_IMPORT not available.\n");
+
+    if ((resources = drmModeGetResources(render->fd_drm)) == NULL){
+        fprintf(stderr, "FindDevice: cannot retrieve DRM resources (%d): %m\n", errno);
+        return -errno;
+    }
+
+#ifdef DEBUG
+    Debug(3,"[FindDevice] DRM have %i connectors, %i crtcs, %i encoders\n",
+        resources->count_connectors, resources->count_crtcs,
+        resources->count_encoders);
+#endif
+
+    // find all available connectors
+    for (i = 0; i < resources->count_connectors; i++) {
+        connector = drmModeGetConnector(render->fd_drm, resources->connectors[i]);
+        if (!connector) {
+            fprintf(stderr, "FindDevice: cannot retrieve DRM connector (%d): %m\n", errno);
+            return -errno;
+        }
+
+        sprintf(connectorstr,"%s-%u",util_lookup_connector_type_name(connector->connector_type),connector->connector_type_id);
+        printf("Connector >%s< is %sconnected\n",connectorstr,connector->connection == DRM_MODE_CONNECTED?"":"not ");
+        if (DRMConnector && strcmp(DRMConnector,connectorstr))
+            continue;
+
+        if (connector->connection == DRM_MODE_CONNECTED && connector->count_modes > 0) {
+			float aspect = (float)connector->mmWidth / (float)connector->mmHeight;
+			if ((aspect > 1.70) && (aspect < 1.85)) {
+				render->mmHeight     = 90;
+            	render->mmWidth      = 160;
+			} else {
+            	render->mmHeight     = connector->mmHeight;
+            	render->mmWidth      = connector->mmWidth;
+			}
+			render->connector_id = connector->connector_id;
+            // FIXME: use default encoder/crtc pair
+            if ((encoder = drmModeGetEncoder(render->fd_drm, connector->encoder_id)) == NULL){
+                fprintf(stderr, "FindDevice: cannot retrieve encoder (%d): %m\n", errno);
+                return -errno;
+            }
+            render->crtc_id = encoder->crtc_id;
+
+            render->hdr_metadata = GetPropertyID(render->fd_drm, connector->connector_id,
+                            DRM_MODE_OBJECT_CONNECTOR, "HDR_OUTPUT_METADATA");
+            printf("ID %d of METADATA in Connector %d connected %d\n",render->hdr_metadata,connector->connector_id,connector->connection);
+
+            memcpy(&render->mode, &connector->modes[0], sizeof(drmModeModeInfo));  // set fallback
+            // search Modes for Connector
+            for (ii = 0; ii < connector->count_modes; ii++) {
+                mode = &connector->modes[ii];
+
+                printf("Mode %d %dx%d Rate %d\n",ii,mode->hdisplay,mode->vdisplay,mode->vrefresh);
+
+                if (VideoWindowWidth && VideoWindowHeight) { // preset by command line
+                    if (VideoWindowWidth == mode->hdisplay &&
+                            VideoWindowHeight == mode->vdisplay &&
+                            mode->vrefresh == DRMRefresh &&
+                            !(mode->flags & DRM_MODE_FLAG_INTERLACE)) {
+                        memcpy(&render->mode, mode, sizeof(drmModeModeInfo));
+                        break;
+                    }
+                }
+                else {
+                    if (!(mode->flags & DRM_MODE_FLAG_INTERLACE)) {
+                        memcpy(&render->mode, mode, sizeof(drmModeModeInfo));
+                        VideoWindowWidth = mode->hdisplay;
+                        VideoWindowHeight = mode->vdisplay;
+                        break;
+                    }
+                }
+            }
+            found = 1;
+            i = resources->count_connectors;   // uuuuhh
+        }
+        VideoWindowWidth = render->mode.hdisplay;
+        VideoWindowHeight = render->mode.vdisplay;
+        if (found)
+            printf("Use Mode %d %dx%d Rate %d\n",ii,render->mode.hdisplay,render->mode.vdisplay,render->mode.vrefresh);
+        drmModeFreeConnector(connector);
+    }
+    if (!found) {
+        Debug(3,"Requested Connector not found or not connected\n");
+        printf("Requested Connector not found or not connected\n");
+        return -1;
+    }
+
+    // find first plane
+    if ((plane_res = drmModeGetPlaneResources(render->fd_drm)) == NULL)
+        fprintf(stderr, "FindDevice: cannot retrieve PlaneResources (%d): %m\n", errno);
+
+    for (j = 0; j < plane_res->count_planes; j++) {
+        plane = drmModeGetPlane(render->fd_drm, plane_res->planes[j]);
+
+        if (plane == NULL)
+            fprintf(stderr, "FindDevice: cannot query DRM-KMS plane %d\n", j);
+
+        for (i = 0; i < resources->count_crtcs; i++) {
+            if (plane->possible_crtcs & (1 << i))
+                break;
+        }
+
+        uint64_t type = GetPropertyValue(render->fd_drm, plane_res->planes[j],
+                            DRM_MODE_OBJECT_PLANE, "type");
+        uint64_t zpos = 0;
+
+#ifdef DRM_DEBUG // If more then 2 crtcs this must rewriten!!!
+        printf("[FindDevice] Plane id %i crtc_id %i possible_crtcs %i possible CRTC %i type %s\n",
+            plane->plane_id, plane->crtc_id, plane->possible_crtcs, resources->crtcs[i],
+            (type == DRM_PLANE_TYPE_PRIMARY) ? "primary plane" :
+            (type == DRM_PLANE_TYPE_OVERLAY) ? "overlay plane" :
+            (type == DRM_PLANE_TYPE_CURSOR) ? "cursor plane" : "No plane type");
+#endif
+
+        // test pixel format and plane caps
+        for (k = 0; k < plane->count_formats; k++) {
+            if (encoder->possible_crtcs & plane->possible_crtcs) {
+                switch (plane->formats[k]) {
+#ifdef RASPI
+                    case DRM_FORMAT_ARGB8888:
+#else
+					case DRM_FORMAT_XRGB2101010:
+#endif
+                        if (!render->video_plane) {
+                            render->video_plane = plane->plane_id;
+                        }
+                        break;
+                    default:
+                        break;
+                }
+            }
+        }
+        drmModeFreePlane(plane);
+    }
+
+    drmModeFreePlaneResources(plane_res);
+
+    drmModeFreeEncoder(encoder);
+    drmModeFreeResources(resources);
+
+#ifdef DRM_DEBUG
+    printf("[FindDevice] DRM setup CRTC: %i video_plane: %i \n",
+        render->crtc_id, render->video_plane);
+#endif
+
+    // save actual modesetting
+    render->saved_crtc = drmModeGetCrtc(render->fd_drm, render->crtc_id);
+
+    return 0;
+}
+
+///
+/// Initialize video output module.
+///
+void VideoInitDrm()
+{
+    int i;
+
+
+    if (!(render = calloc(1, sizeof(*render)))) {
+        Fatal(_("video/DRM: out of memory\n"));
+        return;
+    }
+
+    if (FindDevice(render)){
+        Fatal(_( "VideoInit: FindDevice() failed\n"));
+    }
+
+    gbm.dev = gbm_create_device (render->fd_drm);
+    assert (gbm.dev != NULL);
+
+    PFNEGLGETPLATFORMDISPLAYEXTPROC get_platform_display = NULL;
+    get_platform_display =
+        (void *) eglGetProcAddress("eglGetPlatformDisplay");
+    assert(get_platform_display != NULL);
+
+    eglDisplay = get_platform_display(EGL_PLATFORM_GBM_KHR, gbm.dev, NULL);
+
+    assert (eglDisplay != NULL);
+//    return;
+
+    drmModeAtomicReqPtr ModeReq;
+    const uint32_t flags = DRM_MODE_ATOMIC_ALLOW_MODESET;
+    uint32_t modeID = 0;
+
+    if (drmModeCreatePropertyBlob(render->fd_drm, &render->mode, sizeof(render->mode), &modeID) != 0) {
+        fprintf(stderr, "Failed to create mode property.\n");
+        return;
+    }
+    if (!(ModeReq = drmModeAtomicAlloc())) {
+        fprintf(stderr, "cannot allocate atomic request (%d): %m\n", errno);
+        return;
+    }
+	printf("set CRTC %d of Connector %d aktiv\n",render->crtc_id,render->connector_id);
+    SetPropertyRequest(ModeReq, render->fd_drm, render->crtc_id,
+                        DRM_MODE_OBJECT_CRTC, "MODE_ID", modeID);
+    SetPropertyRequest(ModeReq, render->fd_drm, render->connector_id,
+                        DRM_MODE_OBJECT_CONNECTOR, "CRTC_ID", render->crtc_id);
+    SetPropertyRequest(ModeReq, render->fd_drm, render->crtc_id,
+                        DRM_MODE_OBJECT_CRTC, "ACTIVE", 1);
+
+    if (drmModeAtomicCommit(render->fd_drm, ModeReq, flags, NULL) != 0)
+        fprintf(stderr, "cannot set atomic mode (%d): %m\n", errno);
+
+    if (drmModeDestroyPropertyBlob(render->fd_drm, modeID) != 0)
+        fprintf(stderr, "cannot destroy property blob (%d): %m\n", errno);
+
+    drmModeAtomicFree(ModeReq);
+
+}
+
+void get_drm_aspect(int *num,int *den)
+{
+    *num = VideoWindowWidth;
+    *den = VideoWindowHeight;
+}
+
+struct gbm_bo *bo = NULL, *next_bo=NULL;
+struct drm_fb *fb;
+static int m_need_modeset = 0;
+static int old_color=-1,old_trc=-1;
+
+void InitBo(int bpp) {
+    // create the GBM and EGL surface
+    render->bpp = bpp;
+    gbm.surface = gbm_surface_create (gbm.dev, VideoWindowWidth,VideoWindowHeight,
+                                      bpp==10?GBM_FORMAT_XRGB2101010:GBM_FORMAT_ARGB8888,
+                                      GBM_BO_USE_SCANOUT|GBM_BO_USE_RENDERING);
+    assert(gbm.surface != NULL);
+    eglSurface = eglCreateWindowSurface (eglDisplay, eglConfig, gbm.surface, NULL);
+    assert(eglSurface != NULL);
+
+}
+
+static struct gbm_bo *previous_bo = NULL;
+static uint32_t previous_fb;
+
+static void drm_swap_buffers () {
+
+    uint32_t fb;
+
+    eglSwapBuffers (eglDisplay, eglSurface);
+    struct gbm_bo *bo = gbm_surface_lock_front_buffer (gbm.surface);
+#if 1
+    if (bo == NULL)
+        bo = gbm_surface_lock_front_buffer (gbm.surface);
+#endif
+    assert (bo != NULL);
+    uint32_t handle = gbm_bo_get_handle (bo).u32;
+    uint32_t pitch = gbm_bo_get_stride (bo);
+
+
+    drmModeAddFB (render->fd_drm, VideoWindowWidth,VideoWindowHeight,render->bpp==10? 30:24, 32, pitch, handle, &fb);
+//  drmModeSetCrtc (render->fd_drm, render->crtc_id, fb, 0, 0, &render->connector_id, 1, &render->mode);
+
+    if (m_need_modeset) {
+        drmModeAtomicReqPtr ModeReq;
+        const uint32_t flags = DRM_MODE_ATOMIC_ALLOW_MODESET;
+        uint32_t modeID = 0;
+
+        if (drmModeCreatePropertyBlob(render->fd_drm, &render->mode, sizeof(render->mode), &modeID) != 0) {
+            fprintf(stderr, "Failed to create mode property.\n");
+            return;
+        }
+        if (!(ModeReq = drmModeAtomicAlloc())) {
+            fprintf(stderr, "cannot allocate atomic request (%d): %m\n", errno);
+            return;
+        }
+
+        // Need to disable the CRTC in order to submit the HDR data....
+        SetPropertyRequest(ModeReq, render->fd_drm, render->crtc_id,
+                            DRM_MODE_OBJECT_CRTC, "ACTIVE", 0);
+        if (drmModeAtomicCommit(render->fd_drm, ModeReq, flags, NULL) != 0)
+            fprintf(stderr, "cannot set atomic mode (%d): %m\n", errno);
+        sleep(2);
+
+        SetPropertyRequest(ModeReq, render->fd_drm, render->connector_id,
+                            DRM_MODE_OBJECT_CONNECTOR, "Colorspace",old_color==AVCOL_PRI_BT2020?9:2 );
+        SetPropertyRequest(ModeReq, render->fd_drm, render->crtc_id,
+                            DRM_MODE_OBJECT_CRTC, "MODE_ID", modeID);
+        SetPropertyRequest(ModeReq, render->fd_drm, render->connector_id,
+                            DRM_MODE_OBJECT_CONNECTOR, "CRTC_ID", render->crtc_id);
+        SetPropertyRequest(ModeReq, render->fd_drm, render->crtc_id,
+                            DRM_MODE_OBJECT_CRTC, "ACTIVE", 1);
+
+        if (drmModeAtomicCommit(render->fd_drm, ModeReq, flags, NULL) != 0)
+            fprintf(stderr, "cannot set atomic mode (%d): %m\n", errno);
+
+        if (drmModeDestroyPropertyBlob(render->fd_drm, modeID) != 0)
+            fprintf(stderr, "cannot destroy prperty blob (%d): %m\n", errno);
+
+        drmModeAtomicFree(ModeReq);
+        m_need_modeset = 0;
+    }
+    drmModeSetCrtc (render->fd_drm, render->crtc_id, fb, 0, 0, &render->connector_id, 1, &render->mode);
+
+    if (previous_bo) {
+        drmModeRmFB (render->fd_drm, previous_fb);
+        gbm_surface_release_buffer (gbm.surface, previous_bo);
+    }
+    previous_bo = bo;
+    previous_fb = fb;
+
+}
+
+static void drm_clean_up () {
+    // set the previous crtc
+
+    if (!render)
+        return;
+    Debug(3,"drm clean up\n");
+
+	if (previous_bo) {
+        drmModeRmFB (render->fd_drm, previous_fb);
+        gbm_surface_release_buffer (gbm.surface, previous_bo);
+    }
+
+    drmModeSetCrtc (render->fd_drm, render->saved_crtc->crtc_id, render->saved_crtc->buffer_id,
+                    render->saved_crtc->x, render->saved_crtc->y, &render->connector_id, 1, &render->saved_crtc->mode);
+    drmModeFreeCrtc (render->saved_crtc);
+
+    if (render->hdr_blob_id)
+        drmModeDestroyPropertyBlob(render->fd_drm, render->hdr_blob_id);
+	render->hdr_blob_id = 0;
+
+    eglDestroySurface (eglDisplay, eglSurface);
+	EglCheck();
+    gbm_surface_destroy (gbm.surface);
+    eglDestroyContext (eglDisplay, eglContext);
+	EglCheck();
+	eglDestroyContext (eglDisplay, eglSharedContext);
+	EglCheck();
+	eglSharedContext = NULL;
+
+    eglTerminate (eglDisplay);
+	EglCheck();
+
+    gbm_device_destroy (gbm.dev);
+	drmDropMaster(render->fd_drm);
+    close (render->fd_drm);
+	eglDisplay = NULL;
+	free(render);
+
+}

drvapi_error_string.h

@@ -17,8 +17,6 @@
 #include <string.h>
 #include <stdlib.h>
 
-#ifdef	__cuda_cuda_h__                 // check to see if CUDA_H is included above
-
 // Error Code string definitions here
 typedef struct
 {
@@ -453,6 +451,4 @@ static inline const char *getCudaDrvErrorString(CUresult error_id)
         return (const char *)"CUDA_ERROR not found!";
 }
 
-#endif // __cuda_cuda_h__
-
 #endif

hdr.c

@@ -0,0 +1,492 @@
+#include <libavutil/mastering_display_metadata.h>
+
+/**
+ * struct hdr_metadata_infoframe - HDR Metadata Infoframe Data.
+ *
+ * HDR Metadata Infoframe as per CTA 861.G spec. This is expected
+ * to match exactly with the spec.
+ *
+ * Userspace is expected to pass the metadata information as per
+ * the format described in this structure.
+ */
+struct hdr_metadata_infoframe {
+    /**
+     * @eotf: Electro-Optical Transfer Function (EOTF)
+     * used in the stream.
+     */
+    __u8 eotf;
+    /**
+     * @metadata_type: Static_Metadata_Descriptor_ID.
+     */
+    __u8 metadata_type;
+    /**
+     * @display_primaries: Color Primaries of the Data.
+     * These are coded as unsigned 16-bit values in units of
+     * 0.00002, where 0x0000 represents zero and 0xC350
+     * represents 1.0000.
+     * @display_primaries.x: X cordinate of color primary.
+     * @display_primaries.y: Y cordinate of color primary.
+     */
+    struct {
+        __u16 x, y;
+        } display_primaries[3];
+    /**
+     * @white_point: White Point of Colorspace Data.
+     * These are coded as unsigned 16-bit values in units of
+     * 0.00002, where 0x0000 represents zero and 0xC350
+     * represents 1.0000.
+     * @white_point.x: X cordinate of whitepoint of color primary.
+     * @white_point.y: Y cordinate of whitepoint of color primary.
+     */
+    struct {
+        __u16 x, y;
+        } white_point;
+    /**
+     * @max_display_mastering_luminance: Max Mastering Display Luminance.
+     * This value is coded as an unsigned 16-bit value in units of 1 cd/m2,
+     * where 0x0001 represents 1 cd/m2 and 0xFFFF represents 65535 cd/m2.
+     */
+    __u16 max_display_mastering_luminance;
+    /**
+     * @min_display_mastering_luminance: Min Mastering Display Luminance.
+     * This value is coded as an unsigned 16-bit value in units of
+     * 0.0001 cd/m2, where 0x0001 represents 0.0001 cd/m2 and 0xFFFF
+     * represents 6.5535 cd/m2.
+     */
+    __u16 min_display_mastering_luminance;
+    /**
+     * @max_cll: Max Content Light Level.
+     * This value is coded as an unsigned 16-bit value in units of 1 cd/m2,
+     * where 0x0001 represents 1 cd/m2 and 0xFFFF represents 65535 cd/m2.
+     */
+    __u16 max_cll;
+    /**
+     * @max_fall: Max Frame Average Light Level.
+     * This value is coded as an unsigned 16-bit value in units of 1 cd/m2,
+     * where 0x0001 represents 1 cd/m2 and 0xFFFF represents 65535 cd/m2.
+     */
+    __u16 max_fall;
+};
+
+/**
+ * struct hdr_output_metadata - HDR output metadata
+ *
+ * Metadata Information to be passed from userspace
+ */
+struct hdr_output_metadata {
+    /**
+     * @metadata_type: Static_Metadata_Descriptor_ID.
+     */
+    __u32 metadata_type;
+    /**
+     * @hdmi_metadata_type1: HDR Metadata Infoframe.
+     */
+    union {
+        struct hdr_metadata_infoframe hdmi_metadata_type1;
+    };
+};
+
+
+
+enum hdr_metadata_eotf {
+    EOTF_TRADITIONAL_GAMMA_SDR,
+    EOTF_TRADITIONAL_GAMMA_HDR,
+    EOTF_ST2084,
+    EOTF_HLG,
+};
+
+
+enum metadata_id {
+    METADATA_TYPE1,
+};
+
+void
+weston_hdr_metadata(void *data,
+            uint16_t display_primary_r_x,
+            uint16_t display_primary_r_y,
+            uint16_t display_primary_g_x,
+            uint16_t display_primary_g_y,
+            uint16_t display_primary_b_x,
+            uint16_t display_primary_b_y,
+            uint16_t white_point_x,
+            uint16_t white_point_y,
+            uint16_t min_luminance,
+            uint16_t max_luminance,
+            uint16_t max_cll,
+            uint16_t max_fall,
+            enum hdr_metadata_eotf eotf)
+{
+    uint8_t *data8;
+    uint16_t *data16;
+
+    data8 = data;
+
+    *data8++ = eotf;
+    *data8++ = METADATA_TYPE1;
+
+    data16 = (void*)data8;
+
+    *data16++ = display_primary_r_x;
+    *data16++ = display_primary_r_y;
+    *data16++ = display_primary_g_x;
+    *data16++ = display_primary_g_y;
+    *data16++ = display_primary_b_x;
+    *data16++ = display_primary_b_y;
+    *data16++ = white_point_x;
+    *data16++ = white_point_y;
+
+    *data16++ = max_luminance;
+    *data16++ = min_luminance;
+    *data16++ = max_cll;
+    *data16++ = max_fall;
+}
+
+struct weston_vector {
+    float f[4];
+};
+
+struct weston_colorspace {
+    struct weston_vector r, g, b;
+    struct weston_vector whitepoint;
+    const char *name;
+    const char *whitepoint_name;
+};
+
+struct weston_colorspace hdr10;
+
+static const struct weston_colorspace bt470m = {
+    .r = {{ 0.670f, 0.330f, }},
+    .g = {{ 0.210f, 0.710f, }},
+    .b = {{ 0.140f, 0.080f, }},
+    .whitepoint = {{ 0.3101f, 0.3162f, }},
+    .name = "BT.470 M",
+    .whitepoint_name = "C",
+};
+
+static const struct weston_colorspace bt470bg = {
+    .r = {{ 0.640f, 0.330f, }},
+    .g = {{ 0.290f, 0.600f, }},
+    .b = {{ 0.150f, 0.060f, }},
+    .whitepoint = {{ 0.3127f, 0.3290f, }},
+    .name = "BT.470 B/G",
+    .whitepoint_name = "D65",
+};
+
+static const struct weston_colorspace smpte170m = {
+    .r = {{ 0.630f, 0.340f, }},
+    .g = {{ 0.310f, 0.595f, }},
+    .b = {{ 0.155f, 0.070f, }},
+    .whitepoint = {{ 0.3127f, 0.3290f, }},
+    .name = "SMPTE 170M",
+    .whitepoint_name = "D65",
+};
+
+static const struct weston_colorspace smpte240m = {
+    .r = {{ 0.630f, 0.340f, }},
+    .g = {{ 0.310f, 0.595f, }},
+    .b = {{ 0.155f, 0.070f, }},
+    .whitepoint = {{ 0.3127f, 0.3290f, }},
+    .name = "SMPTE 240M",
+    .whitepoint_name = "D65",
+};
+
+static const struct weston_colorspace bt709 = {
+    .r = {{ 0.640f, 0.330f, }},
+    .g = {{ 0.300f, 0.600f, }},
+    .b = {{ 0.150f, 0.060f, }},
+    .whitepoint = {{ 0.3127f, 0.3290f, }},
+    .name = "BT.709",
+    .whitepoint_name = "D65",
+};
+
+static const struct weston_colorspace bt2020 = {
+    .r = {{ 0.708f, 0.292f, }},
+    .g = {{ 0.170f, 0.797f, }},
+    .b = {{ 0.131f, 0.046f, }},
+    .whitepoint = {{ 0.3127f, 0.3290f, }},
+    .name = "BT.2020",
+    .whitepoint_name = "D65",
+};
+
+static const struct weston_colorspace srgb = {
+    .r = {{ 0.640f, 0.330f, }},
+    .g = {{ 0.300f, 0.600f, }},
+    .b = {{ 0.150f, 0.060f, }},
+    .whitepoint = {{ 0.3127f, 0.3290f, }},
+    .name = "sRGB",
+    .whitepoint_name = "D65",
+};
+
+static const struct weston_colorspace adobergb = {
+    .r = {{ 0.640f, 0.330f, }},
+    .g = {{ 0.210f, 0.710f, }},
+    .b = {{ 0.150f, 0.060f, }},
+    .whitepoint = {{ 0.3127f, 0.3290f, }},
+    .name = "AdobeRGB",
+    .whitepoint_name = "D65",
+};
+
+static const struct weston_colorspace dci_p3 = {
+    .r = {{ 0.680f, 0.320f, }},
+    .g = {{ 0.265f, 0.690f, }},
+    .b = {{ 0.150f, 0.060f, }},
+    .whitepoint = {{ 0.3127f, 0.3290f, }},
+    .name = "DCI-P3 D65",
+    .whitepoint_name = "D65",
+};
+
+static const struct weston_colorspace prophotorgb = {
+    .r = {{ 0.7347f, 0.2653f, }},
+    .g = {{ 0.1596f, 0.8404f, }},
+    .b = {{ 0.0366f, 0.0001f, }},
+    .whitepoint = {{ .3457, .3585 }},
+    .name = "ProPhoto RGB",
+    .whitepoint_name = "D50",
+};
+
+static const struct weston_colorspace ciergb = {
+    .r = {{ 0.7347f, 0.2653f, }},
+    .g = {{ 0.2738f, 0.7174f, }},
+    .b = {{ 0.1666f, 0.0089f, }},
+    .whitepoint = {{ 1.0f / 3.0f, 1.0f / 3.0f, }},
+    .name = "CIE RGB",
+    .whitepoint_name = "E",
+};
+
+static const struct weston_colorspace ciexyz = {
+    .r = {{ 1.0f, 0.0f, }},
+    .g = {{ 0.0f, 1.0f, }},
+    .b = {{ 0.0f, 0.0f, }},
+    .whitepoint = {{ 1.0f / 3.0f, 1.0f / 3.0f, }},
+    .name = "CIE XYZ",
+    .whitepoint_name = "E",
+};
+
+const struct weston_colorspace ap0 = {
+    .r = {{ 0.7347f,  0.2653f, }},
+    .g = {{ 0.0000f,  1.0000f, }},
+    .b = {{ 0.0001f, -0.0770f, }},
+    .whitepoint = {{ .32168f, .33767f, }},
+    .name = "ACES primaries #0",
+    .whitepoint_name = "D60",
+};
+
+const struct weston_colorspace ap1 = {
+    .r = {{ 0.713f, 0.393f, }},
+    .g = {{ 0.165f, 0.830f, }},
+    .b = {{ 0.128f, 0.044f, }},
+    .whitepoint = {{ 0.32168f, 0.33767f, }},
+    .name = "ACES primaries #1",
+    .whitepoint_name = "D60",
+};
+
+static const struct weston_colorspace * const colorspaces[] = {
+    &bt470m,
+    &bt470bg,
+    &smpte170m,
+    &smpte240m,
+    &bt709,
+    &bt2020,
+    &srgb,
+    &adobergb,
+    &dci_p3,
+    &prophotorgb,
+    &ciergb,
+    &ciexyz,
+    &ap0,
+    &ap1,
+};
+#define ARRAY_LENGTH(a) (sizeof(a) / sizeof(a)[0])
+const struct weston_colorspace *
+weston_colorspace_lookup(const char *name)
+{
+    unsigned i;
+
+    if (!name)
+        return NULL;
+
+    for (i = 0; i < ARRAY_LENGTH(colorspaces); i++) {
+        const struct weston_colorspace *c = colorspaces[i];
+
+        if (!strcmp(c->name, name))
+            return c;
+    }
+
+    return NULL;
+}
+
+static int cleanup=0;
+
+
+static uint16_t encode_xyy(float xyy)
+{
+    return xyy * 50000;
+}
+static AVMasteringDisplayMetadata md_save = {0};
+static AVContentLightMetadata ld_save = {0};
+static void set_hdr_metadata(int color,int trc, AVFrameSideData *sd1, AVFrameSideData *sd2)
+{
+  drmModeAtomicReqPtr ModeReq;
+    struct weston_colorspace *cs;
+    enum hdr_metadata_eotf eotf;
+    struct hdr_output_metadata data;
+    int ret,MaxCLL=1500,MaxFALL=400;
+    int max_lum=4000,min_lum=0050;
+    struct AVMasteringDisplayMetadata *md = NULL;
+    struct AVContentLightMetadata *ld = NULL;
+
+    if (render->hdr_metadata == -1) { // Metadata not supported
+		return;
+	}
+
+    // clean up FFMEPG stuff
+    if (trc == AVCOL_TRC_BT2020_10)
+        trc = AVCOL_TRC_ARIB_STD_B67;
+    if (trc == AVCOL_TRC_UNSPECIFIED)
+        trc = AVCOL_TRC_BT709;
+    if (color == AVCOL_PRI_UNSPECIFIED)
+        color = AVCOL_PRI_BT709;
+
+    if ((old_color == color && old_trc == trc && !sd1 && !sd2) || !render->hdr_metadata)
+        return;  // nothing to do
+
+    if (sd1)
+        md = sd1->data;
+
+    if (sd2)
+        ld = sd2->data;
+
+    if (md && !memcmp(md,&md_save,sizeof(md_save)))
+        if (ld && !memcmp(ld,&ld_save,sizeof(ld_save))) {
+            return;
+        }
+    else if (ld && !memcmp(ld,&ld_save,sizeof(ld_save))) {
+        return;
+    }
+
+    if (ld)
+        memcpy(&ld_save,ld,sizeof(ld_save));
+    if (md)
+        memcpy(&md_save,md,sizeof(md_save));
+
+    Debug(3,"Update HDR to TRC %d color %d\n",trc,color);
+
+    if (trc == AVCOL_TRC_BT2020_10)
+        trc = AVCOL_TRC_ARIB_STD_B67;
+
+    old_color = color;
+    old_trc = trc;
+
+    if (render->hdr_blob_id)
+        drmModeDestroyPropertyBlob(render->fd_drm, render->hdr_blob_id);
+
+    switch(trc) {
+        case AVCOL_TRC_BT709:                                   // 1
+        case AVCOL_TRC_UNSPECIFIED:                             // 2
+            eotf = EOTF_TRADITIONAL_GAMMA_SDR;
+            break;
+        case AVCOL_TRC_BT2020_10:                               // 14
+        case AVCOL_TRC_BT2020_12:
+        case AVCOL_TRC_ARIB_STD_B67:                            // 18 HLG
+            eotf = EOTF_HLG;
+            break;
+        case AVCOL_TRC_SMPTE2084:                               // 16
+            eotf = EOTF_ST2084;
+			break;
+        default:
+            eotf = EOTF_TRADITIONAL_GAMMA_SDR;
+            break;
+    }
+
+    switch (color) {
+        case AVCOL_PRI_BT709:                                   // 1
+        case AVCOL_PRI_UNSPECIFIED:                             // 2
+            cs = weston_colorspace_lookup("BT.709");
+            break;
+        case AVCOL_PRI_BT2020:                                  // 9
+            cs = weston_colorspace_lookup("BT.2020");
+            break;
+        case AVCOL_PRI_BT470BG:                                 // 5
+            cs = weston_colorspace_lookup("BT.470 B/G");        // BT.601
+            break;
+        default:
+            cs = weston_colorspace_lookup("BT.709");
+            break;
+    }
+
+    if (md) {       // we got Metadata
+        if (md->has_primaries) {
+            Debug(3,"Mastering Display Metadata,\n has_primaries:%d has_luminance:%d \n"
+                   "r(%5.4f,%5.4f) g(%5.4f,%5.4f) b(%5.4f %5.4f) wp(%5.4f, %5.4f) \n"
+                   "min_luminance=%f, max_luminance=%f\n",
+              md->has_primaries, md->has_luminance,
+              av_q2d(md->display_primaries[0][0]),
+              av_q2d(md->display_primaries[0][1]),
+              av_q2d(md->display_primaries[1][0]),
+              av_q2d(md->display_primaries[1][1]),
+              av_q2d(md->display_primaries[2][0]),
+              av_q2d(md->display_primaries[2][1]),
+              av_q2d(md->white_point[0]), av_q2d(md->white_point[1]),
+              av_q2d(md->min_luminance), av_q2d(md->max_luminance));
+
+            cs = &hdr10;
+            cs->r.f[0] = (float)md->display_primaries[0][0].num / (float)md->display_primaries[0][0].den;
+            cs->r.f[1] = (float)md->display_primaries[0][1].num / (float)md->display_primaries[0][1].den;
+            cs->g.f[0] = (float)md->display_primaries[1][0].num / (float)md->display_primaries[1][0].den;
+            cs->g.f[1] = (float)md->display_primaries[1][1].num / (float)md->display_primaries[1][1].den;
+            cs->b.f[0] = (float)md->display_primaries[2][0].num / (float)md->display_primaries[2][0].den;
+            cs->b.f[1] = (float)md->display_primaries[2][1].num / (float)md->display_primaries[2][1].den;
+            cs->whitepoint.f[0] = (float)md->white_point[0].num / (float)md->white_point[0].den;
+            cs->whitepoint.f[1] = (float)md->white_point[1].num / (float)md->white_point[1].den;
+        }
+        if (md->has_luminance) {
+            max_lum = av_q2d(md->max_luminance);
+            min_lum = av_q2d(md->min_luminance) * 10000 ;
+            printf("max_lum %d min_lum %d\n",max_lum,min_lum);
+        }
+    }
+    if (ld) {
+        Debug(3,"Has MaxCLL %d MaxFALL %d\n",ld->MaxCLL,ld->MaxFALL);
+        MaxCLL = ld->MaxCLL;
+        MaxFALL = ld->MaxFALL;
+    }
+    data.metadata_type = 7;   // ????????????????????????
+    weston_hdr_metadata(&data.hdmi_metadata_type1,
+                encode_xyy(cs->r.f[0]),
+                encode_xyy(cs->r.f[1]),
+                encode_xyy(cs->g.f[0]),
+                encode_xyy(cs->g.f[1]),
+                encode_xyy(cs->b.f[0]),
+                encode_xyy(cs->b.f[1]),
+                encode_xyy(cs->whitepoint.f[0]),
+                encode_xyy(cs->whitepoint.f[1]),
+                max_lum,        // max_display_mastering_luminance
+                min_lum,        // min_display_mastering_luminance
+                MaxCLL,         // Maximum Content Light Level (MaxCLL)
+                MaxFALL,        // Maximum Frame-Average Light Level (MaxFALL)
+                eotf);
+
+
+
+    ret = drmModeCreatePropertyBlob(render->fd_drm, &data, sizeof(data), &render->hdr_blob_id);
+    if (ret) {
+        printf("DRM: HDR metadata: failed blob create \n");
+		render->hdr_blob_id = 0;
+        return;
+    }
+
+    ret = drmModeConnectorSetProperty(render->fd_drm, render->connector_id,
+                      render->hdr_metadata, render->hdr_blob_id);
+    if (ret) {
+        printf("DRM: HDR metadata: failed property set %d\n",ret);
+
+        if (render->hdr_blob_id)
+            drmModeDestroyPropertyBlob(render->fd_drm, render->hdr_blob_id);
+		render->hdr_blob_id = 0;
+        return;
+    }
+    m_need_modeset = 1;
+
+    Debug(3,"DRM: HDR metadata: prop set\n");
+
+}

openglosd.h

@@ -103,14 +103,14 @@ class cOglGlyph:public cListObject
     struct tKerning
     {
       public:
-        tKerning(uint prevSym, GLfloat kerning = 0.0f) {
+        tKerning(FT_ULong prevSym, GLfloat kerning = 0.0f) {
             this->prevSym = prevSym;
             this->kerning = kerning;
         }
-        uint prevSym;
+        FT_ULong prevSym;
         GLfloat kerning;
     };
-    uint charCode;
+    FT_ULong charCode;
     int bearingLeft;
     int bearingTop;
     int width;
@@ -122,9 +122,9 @@ class cOglGlyph:public cListObject
     void LoadTexture(FT_BitmapGlyph ftGlyph);
 
   public:
-    cOglGlyph(uint charCode, FT_BitmapGlyph ftGlyph);
+    cOglGlyph(FT_ULong charCode, FT_BitmapGlyph ftGlyph);
     virtual ~ cOglGlyph();
-    uint CharCode(void)
+    FT_ULong CharCode(void)
     {
         return charCode;
     }
@@ -148,8 +148,8 @@ class cOglGlyph:public cListObject
     {
         return height;
     }
-    int GetKerningCache(uint prevSym);
-    void SetKerningCache(uint prevSym, int kerning);
+    int GetKerningCache(FT_ULong prevSym);
+    void SetKerningCache(FT_ULong prevSym, int kerning);
     void BindTexture(void);
 };
 
@@ -190,8 +190,8 @@ class cOglFont:public cListObject
     {
         return height;
     };
-    cOglGlyph *Glyph(uint charCode) const;
-    int Kerning(cOglGlyph * glyph, uint prevSym) const;
+    cOglGlyph *Glyph(FT_ULong charCode) const;
+    int Kerning(cOglGlyph * glyph, FT_ULong prevSym) const;
 };
 
 /****************************************************************************************

patches/HDR-for-LSPCON.patch

@@ -0,0 +1,312 @@
+diff --git a/drivers/gpu/drm/i915/display/intel_display_types.h b/drivers/gpu/drm/i915/display/intel_display_types.h
+index 8358152e403e..573ab6ea1a6e 100644
+--- a/drivers/gpu/drm/i915/display/intel_display_types.h
++++ b/drivers/gpu/drm/i915/display/intel_display_types.h
+@@ -1274,6 +1274,7 @@ struct intel_lspcon {
+ 	bool active;
+ 	enum drm_lspcon_mode mode;
+ 	enum lspcon_vendor vendor;
++	bool hdr_supported;
+ };
+ 
+ struct intel_digital_port {
+diff --git a/drivers/gpu/drm/i915/display/intel_lspcon.c b/drivers/gpu/drm/i915/display/intel_lspcon.c
+index f8f1308643a9..a1d0127b7f57 100644
+--- a/drivers/gpu/drm/i915/display/intel_lspcon.c
++++ b/drivers/gpu/drm/i915/display/intel_lspcon.c
+@@ -35,6 +35,8 @@
+ #define LSPCON_VENDOR_PARADE_OUI 0x001CF8
+ #define LSPCON_VENDOR_MCA_OUI 0x0060AD
+ 
++#define DPCD_MCA_LSPCON_HDR_STATUS	0x70003
++
+ /* AUX addresses to write MCA AVI IF */
+ #define LSPCON_MCA_AVI_IF_WRITE_OFFSET 0x5C0
+ #define LSPCON_MCA_AVI_IF_CTRL 0x5DF
+@@ -104,6 +106,31 @@ static bool lspcon_detect_vendor(struct intel_lspcon *lspcon)
+ 	return true;
+ }
+ 
++static bool lspcon_detect_hdr_capability(struct intel_lspcon *lspcon)
++{
++	struct intel_dp *dp = lspcon_to_intel_dp(lspcon);
++	u8 hdr_caps;
++	int ret;
++
++	/* Enable HDR for MCA based LSPCON devices */
++	if (lspcon->vendor == LSPCON_VENDOR_MCA)
++		ret = drm_dp_dpcd_read(&dp->aux, DPCD_MCA_LSPCON_HDR_STATUS,
++				       &hdr_caps, 1);
++	else
++		return false;
++
++	if (ret < 0) {
++		DRM_DEBUG_KMS("hdr capability detection failed\n");
++		lspcon->hdr_supported = false;
++		return false;
++	} else if (hdr_caps & 0x1) {
++		DRM_DEBUG_KMS("lspcon capable of HDR\n");
++		lspcon->hdr_supported = true;
++	}
++
++	return true;
++}
++
+ static enum drm_lspcon_mode lspcon_get_current_mode(struct intel_lspcon *lspcon)
+ {
+ 	enum drm_lspcon_mode current_mode;
+@@ -581,6 +608,11 @@ bool lspcon_init(struct intel_digital_port *intel_dig_port)
+ 		return false;
+ 	}
+ 
++	if (!lspcon_detect_hdr_capability(lspcon)) {
++		DRM_ERROR("LSPCON hdr detection failed\n");
++		return false;
++	}
++
+ 	connector->ycbcr_420_allowed = true;
+ 	lspcon->active = true;
+ 	DRM_DEBUG_KMS("Success: LSPCON init\n");
+-- 
+diff --git a/drivers/gpu/drm/i915/display/intel_hdmi.c b/drivers/gpu/drm/i915/display/intel_hdmi.c
+index b54ccbb5aad5..051e30ad80e7 100644
+--- a/drivers/gpu/drm/i915/display/intel_hdmi.c
++++ b/drivers/gpu/drm/i915/display/intel_hdmi.c
+@@ -576,6 +576,16 @@ static u32 hsw_infoframes_enabled(struct intel_encoder *encoder,
+ 	return val & mask;
+ }
+ 
++void lspcon_drm_write_infoframe(struct intel_encoder *encoder,
++				const struct intel_crtc_state *crtc_state,
++				unsigned int type,
++				const void *frame, ssize_t len)
++{
++	DRM_DEBUG_KMS("Update HDR metadata for lspcon\n");
++	/* It uses the legacy hsw implementation for the same */
++	hsw_write_infoframe(encoder, crtc_state, type, frame, len);
++}
++
+ static const u8 infoframe_type_to_idx[] = {
+ 	HDMI_PACKET_TYPE_GENERAL_CONTROL,
+ 	HDMI_PACKET_TYPE_GAMUT_METADATA,
+diff --git a/drivers/gpu/drm/i915/display/intel_lspcon.c b/drivers/gpu/drm/i915/display/intel_lspcon.c
+index a1d0127b7f57..51ad5f02e700 100644
+--- a/drivers/gpu/drm/i915/display/intel_lspcon.c
++++ b/drivers/gpu/drm/i915/display/intel_lspcon.c
+@@ -460,27 +460,41 @@ void lspcon_write_infoframe(struct intel_encoder *encoder,
+ 			    unsigned int type,
+ 			    const void *frame, ssize_t len)
+ {
+-	bool ret;
++	bool ret = true;
+ 	struct intel_dp *intel_dp = enc_to_intel_dp(&encoder->base);
+ 	struct intel_lspcon *lspcon = enc_to_intel_lspcon(&encoder->base);
+ 
+-	/* LSPCON only needs AVI IF */
+-	if (type != HDMI_INFOFRAME_TYPE_AVI)
++	if (!(type == HDMI_INFOFRAME_TYPE_AVI ||
++	      type == HDMI_PACKET_TYPE_GAMUT_METADATA))
+ 		return;
+ 
+-	if (lspcon->vendor == LSPCON_VENDOR_MCA)
+-		ret = _lspcon_write_avi_infoframe_mca(&intel_dp->aux,
+-						      frame, len);
+-	else
+-		ret = _lspcon_write_avi_infoframe_parade(&intel_dp->aux,
+-							 frame, len);
++	/*
++	 * Supporting HDR on MCA LSPCON
++	 * Todo: Add support for Parade later
++	 */
++	if (type == HDMI_PACKET_TYPE_GAMUT_METADATA &&
++	    lspcon->vendor != LSPCON_VENDOR_MCA)
++		return;
++
++	if (lspcon->vendor == LSPCON_VENDOR_MCA) {
++		if (type == HDMI_INFOFRAME_TYPE_AVI)
++			ret = _lspcon_write_avi_infoframe_mca(&intel_dp->aux,
++							      frame, len);
++		else if (type == HDMI_PACKET_TYPE_GAMUT_METADATA)
++			lspcon_drm_write_infoframe(encoder, crtc_state,
++						   HDMI_PACKET_TYPE_GAMUT_METADATA,
++						   frame, VIDEO_DIP_DATA_SIZE);
++	} else {
++		ret = _lspcon_write_avi_infoframe_parade(&intel_dp->aux, frame,
++							 len);
++	}
+ 
+ 	if (!ret) {
+-		DRM_ERROR("Failed to write AVI infoframes\n");
++		DRM_ERROR("Failed to write infoframes\n");
+ 		return;
+ 	}
+ 
+-	DRM_DEBUG_DRIVER("AVI infoframes updated successfully\n");
++	DRM_DEBUG_DRIVER("Infoframes updated successfully\n");
+ }
+ 
+ void lspcon_read_infoframe(struct intel_encoder *encoder,
+diff --git a/drivers/gpu/drm/i915/display/intel_lspcon.h b/drivers/gpu/drm/i915/display/intel_lspcon.h
+index 37cfddf8a9c5..65878904f672 100644
+--- a/drivers/gpu/drm/i915/display/intel_lspcon.h
++++ b/drivers/gpu/drm/i915/display/intel_lspcon.h
+@@ -35,4 +35,8 @@ u32 lspcon_infoframes_enabled(struct intel_encoder *encoder,
+ void lspcon_ycbcr420_config(struct drm_connector *connector,
+ 			    struct intel_crtc_state *crtc_state);
+ 
++void lspcon_drm_write_infoframe(struct intel_encoder *encoder,
++				const struct intel_crtc_state *crtc_state,
++				unsigned int type,
++				const void *frame, ssize_t len);
+ #endif /* __INTEL_LSPCON_H__ */
+-- 
+diff --git a/drivers/gpu/drm/i915/display/intel_lspcon.c b/drivers/gpu/drm/i915/display/intel_lspcon.c
+index 51ad5f02e700..c32452360eeb 100644
+--- a/drivers/gpu/drm/i915/display/intel_lspcon.c
++++ b/drivers/gpu/drm/i915/display/intel_lspcon.c
+@@ -627,6 +627,11 @@ bool lspcon_init(struct intel_digital_port *intel_dig_port)
+ 		return false;
+ 	}
+ 
++	if (lspcon->vendor == LSPCON_VENDOR_MCA && lspcon->hdr_supported)
++		drm_object_attach_property(&connector->base,
++					   connector->dev->mode_config.hdr_output_metadata_property,
++					   0);
++
+ 	connector->ycbcr_420_allowed = true;
+ 	lspcon->active = true;
+ 	DRM_DEBUG_KMS("Success: LSPCON init\n");
+-- 
+diff --git a/drivers/gpu/drm/drm_atomic_state_helper.c b/drivers/gpu/drm/drm_atomic_state_helper.c
+index d0a937fb0c56..e78b3a1626fd 100644
+--- a/drivers/gpu/drm/drm_atomic_state_helper.c
++++ b/drivers/gpu/drm/drm_atomic_state_helper.c
+@@ -416,6 +416,7 @@ __drm_atomic_helper_connector_duplicate_state(struct drm_connector *connector,
+ 
+ 	if (state->hdr_output_metadata)
+ 		drm_property_blob_get(state->hdr_output_metadata);
++	state->hdr_metadata_changed = false;
+ 
+ 	/* Don't copy over a writeback job, they are used only once */
+ 	state->writeback_job = NULL;
+diff --git a/drivers/gpu/drm/drm_atomic_uapi.c b/drivers/gpu/drm/drm_atomic_uapi.c
+index 0d466d3b0809..5beabcd42d30 100644
+--- a/drivers/gpu/drm/drm_atomic_uapi.c
++++ b/drivers/gpu/drm/drm_atomic_uapi.c
+@@ -734,6 +734,7 @@ static int drm_atomic_connector_set_property(struct drm_connector *connector,
+ 				val,
+ 				sizeof(struct hdr_output_metadata), -1,
+ 				&replaced);
++		state->hdr_metadata_changed |= replaced;
+ 		return ret;
+ 	} else if (property == config->aspect_ratio_property) {
+ 		state->picture_aspect_ratio = val;
+diff --git a/drivers/gpu/drm/i915/display/intel_ddi.c b/drivers/gpu/drm/i915/display/intel_ddi.c
+index 9ba794cb9b4f..dee3a593564c 100644
+--- a/drivers/gpu/drm/i915/display/intel_ddi.c
++++ b/drivers/gpu/drm/i915/display/intel_ddi.c
+@@ -3851,6 +3851,8 @@ static void intel_enable_ddi_dp(struct intel_encoder *encoder,
+ {
+ 	struct drm_i915_private *dev_priv = to_i915(encoder->base.dev);
+ 	struct intel_dp *intel_dp = enc_to_intel_dp(&encoder->base);
++	struct intel_lspcon *lspcon =
++				enc_to_intel_lspcon(&encoder->base);
+ 	enum port port = encoder->port;
+ 
+ 	if (port == PORT_A && INTEL_GEN(dev_priv) < 9)
+@@ -3860,6 +3862,12 @@ static void intel_enable_ddi_dp(struct intel_encoder *encoder,
+ 	intel_psr_enable(intel_dp, crtc_state);
+ 	intel_dp_vsc_enable(intel_dp, crtc_state, conn_state);
+ 	intel_dp_hdr_metadata_enable(intel_dp, crtc_state, conn_state);
++
++	/* Set the infoframe for NON modeset cases as well */
++	if (lspcon->active && lspcon->hdr_supported &&
++	    conn_state->hdr_metadata_changed)
++		intel_dp_setup_hdr_metadata_infoframe_sdp(intel_dp, crtc_state,
++							  conn_state);
+ 	intel_edp_drrs_enable(intel_dp, crtc_state);
+ 
+ 	if (crtc_state->has_audio)
+diff --git a/drivers/gpu/drm/i915/display/intel_dp.c b/drivers/gpu/drm/i915/display/intel_dp.c
+index 5eeafa45831a..cc616fd31d8b 100644
+--- a/drivers/gpu/drm/i915/display/intel_dp.c
++++ b/drivers/gpu/drm/i915/display/intel_dp.c
+@@ -4651,7 +4651,7 @@ intel_dp_setup_vsc_sdp(struct intel_dp *intel_dp,
+ 			crtc_state, DP_SDP_VSC, &vsc_sdp, sizeof(vsc_sdp));
+ }
+ 
+-static void
++void
+ intel_dp_setup_hdr_metadata_infoframe_sdp(struct intel_dp *intel_dp,
+ 					  const struct intel_crtc_state *crtc_state,
+ 					  const struct drm_connector_state *conn_state)
+diff --git a/drivers/gpu/drm/i915/display/intel_lspcon.h b/drivers/gpu/drm/i915/display/intel_lspcon.h
+index 65878904f672..3404cff8c337 100644
+--- a/drivers/gpu/drm/i915/display/intel_lspcon.h
++++ b/drivers/gpu/drm/i915/display/intel_lspcon.h
+@@ -14,6 +14,7 @@ struct intel_crtc_state;
+ struct intel_digital_port;
+ struct intel_encoder;
+ struct intel_lspcon;
++struct intel_dp;
+ 
+ bool lspcon_init(struct intel_digital_port *intel_dig_port);
+ void lspcon_resume(struct intel_lspcon *lspcon);
+@@ -39,4 +40,7 @@ void lspcon_drm_write_infoframe(struct intel_encoder *encoder,
+ 				const struct intel_crtc_state *crtc_state,
+ 				unsigned int type,
+ 				const void *frame, ssize_t len);
++void intel_dp_setup_hdr_metadata_infoframe_sdp(struct intel_dp *intel_dp,
++					       const struct intel_crtc_state *crtc_state,
++					       const struct drm_connector_state *conn_state);
+ #endif /* __INTEL_LSPCON_H__ */
+diff --git a/include/drm/drm_connector.h b/include/drm/drm_connector.h
+index 5f8c3389d46f..1f0b4fcf0bd3 100644
+--- a/include/drm/drm_connector.h
++++ b/include/drm/drm_connector.h
+@@ -661,6 +661,7 @@ struct drm_connector_state {
+ 	 * DRM blob property for HDR output metadata
+ 	 */
+ 	struct drm_property_blob *hdr_output_metadata;
++	u8 hdr_metadata_changed : 1;
+ };
+ 
+ /**
+-- 
+diff --git a/drivers/gpu/drm/i915/display/intel_lspcon.c b/drivers/gpu/drm/i915/display/intel_lspcon.c
+index c32452360eeb..8565bf73c4cd 100644
+--- a/drivers/gpu/drm/i915/display/intel_lspcon.c
++++ b/drivers/gpu/drm/i915/display/intel_lspcon.c
+@@ -505,6 +505,11 @@ void lspcon_read_infoframe(struct intel_encoder *encoder,
+ 	/* FIXME implement this */
+ }
+ 
++/* HDMI HDR Colorspace Spec Definitions */
++#define NORMAL_COLORIMETRY_MASK		0x3
++#define EXTENDED_COLORIMETRY_MASK	0x7
++#define HDMI_COLORIMETRY_BT2020_YCC	((3 << 0) | (6 << 2) | (0 << 5))
++
+ void lspcon_set_infoframes(struct intel_encoder *encoder,
+ 			   bool enable,
+ 			   const struct intel_crtc_state *crtc_state,
+@@ -549,6 +554,19 @@ void lspcon_set_infoframes(struct intel_encoder *encoder,
+ 					   HDMI_QUANTIZATION_RANGE_LIMITED :
+ 					   HDMI_QUANTIZATION_RANGE_FULL);
+ 
++	/*
++	 * Set BT2020 colorspace if driving HDR data
++	 * ToDo: Make this generic and expose all colorspaces for lspcon
++	 */
++	if (lspcon->active && conn_state->hdr_metadata_changed) {
++		frame.avi.colorimetry =
++				HDMI_COLORIMETRY_BT2020_YCC &
++				NORMAL_COLORIMETRY_MASK;
++		frame.avi.extended_colorimetry =
++				(HDMI_COLORIMETRY_BT2020_YCC >> 2) &
++				 EXTENDED_COLORIMETRY_MASK;
++	}
++
+ 	ret = hdmi_infoframe_pack(&frame, buf, sizeof(buf));
+ 	if (ret < 0) {
+ 		DRM_ERROR("Failed to pack AVI IF\n");
+-- 

patches/UHD-10Bit.patch

@@ -0,0 +1,38 @@
+diff --git a/drivers/gpu/drm/i915/display/intel_dp.c b/drivers/gpu/drm/i915/display/intel_dp.c
+index cc616fd31d8b..f2d1d7bd87d3 100644
+--- a/drivers/gpu/drm/i915/display/intel_dp.c
++++ b/drivers/gpu/drm/i915/display/intel_dp.c
+@@ -616,8 +616,10 @@ intel_dp_mode_valid(struct drm_connector *connector,
+ {
+ 	struct intel_dp *intel_dp = intel_attached_dp(connector);
+ 	struct intel_connector *intel_connector = to_intel_connector(connector);
++	struct intel_encoder *intel_encoder = intel_attached_encoder(connector);
+ 	struct drm_display_mode *fixed_mode = intel_connector->panel.fixed_mode;
+ 	struct drm_i915_private *dev_priv = to_i915(connector->dev);
++	struct intel_lspcon *lspcon = enc_to_intel_lspcon(&intel_encoder->base);
+ 	int target_clock = mode->clock;
+ 	int max_rate, mode_rate, max_lanes, max_link_clock;
+ 	int max_dotclk;
+@@ -639,6 +641,21 @@ intel_dp_mode_valid(struct drm_connector *connector,
+ 		target_clock = fixed_mode->clock;
+ 	}
+ 
++	/*
++	 * Reducing Blanking to incorporate DP and HDMI timing/link bandwidth
++	 * limitations for CEA modes (4k@60 at 10 bpp). DP can drive 17.28Gbs
++	 * while 4k modes (VIC97 etc) at 10 bpp required 17.8 Gbps. This will
++	 * cause mode to blank out. Reduced Htotal by shortening the back porch
++	 * and front porch within permissible limits.
++	 */
++	if (lspcon->active && lspcon->hdr_supported &&
++	    mode->clock > 570000) {
++		mode->clock = 570000;
++		mode->htotal -= 180;
++		mode->hsync_start -= 72;
++		mode->hsync_end -= 72;
++	}
++
+ 	max_link_clock = intel_dp_max_link_rate(intel_dp);
+ 	max_lanes = intel_dp_max_lane_count(intel_dp);
+ 
+-- 

patches/vdr-plugin-skinnopacity-osd.diff.txt

@@ -0,0 +1,14 @@
+--- helpers.c.orig	2019-11-19 20:02:37.851039110 +0100
++++ helpers.c	2019-11-19 20:02:03.733164221 +0100
+@@ -5,9 +5,9 @@
+ #include <vdr/skins.h>
+ 
+ cOsd *CreateOsd(int Left, int Top, int Width, int Height) {
+-    cOsd *osd = cOsdProvider::NewOsd(Left, Top);
++    cOsd *osd = cOsdProvider::NewOsd(cOsd::OsdLeft() + Left,cOsd::OsdTop() + Top);
+     if (osd) {
+-        tArea Area = { 0, 0, Width, Height,  32 };
++        tArea Area = { 0, 0, Width - 1, Height - 1,  32 };
+         if (osd->SetAreas(&Area, 1) == oeOk) {
+             return osd;
+         }

po/de_DE.po

@@ -7,7 +7,7 @@ msgid ""
 msgstr ""
 "Project-Id-Version: VDR \n"
 "Report-Msgid-Bugs-To: <see README>\n"
-"POT-Creation-Date: 2019-10-26 18:41+0200\n"
+"POT-Creation-Date: 2020-04-15 18:57+0200\n"
 "PO-Revision-Date: blabla\n"
 "Last-Translator: blabla\n"
 "Language-Team: blabla\n"
@@ -263,9 +263,6 @@ msgstr ""
 msgid "codec: can't allocate video codec context\n"
 msgstr ""
 
-msgid "VAAPI Refcounts invalid\n"
-msgstr ""
-
 msgid "codec: can't set option deint to video codec!\n"
 msgstr ""
 
@@ -306,24 +303,6 @@ msgstr ""
 msgid "codec/audio: decoded data smaller than encoded\n"
 msgstr ""
 
-msgid "codec/audio: resample setup error\n"
-msgstr ""
-
-msgid "codec/audio: overwrite resample\n"
-msgstr ""
-
-msgid "codec/audio: AvResample setup error\n"
-msgstr ""
-
-msgid "codec: latm\n"
-msgstr ""
-
-msgid "codec: error audio data\n"
-msgstr ""
-
-msgid "codec: error more than one frame data\n"
-msgstr ""
-
 msgid "codec/audio: can't setup resample\n"
 msgstr ""
 
@@ -471,18 +450,6 @@ msgstr "Schneide oben und unten ab (Pixel)"
 msgid "Cut left and right (pixel)"
 msgstr "Schneide links und rechts ab (Pixel)"
 
-msgid "Auto-crop"
-msgstr ""
-
-msgid "Autocrop interval (frames)"
-msgstr ""
-
-msgid "Autocrop delay (n * interval)"
-msgstr ""
-
-msgid "Autocrop tolerance (pixel)"
-msgstr ""
-
 msgid "Audio"
 msgstr "Audio"
 
@@ -642,7 +609,7 @@ msgid " Frames missed(%d) duped(%d) dropped(%d) total(%d)"
 msgstr " Frames verloren(%d) verdoppelt(%d) übersprungen(%d) Gesamt(%d)"
 
 #, c-format
-msgid " Frame Process time %2.2fms"
+msgid " Video %dx%d Color: %s Gamma: %s"
 msgstr ""
 
 msgid "pass-through disabled"
@@ -661,12 +628,6 @@ msgstr ""
 msgid "surround downmix disabled"
 msgstr ""
 
-msgid "auto-crop disabled and freezed"
-msgstr ""
-
-msgid "auto-crop enabled"
-msgstr ""
-
 #, c-format
 msgid "[softhddev]: hot key %d is not supported\n"
 msgstr ""
@@ -807,10 +768,6 @@ msgstr ""
 msgid "video/glx: no GLX support\n"
 msgstr ""
 
-#, c-format
-msgid "video/glx: glx version %d.%d\n"
-msgstr ""
-
 msgid "did not get FBconfig"
 msgstr ""
 
@@ -898,11 +855,10 @@ msgid "Failed rendering frame!\n"
 msgstr ""
 
 #, c-format
-msgid "video/vdpau: output buffer full, dropping frame (%d/%d)\n"
+msgid "video/cuvid: output buffer full, dropping frame (%d/%d)\n"
 msgstr ""
 
-#, c-format
-msgid "video/vdpau: pixel format %d not supported\n"
+msgid "Could not dynamically load CUDA\n"
 msgstr ""
 
 msgid "Kein Cuda device gefunden"
@@ -943,12 +899,6 @@ msgstr ""
 msgid "video/egl: can't create thread egl context\n"
 msgstr ""
 
-msgid "video: can't queue cancel video display thread\n"
-msgstr ""
-
-msgid "video: can't cancel video display thread\n"
-msgstr ""
-
 #, c-format
 msgid "video: repeated pict %d found, but not handled\n"
 msgstr ""

shaders.h

@@ -1,184 +1,14 @@
 // shader
+#define SHADER_LENGTH 10000
+
 #ifdef CUVID
-char vertex_osd[] = { "\
-#version 330\n\
-in vec2 vertex_position;\n\
-in vec2 vertex_texcoord0;\n\
-out vec2 texcoord0;\n\
-void main() {\n\
-gl_Position = vec4(vertex_position, 1.0, 1.0);\n\
-texcoord0 = vertex_texcoord0;\n\
-}\n" };
-
-char fragment_osd[] = { "\
-#version 330\n\
-#define texture1D texture\n\
-precision mediump float; \
-layout(location = 0) out vec4 out_color;\n\
-in vec2 texcoord0;\n\
-uniform sampler2D texture0;\n\
-void main() {\n\
-vec4 color; \n\
-color = vec4(texture(texture0, texcoord0));\n\
-out_color = color;\n\
-}\n" };
-
-char vertex[] = { "\
-#version 310 es\n\
-in vec2 vertex_position;\n\
-in vec2 vertex_texcoord0;\n\
-out vec2 texcoord0;\n\
-in vec2 vertex_texcoord1;\n\
-out vec2 texcoord1;\n\
-void main() {\n\
-gl_Position = vec4(vertex_position, 1.0, 1.0);\n\
-texcoord0 = vertex_texcoord0;\n\
-texcoord1 = vertex_texcoord1;\n\
-}\n" };
-
-char fragment[] = { "\
-#version 310 es\n\
-#define texture1D texture\n\
-#define texture3D texture\n\
-precision mediump float; \
-layout(location = 0) out vec4 out_color;\n\
-in vec2 texcoord0;\n\
-in vec2 texcoord1;\n\
-uniform mat3 colormatrix;\n\
-uniform vec3 colormatrix_c;\n\
-uniform sampler2D texture0;\n\
-uniform sampler2D texture1;\n\
-void main() {\n\
-vec4 color; // = vec4(0.0, 0.0, 0.0, 1.0);\n\
-color.r = 1.000000 * vec4(texture(texture0, texcoord0)).r;\n\
-color.gb = 1.000000 * vec4(texture(texture1, texcoord1)).rg;\n\
-// color conversion\n\
-color.rgb = mat3(colormatrix) * color.rgb  + colormatrix_c;\n\
-color.a = 1.0;\n\
-// color mapping\n\
-out_color = color;\n\
-}\n" };
-
-char fragment_bt2100[] = { "\
-#version 310 es\n \
-#define texture1D texture\n\
-#define texture3D texture\n\
-precision mediump float; \
-layout(location = 0) out vec4 out_color;\n\
-in vec2 texcoord0;\n\
-in vec2 texcoord1;\n\
-uniform mat3 colormatrix;\n\
-uniform vec3 colormatrix_c;\n\
-uniform mat3 cms_matrix;\n\
-uniform sampler2D texture0;\n\
-uniform sampler2D texture1;\n\
-//#define LUT_POS(x, lut_size) mix(0.5 / (lut_size), 1.0 - 0.5 / (lut_size), (x))\n\
-void main() {\n\
-vec4 color; // = vec4(0.0, 0.0, 0.0, 1.0);\n\
-color.r = 1.003906 * vec4(texture(texture0, texcoord0)).r;\n\
-color.gb = 1.003906 * vec4(texture(texture1, texcoord1)).rg;\n\
-// color conversion\n\
-color.rgb = mat3(colormatrix) * color.rgb  + colormatrix_c;\n\
-color.a = 1.0;\n\
-// color mapping\n\
-color.rgb = clamp(color.rgb, 0.0, 1.0);\n\
-color.rgb = pow(color.rgb, vec3(2.4));\n\
-color.rgb = cms_matrix * color.rgb;\n\
-color.rgb = clamp(color.rgb, 0.0, 1.0);\n\
-color.rgb = pow(color.rgb, vec3(1.0/2.4));\n\
-out_color = color;\n\
-}\n" };
-
+const char *gl_version = "#version 330";
 #else
-char vertex_osd[] = { "\
-\n\
-in vec2 vertex_position;\n\
-in vec2 vertex_texcoord0;\n\
-out vec2 texcoord0;\n\
-void main() {\n\
-gl_Position = vec4(vertex_position, 1.0, 1.0);\n\
-texcoord0 = vertex_texcoord0;\n\
-}\n" };
-
-char fragment_osd[] = { "\
-\n\
-#define texture1D texture\n\
-precision mediump float; \
-layout(location = 0) out vec4 out_color;\n\
-in vec2 texcoord0;\n\
-uniform sampler2D texture0;\n\
-void main() {\n\
-vec4 color; \n\
-color = vec4(texture(texture0, texcoord0));\n\
-out_color = color;\n\
-}\n" };
-
-char vertex[] = { "\
-\n\
-in vec2 vertex_position;\n\
-in vec2 vertex_texcoord0;\n\
-out vec2 texcoord0;\n\
-in vec2 vertex_texcoord1;\n\
-out vec2 texcoord1;\n\
-void main() {\n\
-gl_Position = vec4(vertex_position, 1.0, 1.0);\n\
-texcoord0 = vertex_texcoord0;\n\
-texcoord1 = vertex_texcoord1;\n\
-}\n" };
-
-char fragment[] = { "\
-\n\
-#define texture1D texture\n\
-#define texture3D texture\n\
-precision mediump float; \
-layout(location = 0) out vec4 out_color;\n\
-in vec2 texcoord0;\n\
-in vec2 texcoord1;\n\
-uniform mat3 colormatrix;\n\
-uniform vec3 colormatrix_c;\n\
-uniform sampler2D texture0;\n\
-uniform sampler2D texture1;\n\
-//#define LUT_POS(x, lut_size) mix(0.5 / (lut_size), 1.0 - 0.5 / (lut_size), (x))\n\
-void main() {\n\
-vec4 color; // = vec4(0.0, 0.0, 0.0, 1.0);\n\
-color.r = 1.000000 * vec4(texture(texture0, texcoord0)).r;\n\
-color.gb = 1.000000 * vec4(texture(texture1, texcoord1)).rg;\n\
-// color conversion\n\
-color.rgb = mat3(colormatrix) * color.rgb  + colormatrix_c;\n\
-color.a = 1.0;\n\
-// color mapping\n\
-out_color = color;\n\
-}\n" };
-
-char fragment_bt2100[] = { "\
-\n \
-#define texture1D texture\n\
-#define texture3D texture\n\
-precision mediump float; \
-layout(location = 0) out vec4 out_color;\n\
-in vec2 texcoord0;\n\
-in vec2 texcoord1;\n\
-uniform mat3 colormatrix;\n\
-uniform vec3 colormatrix_c;\n\
-uniform mat3 cms_matrix;\n\
-uniform sampler2D texture0;\n\
-uniform sampler2D texture1;\n\
-//#define LUT_POS(x, lut_size) mix(0.5 / (lut_size), 1.0 - 0.5 / (lut_size), (x))\n\
-void main() {\n\
-vec4 color; // = vec4(0.0, 0.0, 0.0, 1.0);\n\
-color.r = 1.003906 * vec4(texture(texture0, texcoord0)).r;\n\
-color.gb = 1.003906 * vec4(texture(texture1, texcoord1)).rg;\n\
-// color conversion\n\
-color.rgb = mat3(colormatrix) * color.rgb  + colormatrix_c;\n\
-color.a = 1.0;\n\
-// color mapping\n\
-color.rgb = clamp(color.rgb, 0.0, 1.0);\n\
-color.rgb = pow(color.rgb, vec3(2.4));\n\
-color.rgb = cms_matrix * color.rgb;\n\
-color.rgb = clamp(color.rgb, 0.0, 1.0);\n\
-color.rgb = pow(color.rgb, vec3(1.0/2.4));\n\
-out_color = color;\n\
-}\n" };
+#ifdef RASPI
+const char *gl_version = "#version 300 es";
+#else
+const char *gl_version = "#version 300 es ";
+#endif
 #endif
 
 /* Color conversion matrix: RGB = m * YUV + c
@@ -208,37 +38,49 @@ struct mp_mat
 // YUV input limited range (16-235 for luma, 16-240 for chroma)
 // ITU-R BT.601 (SD)
 struct mp_cmat yuv_bt601 = { {{1.164384, 1.164384, 1.164384},
-    {0.00000, -0.391762, 2.017232},
-    {1.596027, -0.812968, 0.000000}},
-{-0.874202, 0.531668, -1.085631}
+    						  {0.00000, -0.391762, 2.017232},
+    						  {1.596027, -0.812968, 0.000000}},
+							  {-0.874202, 0.531668, -1.085631}
 };
 
 // ITU-R BT.709 (HD)
 struct mp_cmat yuv_bt709 = { {{1.164384, 1.164384, 1.164384},
-    {0.00000, -0.213249, 2.112402},
-    {1.792741, -0.532909, 0.000000}},
-{-0.972945, 0.301483, -1.133402}
+    						  {0.00000, -0.213249, 2.112402},
+    						  {1.792741, -0.532909, 0.000000}},
+							  {-0.972945, 0.301483, -1.133402}
 };
 
 // ITU-R BT.2020 non-constant luminance system
 struct mp_cmat yuv_bt2020ncl = { {{1.164384, 1.164384, 1.164384},
-    {0.00000, -0.187326, 2.141772},
-    {1.678674, -0.650424, 0.000000}},
-{-0.915688, 0.347459, -1.148145}
+    							  {0.00000, -0.187326, 2.141772},
+    							  {1.678674, -0.650424, 0.000000}},
+								  {-0.915688, 0.347459, -1.148145}
 };
 
 // ITU-R BT.2020 constant luminance system
 struct mp_cmat yuv_bt2020cl = { {{0.0000, 1.164384, 0.000000},
-    {0.00000, 0.000000, 1.138393},
-    {1.138393, 0.000000, 0.000000}},
-{-0.571429, -0.073059, -0.571429}
+    							 {0.00000, 0.000000, 1.138393},
+    							 {1.138393, 0.000000, 0.000000}},
+							  	 {-0.571429, -0.073059, -0.571429}
 };
 
 float cms_matrix[3][3] = { {1.660497, -0.124547, -0.018154},
-{-0.587657, 1.132895, -0.100597},
-{-0.072840, -0.008348, 1.118751}
+						 {-0.587657, 1.132895, -0.100597},
+						 {-0.072840, -0.008348, 1.118751}
 };
 
+// Common constants for SMPTE ST.2084 (PQ)
+static const float PQ_M1 = 2610. / 4096 * 1. / 4,
+				   PQ_M2 = 2523. / 4096 * 128,
+				   PQ_C1 = 3424. / 4096, 
+				   PQ_C2 =    2413. / 4096 * 32, 
+				   PQ_C3 = 2392. / 4096 * 32;
+
+// Common constants for ARIB STD-B67 (HLG)
+static const float HLG_A = 0.17883277,
+				   HLG_B = 0.28466892, 
+				   HLG_C = 0.55991073;
+
 struct gl_vao_entry
 {
     // used for shader / glBindAttribLocation
@@ -275,15 +117,61 @@ static const struct gl_vao_entry vertex_vao[] = {
     {0}
 };
 
+#define GLSL(...)  pl_shader_append(__VA_ARGS__)
+#define GLSLV(...)  pl_shader_append_v(__VA_ARGS__)
+
+char sh[SHADER_LENGTH];
+char shv[SHADER_LENGTH];
+
+GL_init()
+{
+    sh[0] = 0;
+}
+
+GLV_init()
+{
+    shv[0] = 0;
+}
+
+pl_shader_append(const char *fmt, ...)
+{
+    char temp[1000];
+    va_list ap;
+
+    va_start(ap, fmt);
+    vsprintf(temp, fmt, ap);
+    va_end(ap);
+
+    if (strlen(sh) + strlen(temp) > SHADER_LENGTH)
+        Fatal(_("Shaderlenght fault\n"));
+    strcat(sh, temp);
+
+}
+
+pl_shader_append_v(const char *fmt, ...)
+{
+    char temp[1000];
+    va_list ap;
+
+    va_start(ap, fmt);
+    vsprintf(temp, fmt, ap);
+    va_end(ap);
+
+    if (strlen(shv) + strlen(temp) > SHADER_LENGTH)
+        Fatal(_("Shaderlenght fault\n"));
+    strcat(shv, temp);
+
+}
+
 static void compile_attach_shader(GLuint program, GLenum type, const char *source)
 {
     GLuint shader;
-    GLint status, log_length;
+    GLint status = 1234, log_length;
     char log[4000];
     GLsizei len;
 
     shader = glCreateShader(type);
-    glShaderSource(shader, 1, &source, NULL);
+    glShaderSource(shader, 1, (const GLchar **)&source, NULL);  // &buffer, NULL);
     glCompileShader(shader);
     status = 0;
     glGetShaderiv(shader, GL_COMPILE_STATUS, &status);
@@ -295,6 +183,7 @@ static void compile_attach_shader(GLuint program, GLenum type, const char *sourc
 
     glAttachShader(program, shader);
     glDeleteShader(shader);
+
 }
 
 static void link_shader(GLuint program)
@@ -314,14 +203,43 @@ static GLuint sc_generate_osd(GLuint gl_prog)
 
     Debug(3, "vor create osd\n");
     gl_prog = glCreateProgram();
+
+    GL_init();
+    GLSL("%s\n", gl_version);
+    GLSL("in vec2 vertex_position;\n");
+    GLSL("in vec2 vertex_texcoord0;\n");
+    GLSL("out vec2 texcoord0;\n");
+    GLSL("void main() {\n");
+    GLSL("gl_Position = vec4(vertex_position, 1.0, 1.0);\n");
+    GLSL("texcoord0 = vertex_texcoord0;\n");
+    GLSL("}\n");
+
     Debug(3, "vor compile vertex osd\n");
-    compile_attach_shader(gl_prog, GL_VERTEX_SHADER, vertex_osd);
+    compile_attach_shader(gl_prog, GL_VERTEX_SHADER, sh);   // vertex_osd);
+    GL_init();
+    GLSL("%s\n", gl_version);
+    GLSL("#define texture1D texture\n");
+    GLSL("precision mediump float; \n");
+    GLSL("layout(location = 0) out vec4 out_color;\n");
+    GLSL("in vec2 texcoord0;\n");
+    GLSL("uniform sampler2D texture0;\n");
+    GLSL("void main() {\n");
+    GLSL("vec4 color; \n");
+    GLSL("color = vec4(texture(texture0, texcoord0));\n");
+#ifdef GAMMA
+    GLSL("// delinearize gamma                     \n");
+    GLSL("color.rgb = clamp(color.rgb, 0.0, 1.0);  \n");    // delinearize gamma
+    GLSL("color.rgb = pow(color.rgb, vec3(2.4));   \n");
+#endif
+    GLSL("out_color = color;\n");
+    GLSL("}\n");
     Debug(3, "vor compile fragment osd \n");
-    compile_attach_shader(gl_prog, GL_FRAGMENT_SHADER, fragment_osd);
+    compile_attach_shader(gl_prog, GL_FRAGMENT_SHADER, sh); //fragment_osd);
     glBindAttribLocation(gl_prog, 0, "vertex_position");
     glBindAttribLocation(gl_prog, 1, "vertex_texcoord0");
 
     link_shader(gl_prog);
+
     return gl_prog;
 }
 
@@ -334,41 +252,135 @@ static GLuint sc_generate(GLuint gl_prog, enum AVColorSpace colorspace)
     float *m, *c, *cms;
     char *frag;
 
+    GL_init();
+    GLSL("%s\n", gl_version);
+    GLSL("in vec2 vertex_position;      \n");
+    GLSL("in vec2 vertex_texcoord0;     \n");
+    GLSL("out vec2 texcoord0;           \n");
+    GLSL("in vec2 vertex_texcoord1;     \n");
+    GLSL("out vec2 texcoord1;           \n");
+    if (Planes == 3) {
+        GLSL("in vec2 vertex_texcoord2; \n");
+        GLSL("out vec2 texcoord2;       \n");
+    }
+    GLSL("void main() {                 \n");
+    GLSL("gl_Position = vec4(vertex_position, 1.0, 1.0);\n");
+    GLSL("texcoord0 = vertex_texcoord0; \n");
+    GLSL("texcoord1 = vertex_texcoord1; \n");
+    if (Planes == 3) {
+        GLSL("texcoord2 = vertex_texcoord1; \n");   // texcoord1 ist hier richtig
+    }
+    GLSL("}                             \n");
+
+    Debug(3, "vor create\n");
+    gl_prog = glCreateProgram();
+    Debug(3, "vor compile vertex\n");
+//  printf("%s",sh);
+    compile_attach_shader(gl_prog, GL_VERTEX_SHADER, sh);
+
     switch (colorspace) {
         case AVCOL_SPC_RGB:
             m = &yuv_bt601.m[0][0];
             c = &yuv_bt601.c[0];
-            frag = fragment;
             Debug(3, "BT601 Colorspace used\n");
             break;
         case AVCOL_SPC_BT709:
         case AVCOL_SPC_UNSPECIFIED:    //  comes with UHD
             m = &yuv_bt709.m[0][0];
             c = &yuv_bt709.c[0];
-            frag = fragment;
             Debug(3, "BT709 Colorspace used\n");
             break;
         case AVCOL_SPC_BT2020_NCL:
             m = &yuv_bt2020ncl.m[0][0];
             c = &yuv_bt2020ncl.c[0];
             cms = &cms_matrix[0][0];
-            frag = fragment_bt2100;
             Debug(3, "BT2020NCL Colorspace used\n");
             break;
         default:                       // fallback
             m = &yuv_bt709.m[0][0];
             c = &yuv_bt709.c[0];
-            frag = fragment;
             Debug(3, "default BT709 Colorspace used  %d\n", colorspace);
             break;
     }
 
-    Debug(3, "vor create\n");
-    gl_prog = glCreateProgram();
-    Debug(3, "vor compile vertex\n");
-    compile_attach_shader(gl_prog, GL_VERTEX_SHADER, vertex);
+    GL_init();
+
+    GLSL("%s\n", gl_version);
+    GLSL("precision mediump float;    \n");
+    GLSL("layout(location = 0) out vec4 out_color;\n");
+    GLSL("in vec2 texcoord0;          \n");
+    GLSL("in vec2 texcoord1;          \n");
+    if (Planes == 3)
+        GLSL("in vec2 texcoord2;      \n");
+    GLSL("uniform mat3 colormatrix;   \n");
+    GLSL("uniform vec3 colormatrix_c; \n");
+    if (colorspace == AVCOL_SPC_BT2020_NCL)
+        GLSL("uniform mat3 cms_matrix;\n");
+    GLSL("uniform sampler2D texture0; \n");
+    GLSL("uniform sampler2D texture1; \n");
+    if (Planes == 3)
+        GLSL("uniform sampler2D texture2; \n");
+    GLSL("void main() {               \n");
+    GLSL("vec4 color;                 \n");
+
+    if (colorspace == AVCOL_SPC_BT2020_NCL) {
+        GLSL("color.r = 1.003906 * vec4(texture(texture0, texcoord0)).r;     \n");
+        if (Planes == 3) {
+            GLSL("color.g = 1.003906 * vec4(texture(texture1, texcoord1)).r;  \n");
+            GLSL("color.b = 1.003906 * vec4(texture(texture2, texcoord2)).r;  \n");
+        } else {
+            GLSL("color.gb = 1.003906 * vec4(texture(texture1, texcoord1)).rg;\n");
+        }
+        GLSL("// color conversion\n");
+        GLSL("color.rgb = mat3(colormatrix) * color.rgb  + colormatrix_c;     \n");
+        GLSL("color.a = 1.0;                             \n");
+
+        GLSL("// pl_shader_linearize                     \n");
+        GLSL("color.rgb = max(color.rgb, 0.0);           \n");
+//      GLSL("color.rgb = clamp(color.rgb, 0.0, 1.0);    \n");
+//      GLSL("color.rgb = pow(color.rgb, vec3(2.4));     \n");
+//      GLSL("color.rgb = mix(vec3(4.0) * color.rgb * color.rgb,exp((color.rgb - vec3(%f)) * vec3(1.0/%f)) + vec3(%f),bvec3(lessThan(vec3(0.5), color.rgb)));\n",HLG_C, HLG_A, HLG_B);
+        GLSL("color.rgb = mix(vec3(4.0) * color.rgb * color.rgb,exp((color.rgb - vec3(0.55991073)) * vec3(1.0/0.17883277)) + vec3(0.28466892), bvec3(lessThan(vec3(0.5), color.rgb)));\n");
+        GLSL("// color mapping                           \n");
+        GLSL("color.rgb = cms_matrix * color.rgb;        \n");
+#ifndef GAMMA
+        GLSL("// pl_shader_delinearize                   \n");
+        GLSL("color.rgb = max(color.rgb, 0.0);           \n");
+//      GLSL("color.rgb = clamp(color.rgb, 0.0, 1.0);    \n");
+//      GLSL("color.rgb = pow(color.rgb, vec3(1.0/2.4)); \n");
+        GLSL("color.rgb = mix(vec3(0.5) * sqrt(color.rgb), vec3(0.17883277) * log(color.rgb - vec3(0.28466892)) + vec3(0.55991073), bvec3(lessThan(vec3(1.0), color.rgb))); \n");
+
+#endif
+        GLSL("out_color = color;                         \n");
+        GLSL("} \n");
+    } else {
+
+        GLSL("color.r =  1.000000 * vec4(texture(texture0, texcoord0)).r;  \n");
+        if (Planes == 3) {
+            GLSL("color.g = 1.000000 * vec4(texture(texture1, texcoord1)).r;\n");
+            GLSL("color.b = 1.000000 * vec4(texture(texture2, texcoord2)).r;\n");
+        } else {
+            GLSL("color.gb = 1.000000 * vec4(texture(texture1, texcoord1)).rg; \n");
+        }
+        GLSL("// color conversion         \n");
+        GLSL("color.rgb = mat3(colormatrix) * color.rgb  + colormatrix_c;  \n");
+        GLSL("color.a = 1.0;              \n");
+
+        GLSL("// linearize gamma                     \n");
+        GLSL("color.rgb = clamp(color.rgb, 0.0, 1.0);  \n");    // linearize gamma
+        GLSL("color.rgb = pow(color.rgb, vec3(2.4));   \n");
+#ifndef GAMMA
+        GLSL("// delinearize gamma to sRGB               \n");
+        GLSL("color.rgb = max(color.rgb, 0.0);         \n");
+        GLSL("color.rgb = mix(color.rgb * vec3(12.92), vec3(1.055) * pow(color.rgb, vec3(1.0/2.4)) - vec3(0.055), bvec3(lessThanEqual(vec3(0.0031308), color.rgb))); \n");
+#endif
+        GLSL("// color mapping            \n");
+        GLSL("out_color = color;          \n");
+        GLSL("} \n");
+    }
+//printf(">%s<",sh);
     Debug(3, "vor compile fragment\n");
-    compile_attach_shader(gl_prog, GL_FRAGMENT_SHADER, frag);
+    compile_attach_shader(gl_prog, GL_FRAGMENT_SHADER, sh);
     glBindAttribLocation(gl_prog, 0, "vertex_position");
 
     for (n = 0; n < 6; n++) {

shaders.txt

@@ -1,91 +0,0 @@
-Pro 7 1080i
-
-[vo/opengl] [  1] color.r = 1.000000 * vec4(texture(texture0, texcoord0)).r;
-[vo/opengl] [  2] color.gb = 1.000000 * vec4(texture(texture1, texcoord1)).rg;
-[vo/opengl] [  3] // color conversion
-[vo/opengl] [  4] color.rgb = mat3(colormatrix) * color.rgb + colormatrix_c;
-[vo/opengl] [  5] color.a = 1.0;
-[vo/opengl] [  6] // color mapping
-
-UHD 10 Bit
-[vo/opengl] [  1] color.r = 1.003906 * vec4(texture(texture0, texcoord0)).r;
-[vo/opengl] [  2] color.gb = 1.003906 * vec4(texture(texture1, texcoord1)).rg;
-[vo/opengl] [  3] // color conversion
-[vo/opengl] [  4] color.rgb = mat3(colormatrix) * color.rgb + colormatrix_c;
-[vo/opengl] [  5] color.a = 1.0;
-[vo/opengl] [  6] // color mapping
-
-
-HEVC 8 Bit
-[vo/opengl] [  1] color.r = 1.003906 * vec4(texture(texture0, texcoord0)).r;
-[vo/opengl] [  2] color.gb = 1.003906 * vec4(texture(texture1, texcoord1)).rg;
-[vo/opengl] [  3] // color conversion
-[vo/opengl] [  4] color.rgb = mat3(colormatrix) * color.rgb + colormatrix_c;
-[vo/opengl] [  5] color.a = 1.0;
-[vo/opengl] [  6] // color mapping
-
-ZDF 720p
-[vo/opengl] [  1] color.r = 1.000000 * vec4(texture(texture0, texcoord0)).r;
-[vo/opengl] [  2] color.gb = 1.000000 * vec4(texture(texture1, texcoord1)).rg;
-[vo/opengl] [  3] // color conversion
-[vo/opengl] [  4] color.rgb = mat3(colormatrix) * color.rgb + colormatrix_c;
-[vo/opengl] [  5] color.a = 1.0;
-[vo/opengl] [  6] // color mapping
-
-VERTEX
-#version 330
-in vec2 vertex_position;
-in vec2 vertex_texcoord0;
-out vec2 texcoord0;
-in vec2 vertex_texcoord1;
-out vec2 texcoord1;
-in vec2 vertex_texcoord2;
-out vec2 texcoord2;
-in vec2 vertex_texcoord3;
-out vec2 texcoord3;
-in vec2 vertex_texcoord4;
-out vec2 texcoord4;
-in vec2 vertex_texcoord5;
-out vec2 texcoord5;
-void main() {
-gl_Position = vec4(vertex_position, 1.0, 1.0);
-texcoord0 = vertex_texcoord0;
-texcoord1 = vertex_texcoord1;
-texcoord2 = vertex_texcoord2;
-texcoord3 = vertex_texcoord3;
-texcoord4 = vertex_texcoord4;
-texcoord5 = vertex_texcoord5;
-}
-
-FRAGMENT
-#version 330
-#define texture1D texture
-#define texture3D texture
-out vec4 out_color;
-in vec2 texcoord0;
-in vec2 texcoord1;
-in vec2 texcoord2;
-in vec2 texcoord3;
-in vec2 texcoord4;
-in vec2 texcoord5;
-uniform mat3 colormatrix;
-uniform vec3 colormatrix_c;
-uniform sampler2D texture0;
-uniform vec2 texture_size0;
-uniform mat2 texture_rot0;
-uniform vec2 pixel_size0;
-uniform sampler2D texture1;
-uniform vec2 texture_size1;
-uniform mat2 texture_rot1;
-uniform vec2 pixel_size1;
-#define LUT_POS(x, lut_size) mix(0.5 / (lut_size), 1.0 - 0.5 / (lut_size), (x))
-void main() {
-vec4 color = vec4(0.0, 0.0, 0.0, 1.0);
-color.r = 1.000000 * vec4(texture(texture0, texcoord0)).r;
-color.gb = 1.000000 * vec4(texture(texture1, texcoord1)).rg;
-// color conversion
-color.rgb = mat3(colormatrix) * color.rgb + colormatrix_c;
-color.a = 1.0;
-// color mapping
-out_color = color;
-}

shaders/KrigBilateral.glsl

@@ -0,0 +1,222 @@
+// KrigBilateral by Shiandow
+//
+// This library is free software; you can redistribute it and/or
+// modify it under the terms of the GNU Lesser General Public
+// License as published by the Free Software Foundation; either
+// version 3.0 of the License, or (at your option) any later version.
+// 
+// This library 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
+// Lesser General Public License for more details.
+// 
+// You should have received a copy of the GNU Lesser General Public
+// License along with this library.
+
+//!HOOK CHROMA
+//!BIND HOOKED
+//!BIND LUMA
+//!SAVE LOWRES_Y
+//!WIDTH LUMA.w
+//!WHEN CHROMA.w LUMA.w <
+//!DESC KrigBilateral Downscaling Y pass 1
+
+#define offset      vec2(0,0)
+
+#define axis 1
+
+#define Kernel(x)   dot(vec3(0.42659, -0.49656, 0.076849), cos(vec3(0, 1, 2) * acos(-1.) * (x + 1.)))
+
+vec4 hook() {
+    // Calculate bounds
+    float low  = ceil((LUMA_pos - CHROMA_pt) * LUMA_size - offset - 0.5)[axis];
+    float high = floor((LUMA_pos + CHROMA_pt) * LUMA_size - offset - 0.5)[axis];
+
+    float W = 0.0;
+    vec4 avg = vec4(0);
+    vec2 pos = LUMA_pos;
+
+    for (float k = low; k <= high; k++) {
+        pos[axis] = LUMA_pt[axis] * (k - offset[axis] + 0.5);
+        float rel = (pos[axis] - LUMA_pos[axis])*CHROMA_size[axis];
+        float w = Kernel(rel);
+
+        vec4 y = textureGrad(LUMA_raw, pos, vec2(0.0), vec2(0.0)).xxxx * LUMA_mul;
+        y.y *= y.y;
+        avg += w * y;
+        W += w;
+    }
+    avg /= W;
+    avg.y = abs(avg.y - pow(avg.x, 2.0));
+    return avg;
+}
+
+//!HOOK CHROMA
+//!BIND HOOKED
+//!BIND LOWRES_Y
+//!SAVE LOWRES_Y
+//!WHEN CHROMA.w LUMA.w <
+//!DESC KrigBilateral Downscaling Y pass 2
+
+#define offset      vec2(0,0)
+
+#define axis 0
+
+#define Kernel(x)   dot(vec3(0.42659, -0.49656, 0.076849), cos(vec3(0, 1, 2) * acos(-1.) * (x + 1.)))
+
+vec4 hook() {
+    // Calculate bounds
+    float low  = ceil((LOWRES_Y_pos - CHROMA_pt) * LOWRES_Y_size - offset - 0.5)[axis];
+    float high = floor((LOWRES_Y_pos + CHROMA_pt) * LOWRES_Y_size - offset - 0.5)[axis];
+
+    float W = 0.0;
+    vec4 avg = vec4(0);
+    vec2 pos = LOWRES_Y_pos;
+
+    for (float k = low; k <= high; k++) {
+        pos[axis] = LOWRES_Y_pt[axis] * (k - offset[axis] + 0.5);
+        float rel = (pos[axis] - LOWRES_Y_pos[axis])*CHROMA_size[axis];
+        float w = Kernel(rel);
+
+        vec4 y = textureGrad(LOWRES_Y_raw, pos, vec2(0.0), vec2(0.0)).xxxx * LOWRES_Y_mul;
+        y.y *= y.y;
+        avg += w * y;
+        W += w;
+    }
+    avg /= W;
+    avg.y = abs(avg.y - pow(avg.x, 2.0)) + LOWRES_Y_texOff(0).y;
+    return avg;
+}
+
+//!HOOK CHROMA
+//!BIND HOOKED
+//!BIND LUMA
+//!BIND LOWRES_Y
+//!WIDTH LUMA.w
+//!HEIGHT LUMA.h
+//!WHEN CHROMA.w LUMA.w <
+//!OFFSET ALIGN
+//!DESC KrigBilateral Upscaling UV
+
+// -- Convenience --
+#define sqr(x)   dot(x,x)
+#define bitnoise 1.0/(2.0*255.0)
+#define noise    0.05//5.0*bitnoise
+#define chromaOffset vec2(0.0, 0.0)
+
+// -- Window Size --
+#define taps 3
+#define even (float(taps) - 2.0 * floor(float(taps) / 2.0) == 0.0)
+#define minX int(1.0-ceil(float(taps)/2.0))
+#define maxX int(floor(float(taps)/2.0))
+
+#define Kernel(x) (cos(acos(-1.0)*(x)/float(taps))) // Hann kernel
+
+// -- Input processing --
+#define GetY(coord)  LOWRES_Y_tex(LOWRES_Y_pt*(pos+coord+vec2(0.5))).xy
+#define GetUV(coord) CHROMA_tex(CHROMA_pt*(pos+coord+vec2(0.5))).xy
+
+#define N (taps*taps - 1)
+
+#define M(i,j) Mx[min(i,j)*N + max(i,j) - min(i,j)*(min(i,j)+1)/2]
+
+#define C(i,j) (inversesqrt(1.0 + (X[i].y + X[j].y)/localVar) * exp(-0.5*(sqr(X[i].x - X[j].x)/(localVar + X[i].y + X[j].y) + sqr((coords[i] - coords[j])/radius))) + (X[i].x - y) * (X[j].x - y) / localVar)
+#define c(i)   (inversesqrt(1.0 + X[i].y/localVar) * exp(-0.5*(sqr(X[i].x - y)/(localVar + X[i].y) + sqr((coords[i] - offset)/radius))))
+
+vec4 hook() {
+    vec2 pos = CHROMA_pos * HOOKED_size - chromaOffset - vec2(0.5);
+    vec2 offset = pos - (even ? floor(pos) : round(pos));
+    pos -= offset;
+
+    vec2 coords[N+1];
+    vec4 X[N+1];
+    float y = LUMA_texOff(0).x;
+    vec4 total = vec4(0);
+
+    coords[0] = vec2(-1,-1); coords[1] = vec2(-1, 0); coords[2] = vec2(-1, 1);
+    coords[3] = vec2( 0,-1); coords[4] = vec2( 0, 1); coords[5] = vec2( 1,-1);
+    coords[6] = vec2( 1, 0); coords[7] = vec2( 1, 1); coords[8] = vec2( 0, 0);
+
+    for (int i=0; i<N+1; i++) {
+        X[i] = vec4(GetY(coords[i]), GetUV(coords[i]));
+        vec2 w = clamp(1.5 - abs(coords[i] - offset), 0.0, 1.0);
+        total += w.x*w.y*vec4(X[i].x, pow(X[i].x, 2.0), X[i].y, 1.0);
+    }
+    total.xyz /= total.w;
+    float localVar = sqr(noise) + abs(total.y - pow(total.x, 2.0)) + total.z;
+    float radius = 1.0;
+
+    float Mx[N*(N+1)/2];
+    float b[N];
+    vec4 interp = X[N];
+
+    b[0] = c(0) - c(N) - C(0,N) + C(N,N); M(0, 0) = C(0,0) - C(0,N) - C(0,N) + C(N,N); M(0, 1) = C(0,1) - C(1,N) - C(0,N) + C(N,N); M(0, 2) = C(0,2) - C(2,N) - C(0,N) + C(N,N); M(0, 3) = C(0,3) - C(3,N) - C(0,N) + C(N,N); M(0, 4) = C(0,4) - C(4,N) - C(0,N) + C(N,N); M(0, 5) = C(0,5) - C(5,N) - C(0,N) + C(N,N); M(0, 6) = C(0,6) - C(6,N) - C(0,N) + C(N,N); M(0, 7) = C(0,7) - C(7,N) - C(0,N) + C(N,N);
+    b[1] = c(1) - c(N) - C(1,N) + C(N,N); M(1, 1) = C(1,1) - C(1,N) - C(1,N) + C(N,N); M(1, 2) = C(1,2) - C(2,N) - C(1,N) + C(N,N); M(1, 3) = C(1,3) - C(3,N) - C(1,N) + C(N,N); M(1, 4) = C(1,4) - C(4,N) - C(1,N) + C(N,N); M(1, 5) = C(1,5) - C(5,N) - C(1,N) + C(N,N); M(1, 6) = C(1,6) - C(6,N) - C(1,N) + C(N,N); M(1, 7) = C(1,7) - C(7,N) - C(1,N) + C(N,N);
+    b[2] = c(2) - c(N) - C(2,N) + C(N,N); M(2, 2) = C(2,2) - C(2,N) - C(2,N) + C(N,N); M(2, 3) = C(2,3) - C(3,N) - C(2,N) + C(N,N); M(2, 4) = C(2,4) - C(4,N) - C(2,N) + C(N,N); M(2, 5) = C(2,5) - C(5,N) - C(2,N) + C(N,N); M(2, 6) = C(2,6) - C(6,N) - C(2,N) + C(N,N); M(2, 7) = C(2,7) - C(7,N) - C(2,N) + C(N,N);
+    b[3] = c(3) - c(N) - C(3,N) + C(N,N); M(3, 3) = C(3,3) - C(3,N) - C(3,N) + C(N,N); M(3, 4) = C(3,4) - C(4,N) - C(3,N) + C(N,N); M(3, 5) = C(3,5) - C(5,N) - C(3,N) + C(N,N); M(3, 6) = C(3,6) - C(6,N) - C(3,N) + C(N,N); M(3, 7) = C(3,7) - C(7,N) - C(3,N) + C(N,N);
+    b[4] = c(4) - c(N) - C(4,N) + C(N,N); M(4, 4) = C(4,4) - C(4,N) - C(4,N) + C(N,N); M(4, 5) = C(4,5) - C(5,N) - C(4,N) + C(N,N); M(4, 6) = C(4,6) - C(6,N) - C(4,N) + C(N,N); M(4, 7) = C(4,7) - C(7,N) - C(4,N) + C(N,N);
+    b[5] = c(5) - c(N) - C(5,N) + C(N,N); M(5, 5) = C(5,5) - C(5,N) - C(5,N) + C(N,N); M(5, 6) = C(5,6) - C(6,N) - C(5,N) + C(N,N); M(5, 7) = C(5,7) - C(7,N) - C(5,N) + C(N,N);
+    b[6] = c(6) - c(N) - C(6,N) + C(N,N); M(6, 6) = C(6,6) - C(6,N) - C(6,N) + C(N,N); M(6, 7) = C(6,7) - C(7,N) - C(6,N) + C(N,N);
+    b[7] = c(7) - c(N) - C(7,N) + C(N,N); M(7, 7) = C(7,7) - C(7,N) - C(7,N) + C(N,N);
+
+    b[1] -= b[0] * M(1, 0) / M(0, 0); M(1, 1) -= M(0, 1) * M(1, 0) / M(0, 0); M(1, 2) -= M(0, 2) * M(1, 0) / M(0, 0); M(1, 3) -= M(0, 3) * M(1, 0) / M(0, 0); M(1, 4) -= M(0, 4) * M(1, 0) / M(0, 0); M(1, 5) -= M(0, 5) * M(1, 0) / M(0, 0); M(1, 6) -= M(0, 6) * M(1, 0) / M(0, 0); M(1, 7) -= M(0, 7) * M(1, 0) / M(0, 0);
+    b[2] -= b[0] * M(2, 0) / M(0, 0); M(2, 2) -= M(0, 2) * M(2, 0) / M(0, 0); M(2, 3) -= M(0, 3) * M(2, 0) / M(0, 0); M(2, 4) -= M(0, 4) * M(2, 0) / M(0, 0); M(2, 5) -= M(0, 5) * M(2, 0) / M(0, 0); M(2, 6) -= M(0, 6) * M(2, 0) / M(0, 0); M(2, 7) -= M(0, 7) * M(2, 0) / M(0, 0);
+    b[3] -= b[0] * M(3, 0) / M(0, 0); M(3, 3) -= M(0, 3) * M(3, 0) / M(0, 0); M(3, 4) -= M(0, 4) * M(3, 0) / M(0, 0); M(3, 5) -= M(0, 5) * M(3, 0) / M(0, 0); M(3, 6) -= M(0, 6) * M(3, 0) / M(0, 0); M(3, 7) -= M(0, 7) * M(3, 0) / M(0, 0);
+    b[4] -= b[0] * M(4, 0) / M(0, 0); M(4, 4) -= M(0, 4) * M(4, 0) / M(0, 0); M(4, 5) -= M(0, 5) * M(4, 0) / M(0, 0); M(4, 6) -= M(0, 6) * M(4, 0) / M(0, 0); M(4, 7) -= M(0, 7) * M(4, 0) / M(0, 0);
+    b[5] -= b[0] * M(5, 0) / M(0, 0); M(5, 5) -= M(0, 5) * M(5, 0) / M(0, 0); M(5, 6) -= M(0, 6) * M(5, 0) / M(0, 0); M(5, 7) -= M(0, 7) * M(5, 0) / M(0, 0);
+    b[6] -= b[0] * M(6, 0) / M(0, 0); M(6, 6) -= M(0, 6) * M(6, 0) / M(0, 0); M(6, 7) -= M(0, 7) * M(6, 0) / M(0, 0);
+    b[7] -= b[0] * M(7, 0) / M(0, 0); M(7, 7) -= M(0, 7) * M(7, 0) / M(0, 0);
+
+    b[2] -= b[1] * M(2, 1) / M(1, 1); M(2, 2) -= M(1, 2) * M(2, 1) / M(1, 1); M(2, 3) -= M(1, 3) * M(2, 1) / M(1, 1); M(2, 4) -= M(1, 4) * M(2, 1) / M(1, 1); M(2, 5) -= M(1, 5) * M(2, 1) / M(1, 1); M(2, 6) -= M(1, 6) * M(2, 1) / M(1, 1); M(2, 7) -= M(1, 7) * M(2, 1) / M(1, 1);
+    b[3] -= b[1] * M(3, 1) / M(1, 1); M(3, 3) -= M(1, 3) * M(3, 1) / M(1, 1); M(3, 4) -= M(1, 4) * M(3, 1) / M(1, 1); M(3, 5) -= M(1, 5) * M(3, 1) / M(1, 1); M(3, 6) -= M(1, 6) * M(3, 1) / M(1, 1); M(3, 7) -= M(1, 7) * M(3, 1) / M(1, 1);
+    b[4] -= b[1] * M(4, 1) / M(1, 1); M(4, 4) -= M(1, 4) * M(4, 1) / M(1, 1); M(4, 5) -= M(1, 5) * M(4, 1) / M(1, 1); M(4, 6) -= M(1, 6) * M(4, 1) / M(1, 1); M(4, 7) -= M(1, 7) * M(4, 1) / M(1, 1);
+    b[5] -= b[1] * M(5, 1) / M(1, 1); M(5, 5) -= M(1, 5) * M(5, 1) / M(1, 1); M(5, 6) -= M(1, 6) * M(5, 1) / M(1, 1); M(5, 7) -= M(1, 7) * M(5, 1) / M(1, 1);
+    b[6] -= b[1] * M(6, 1) / M(1, 1); M(6, 6) -= M(1, 6) * M(6, 1) / M(1, 1); M(6, 7) -= M(1, 7) * M(6, 1) / M(1, 1);
+    b[7] -= b[1] * M(7, 1) / M(1, 1); M(7, 7) -= M(1, 7) * M(7, 1) / M(1, 1);
+
+    b[3] -= b[2] * M(3, 2) / M(2, 2); M(3, 3) -= M(2, 3) * M(3, 2) / M(2, 2); M(3, 4) -= M(2, 4) * M(3, 2) / M(2, 2); M(3, 5) -= M(2, 5) * M(3, 2) / M(2, 2); M(3, 6) -= M(2, 6) * M(3, 2) / M(2, 2); M(3, 7) -= M(2, 7) * M(3, 2) / M(2, 2);
+    b[4] -= b[2] * M(4, 2) / M(2, 2); M(4, 4) -= M(2, 4) * M(4, 2) / M(2, 2); M(4, 5) -= M(2, 5) * M(4, 2) / M(2, 2); M(4, 6) -= M(2, 6) * M(4, 2) / M(2, 2); M(4, 7) -= M(2, 7) * M(4, 2) / M(2, 2);
+    b[5] -= b[2] * M(5, 2) / M(2, 2); M(5, 5) -= M(2, 5) * M(5, 2) / M(2, 2); M(5, 6) -= M(2, 6) * M(5, 2) / M(2, 2); M(5, 7) -= M(2, 7) * M(5, 2) / M(2, 2);
+    b[6] -= b[2] * M(6, 2) / M(2, 2); M(6, 6) -= M(2, 6) * M(6, 2) / M(2, 2); M(6, 7) -= M(2, 7) * M(6, 2) / M(2, 2);
+    b[7] -= b[2] * M(7, 2) / M(2, 2); M(7, 7) -= M(2, 7) * M(7, 2) / M(2, 2);
+
+    b[4] -= b[3] * M(4, 3) / M(3, 3); M(4, 4) -= M(3, 4) * M(4, 3) / M(3, 3); M(4, 5) -= M(3, 5) * M(4, 3) / M(3, 3); M(4, 6) -= M(3, 6) * M(4, 3) / M(3, 3); M(4, 7) -= M(3, 7) * M(4, 3) / M(3, 3);
+    b[5] -= b[3] * M(5, 3) / M(3, 3); M(5, 5) -= M(3, 5) * M(5, 3) / M(3, 3); M(5, 6) -= M(3, 6) * M(5, 3) / M(3, 3); M(5, 7) -= M(3, 7) * M(5, 3) / M(3, 3);
+    b[6] -= b[3] * M(6, 3) / M(3, 3); M(6, 6) -= M(3, 6) * M(6, 3) / M(3, 3); M(6, 7) -= M(3, 7) * M(6, 3) / M(3, 3);
+    b[7] -= b[3] * M(7, 3) / M(3, 3); M(7, 7) -= M(3, 7) * M(7, 3) / M(3, 3);
+
+    b[5] -= b[4] * M(5, 4) / M(4, 4); M(5, 5) -= M(4, 5) * M(5, 4) / M(4, 4); M(5, 6) -= M(4, 6) * M(5, 4) / M(4, 4); M(5, 7) -= M(4, 7) * M(5, 4) / M(4, 4);
+    b[6] -= b[4] * M(6, 4) / M(4, 4); M(6, 6) -= M(4, 6) * M(6, 4) / M(4, 4); M(6, 7) -= M(4, 7) * M(6, 4) / M(4, 4);
+    b[7] -= b[4] * M(7, 4) / M(4, 4); M(7, 7) -= M(4, 7) * M(7, 4) / M(4, 4);
+
+    b[6] -= b[5] * M(6, 5) / M(5, 5); M(6, 6) -= M(5, 6) * M(6, 5) / M(5, 5); M(6, 7) -= M(5, 7) * M(6, 5) / M(5, 5);
+    b[7] -= b[5] * M(7, 5) / M(5, 5); M(7, 7) -= M(5, 7) * M(7, 5) / M(5, 5);
+
+    b[7] -= b[6] * M(7, 6) / M(6, 6); M(7, 7) -= M(6, 7) * M(7, 6) / M(6, 6);
+
+    b[N-1-0] /= M(N-1-0, N-1-0);
+    interp += b[N-1-0] * (X[N-1-0] - X[N]);
+
+    b[N-1-1] -= M(N-1-1, 7) * b[7]; b[N-1-1] /= M(N-1-1, N-1-1);
+    interp += b[N-1-1] * (X[N-1-1] - X[N]);
+
+    b[N-1-2] -= M(N-1-2, 6) * b[6]; b[N-1-2] -= M(N-1-2, 7) * b[7]; b[N-1-2] /= M(N-1-2, N-1-2);
+    interp += b[N-1-2] * (X[N-1-2] - X[N]);
+
+    b[N-1-3] -= M(N-1-3, 5) * b[5]; b[N-1-3] -= M(N-1-3, 6) * b[6]; b[N-1-3] -= M(N-1-3, 7) * b[7]; b[N-1-3] /= M(N-1-3, N-1-3);
+    interp += b[N-1-3] * (X[N-1-3] - X[N]);
+
+    b[N-1-4] -= M(N-1-4, 4) * b[4]; b[N-1-4] -= M(N-1-4, 5) * b[5]; b[N-1-4] -= M(N-1-4, 6) * b[6]; b[N-1-4] -= M(N-1-4, 7) * b[7]; b[N-1-4] /= M(N-1-4, N-1-4);
+    interp += b[N-1-4] * (X[N-1-4] - X[N]);
+
+    b[N-1-5] -= M(N-1-5, 3) * b[3]; b[N-1-5] -= M(N-1-5, 4) * b[4]; b[N-1-5] -= M(N-1-5, 5) * b[5]; b[N-1-5] -= M(N-1-5, 6) * b[6]; b[N-1-5] -= M(N-1-5, 7) * b[7]; b[N-1-5] /= M(N-1-5, N-1-5);
+    interp += b[N-1-5] * (X[N-1-5] - X[N]);
+
+    b[N-1-6] -= M(N-1-6, 2) * b[2]; b[N-1-6] -= M(N-1-6, 3) * b[3]; b[N-1-6] -= M(N-1-6, 4) * b[4]; b[N-1-6] -= M(N-1-6, 5) * b[5]; b[N-1-6] -= M(N-1-6, 6) * b[6]; b[N-1-6] -= M(N-1-6, 7) * b[7]; b[N-1-6] /= M(N-1-6, N-1-6);
+    interp += b[N-1-6] * (X[N-1-6] - X[N]);
+
+    b[N-1-7] -= M(N-1-7, 1) * b[1]; b[N-1-7] -= M(N-1-7, 2) * b[2]; b[N-1-7] -= M(N-1-7, 3) * b[3]; b[N-1-7] -= M(N-1-7, 4) * b[4]; b[N-1-7] -= M(N-1-7, 5) * b[5]; b[N-1-7] -= M(N-1-7, 6) * b[6]; b[N-1-7] -= M(N-1-7, 7) * b[7]; b[N-1-7] /= M(N-1-7, N-1-7);
+    interp += b[N-1-7] * (X[N-1-7] - X[N]);
+
+    return interp.zwxx;
+}

shaders/LumaSharpenHook.glsl

@@ -0,0 +1,206 @@
+// vim: set ft=glsl:
+
+/*
+    LumaSharpenHook 0.3
+
+    original hlsl by Christian Cann Schuldt Jensen ~ CeeJay.dk
+    port to glsl by Anon
+
+    It blurs the original pixel with the surrounding pixels and then subtracts this blur to sharpen the image.
+    It does this in luma to avoid color artifacts and allows limiting the maximum sharpning to avoid or lessen halo artifacts.
+
+    This is similar to using Unsharp Mask in Photoshop.
+*/
+
+// -- Hooks --
+//!HOOK LUMA
+//!BIND HOOKED
+
+
+// -- Sharpening --
+#define sharp_strength 0.30   //[0.10 to 3.00] Strength of the sharpening
+
+#define sharp_clamp    0.035  //[0.000 to 1.000] Limits maximum amount of sharpening a pixel recieves - Default is 0.035
+
+// -- Advanced sharpening settings --
+#define pattern 2        //[1|2|3|4] Choose a sample pattern. 1 = Fast, 2 = Normal, 3 = Wider, 4 = Pyramid shaped.
+                         //[8|9] Experimental slower patterns. 8 = 9 tap 9 fetch gaussian, 9 = 9 tap 9 fetch high pass.
+                         
+#define offset_bias 1.0  //[0.0 to 6.0] Offset bias adjusts the radius of the sampling pattern.
+
+vec4 hook(){
+    vec4 colorInput = LUMA_tex(LUMA_pos);
+    
+    
+    //We are on luma plane: xyzw = [luma_val, 0.0, 0.0, 1.0]
+    float ori = colorInput.x;
+    
+    // -- Combining the strength and luma multipliers --
+    float sharp_strength_luma = sharp_strength; //I'll be combining even more multipliers with it later on
+    
+    float px = 1.0;
+    float py = 1.0;
+    
+    //                       Sampling patterns                     
+  
+    //   [ NW,   , NE ] Each texture lookup (except ori)
+    //   [   ,ori,    ] samples 4 pixels
+    //   [ SW,   , SE ]
+
+    // -- Pattern 1 -- A (fast) 7 tap gaussian using only 2+1 texture fetches.
+    #if pattern == 1
+
+        // -- Gaussian filter --
+        //   [ 1/9, 2/9,    ]     [ 1 , 2 ,   ]
+        //   [ 2/9, 8/9, 2/9]  =  [ 2 , 8 , 2 ]
+        //   [    , 2/9, 1/9]     [   , 2 , 1 ]
+        
+        px = (px / 3.0) * offset_bias;
+        py = (py / 3.0) * offset_bias;
+        
+        float blur_ori = LUMA_texOff(vec2(px,py)).x;  // North West
+        blur_ori += LUMA_texOff(vec2(-px,-py)).x; // South East
+        
+        //blur_ori += LUMA_texOff(vec2(px,py)).x; // North East
+        //blur_ori += LUMA_texOff(vec2(-px,-py)).x; // South West
+        
+        blur_ori *= 0.5;  //Divide by the number of texture fetches
+
+        sharp_strength_luma *= 1.5; // Adjust strength to aproximate the strength of pattern 2
+    #endif
+  
+    // -- Pattern 2 -- A 9 tap gaussian using 4+1 texture fetches.
+    #if pattern == 2
+        // -- Gaussian filter --
+        //   [ .25, .50, .25]     [ 1 , 2 , 1 ]
+        //   [ .50,   1, .50]  =  [ 2 , 4 , 2 ]
+        //   [ .25, .50, .25]     [ 1 , 2 , 1 ]
+        
+        px = px * 0.5 * offset_bias;
+        py = py * 0.5 * offset_bias;
+        
+        float blur_ori = LUMA_texOff(vec2(px,-py)).x; // South East
+        blur_ori += LUMA_texOff(vec2(-px,-py)).x;  // South West
+        blur_ori += LUMA_texOff(vec2(px,py)).x; // North East
+        blur_ori += LUMA_texOff(vec2(-px,py)).x; // North West
+        
+        blur_ori *= 0.25;  // ( /= 4) Divide by the number of texture fetches
+    #endif
+     
+    // -- Pattern 3 -- An experimental 17 tap gaussian using 4+1 texture fetches.
+    #if pattern == 3
+
+        // -- Gaussian filter --
+        //   [   , 4 , 6 ,   ,   ]
+        //   [   ,16 ,24 ,16 , 4 ]
+        //   [ 6 ,24 ,   ,24 , 6 ]
+        //   [ 4 ,16 ,24 ,16 ,   ]
+        //   [   ,   , 6 , 4 ,   ]
+        
+        px = px * offset_bias;
+        py = py * offset_bias;
+
+        float blur_ori = LUMA_texOff(vec2(0.4*px,-1.2*py)).x;  // South South East
+        blur_ori += LUMA_texOff(vec2(-1.2*px,-0.4*py)).x; // West South West
+        blur_ori += LUMA_texOff(vec2(1.2*px,0.4*py)).x; // East North East
+        blur_ori += LUMA_texOff(vec2(-0.4*px,1.2*py)).x; // North North West
+         
+        blur_ori *= 0.25;  // ( /= 4) Divide by the number of texture fetches
+        
+        sharp_strength_luma *= 0.51;
+  #endif
+  
+    // -- Pattern 4 -- A 9 tap high pass (pyramid filter) using 4+1 texture fetches.
+    #if pattern == 4
+        // -- Gaussian filter --
+        //   [ .50, .50, .50]     [ 1 , 1 , 1 ]
+        //   [ .50,    , .50]  =  [ 1 ,   , 1 ]
+        //   [ .50, .50, .50]     [ 1 , 1 , 1 ]
+        
+        float blur_ori = LUMA_texOff(vec2(0.5 * px,-py * offset_bias)).x;  // South South East
+        blur_ori += LUMA_texOff(vec2(offset_bias * -px,0.5 * -py)).x; // West South West
+        blur_ori += LUMA_texOff(vec2(offset_bias * px,0.5 * py)).x; // East North East
+        blur_ori += LUMA_texOff(vec2(0.5 * -px,py * offset_bias)).x; // North North West
+        
+        //blur_ori += (2.0 * ori); // Probably not needed. Only serves to lessen the effect.
+        
+        blur_ori *= 0.25;  //Divide by the number of texture fetches
+
+        sharp_strength_luma *= 0.666; // Adjust strength to aproximate the strength of pattern 2
+    #endif
+    
+    // -- Pattern 8 -- A (slower) 9 tap gaussian using 9 texture fetches.
+    #if pattern == 8
+        
+        // -- Gaussian filter --
+        //   [ 1 , 2 , 1 ]
+        //   [ 2 , 4 , 2 ]
+        //   [ 1 , 2 , 1 ]
+        
+        px = px * offset_bias;
+        py = py * offset_bias;
+        
+        float blur_ori = LUMA_texOff(vec2(-px,py)).x; // North West
+        blur_ori += LUMA_texOff(vec2(px,-py)).x;     // South East
+        blur_ori += LUMA_texOff(vec2(-px,-py)).x;  // South West
+        blur_ori += LUMA_texOff(vec2(px,py)).x;    // North East
+        
+        float blur_ori2 = LUMA_texOff(vec2(0.0,py)).x; // North
+        blur_ori2 += LUMA_texOff(vec2(0.0,-py)).x;    // South
+        blur_ori2 += LUMA_texOff(vec2(-px,0.0)).x;   // West
+        blur_ori2 += LUMA_texOff(vec2(px,0.0)).x;   // East
+        blur_ori2 *= 2.0;
+        
+        blur_ori += blur_ori2;
+        blur_ori += (ori * 4.0); // Probably not needed. Only serves to lessen the effect.
+        
+        // dot()s with gaussian strengths here?
+        
+        blur_ori /= 16.0;  //Divide by the number of texture fetches
+        
+        sharp_strength_luma *= 0.75; // Adjust strength to aproximate the strength of pattern 2
+    #endif
+    
+    // -- Pattern 9 -- A (slower) 9 tap high pass using 9 texture fetches.
+    #if pattern == 9
+        
+        // -- Gaussian filter --
+        //   [ 1 , 1 , 1 ]
+        //   [ 1 , 1 , 1 ]
+        //   [ 1 , 1 , 1 ]
+        
+        px = px * offset_bias;
+        py = py * offset_bias;
+        
+        float blur_ori = LUMA_texOff(vec2(-px,py)).x; // North West
+        blur_ori += LUMA_texOff(vec2(px,-py)).x;     // South East
+        blur_ori += LUMA_texOff(vec2(-px,-py)).x;  // South West
+        blur_ori += LUMA_texOff(vec2(px,py)).x;    // North East
+        
+        blur_ori += ori; // Probably not needed. Only serves to lessen the effect.
+        
+        blur_ori += LUMA_texOff(vec2(0.0,py)).x;    // North
+        blur_ori += LUMA_texOff(vec2(0.0,-py)).x;  // South
+        blur_ori += LUMA_texOff(vec2(-px,0.0)).x; // West
+        blur_ori += LUMA_texOff(vec2(px,0.0)).x; // East
+        
+        blur_ori /= 9.0;  //Divide by the number of texture fetches
+        
+        sharp_strength_luma *= (8.0/9.0); // Adjust strength to aproximate the strength of pattern 2
+    #endif
+    
+    // -- Calculate the sharpening --
+    float sharp = ori - blur_ori;  //Subtracting the blurred image from the original image
+    
+    // -- Adjust strength of the sharpening and clamp it--
+    float sharp_strength_luma_clamp = sharp_strength_luma / (2.0 * sharp_clamp); //Roll part of the clamp into the dot
+    
+    float sharp_luma = clamp((sharp * sharp_strength_luma_clamp + 0.5), 0.0,1.0 ); //Calculate the luma, adjust the strength, scale up and clamp
+    sharp_luma = (sharp_clamp * 2.0) * sharp_luma - sharp_clamp; //scale down
+
+
+    // -- Combining the values to get the final sharpened pixel --
+
+    colorInput.x = colorInput.x + sharp_luma;    // Add the sharpening to the input color.
+    return clamp(colorInput, 0.0,1.0);
+}

shaders/adaptive-sharpen.glsl

@@ -0,0 +1,246 @@
+// Copyright (c) 2015-2018, bacondither
+// All rights reserved.
+//
+// Redistribution and use in source and binary forms, with or without
+// modification, are permitted provided that the following conditions
+// are met:
+// 1. Redistributions of source code must retain the above copyright
+//    notice, this list of conditions and the following disclaimer
+//    in this position and unchanged.
+// 2. Redistributions in binary form must reproduce the above copyright
+//    notice, this list of conditions and the following disclaimer in the
+//    documentation and/or other materials provided with the distribution.
+//
+// THIS SOFTWARE IS PROVIDED BY THE AUTHORS ``AS IS'' AND ANY EXPRESS OR
+// IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES
+// OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE DISCLAIMED.
+// IN NO EVENT SHALL THE AUTHOR BE LIABLE FOR ANY DIRECT, INDIRECT,
+// INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT
+// NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,
+// DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY
+// THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
+// (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF
+// THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
+
+// Adaptive sharpen - version 2018-04-14 - (requires ps >= 3.0)
+// Tuned for use post resize
+
+//!HOOK SCALED
+//!BIND HOOKED
+//!SAVE ASSD
+//!COMPONENTS 2
+//!DESC adaptive-sharpen
+
+//--------------------------------------- Settings ------------------------------------------------
+
+#define curve_height    1.6                  // Main control of sharpening strength [>0]  
+                                             // 0.3 <-> 2.0 is a reasonable range of values
+
+// Defined values under this row are "optimal" DO NOT CHANGE IF YOU DO NOT KNOW WHAT YOU ARE DOING!
+
+#define curveslope      0.5                  // Sharpening curve slope, high edge values
+
+#define L_overshoot     0.003                // Max light overshoot before compression [>0.001]
+#define L_compr_low     0.167                // Light compression, default (0.169=~9x)
+#define L_compr_high    0.334                // Light compression, surrounded by edges (0.337=~4x)
+
+#define D_overshoot     0.009                // Max dark overshoot before compression [>0.001]
+#define D_compr_low     0.250                // Dark compression, default (0.253=~6x)
+#define D_compr_high    0.500                // Dark compression, surrounded by edges (0.504=~2.5x)
+
+#define scale_lim       0.1                  // Abs max change before compression (0.1=+-10%)
+#define scale_cs        0.056                // Compression slope above scale_lim
+
+#define pm_p        sat(1.0/curve_height)    // Power mean p-value [>0-1.0]
+//-------------------------------------------------------------------------------------------------
+
+// Soft limit
+#define soft_lim(v,s)  ( (exp(2.0*min(abs(v), s*24.0)/s) - 1.0)/(exp(2.0*min(abs(v), s*24.0)/s) + 1.0)*s )
+
+// Weighted power mean
+#define wpmean(a,b,c)  ( pow((c*pow(abs(a), pm_p) + (1.0-c)*pow(b, pm_p)), (1.0/pm_p)) )
+
+// Get destination pixel values
+#define get(x,y)       ( HOOKED_texOff(vec2(x, y)).rgb )
+#define sat(x)         ( clamp(x, 0.0, 1.0) )
+
+// Colour to luma, fast approx gamma, avg of rec. 709 & 601 luma coeffs
+#define CtL(RGB)       ( sqrt(dot(vec3(0.2558, 0.6511, 0.0931), pow(sat(RGB), vec3(2.0)))) )
+
+// Center pixel diff
+#define mdiff(a,b,c,d,e,f,g) ( abs(luma[g]-luma[a]) + abs(luma[g]-luma[b])           \
+                             + abs(luma[g]-luma[c]) + abs(luma[g]-luma[d])           \
+                             + 0.5*(abs(luma[g]-luma[e]) + abs(luma[g]-luma[f])) )
+
+#define b_diff(pix) ( abs(blur-c[pix]) )
+
+vec4 hook() {
+
+    vec4 o = HOOKED_tex(HOOKED_pos);
+
+    // Get points, saturate colour data in c[0]
+    // [                c22               ]
+    // [           c24, c9,  c23          ]
+    // [      c21, c1,  c2,  c3, c18      ]
+    // [ c19, c10, c4,  c0,  c5, c11, c16 ]
+    // [      c20, c6,  c7,  c8, c17      ]
+    // [           c15, c12, c14          ]
+    // [                c13               ]
+    vec3 c[25] = vec3[](sat(o.rgb), get(-1,-1), get( 0,-1), get( 1,-1), get(-1, 0),
+                        get( 1, 0), get(-1, 1), get( 0, 1), get( 1, 1), get( 0,-2),
+                        get(-2, 0), get( 2, 0), get( 0, 2), get( 0, 3), get( 1, 2),
+                        get(-1, 2), get( 3, 0), get( 2, 1), get( 2,-1), get(-3, 0),
+                        get(-2, 1), get(-2,-1), get( 0,-3), get( 1,-2), get(-1,-2));
+
+    // Blur, gauss 3x3
+    vec3  blur   = (2.0 * (c[2]+c[4]+c[5]+c[7]) + (c[1]+c[3]+c[6]+c[8]) + 4.0 * c[0]) / 16.0;
+
+    // Contrast compression, center = 0.5, scaled to 1/3
+    float c_comp = sat(0.266666681f + 0.9*exp2(dot(blur, vec3(-7.4/3.0))));
+
+    // Edge detection
+    // Relative matrix weights
+    // [          1          ]
+    // [      4,  5,  4      ]
+    // [  1,  5,  6,  5,  1  ]
+    // [      4,  5,  4      ]
+    // [          1          ]
+    float edge = length( 1.38*b_diff(0)
+                       + 1.15*(b_diff(2) + b_diff(4) + b_diff(5) + b_diff(7))
+                       + 0.92*(b_diff(1) + b_diff(3) + b_diff(6) + b_diff(8))
+                       + 0.23*(b_diff(9) + b_diff(10) + b_diff(11) + b_diff(12)) ) * c_comp;
+
+    // RGB to luma
+    float c0_Y = CtL(c[0]);
+
+    float luma[25] = float[](c0_Y, CtL(c[1]), CtL(c[2]), CtL(c[3]), CtL(c[4]), CtL(c[5]), CtL(c[6]),
+                             CtL(c[7]),  CtL(c[8]),  CtL(c[9]),  CtL(c[10]), CtL(c[11]), CtL(c[12]),
+                             CtL(c[13]), CtL(c[14]), CtL(c[15]), CtL(c[16]), CtL(c[17]), CtL(c[18]),
+                             CtL(c[19]), CtL(c[20]), CtL(c[21]), CtL(c[22]), CtL(c[23]), CtL(c[24]));
+
+    // Precalculated default squared kernel weights
+    const vec3 w1 = vec3(0.5,           1.0, 1.41421356237); // 0.25, 1.0, 2.0
+    const vec3 w2 = vec3(0.86602540378, 1.0, 0.54772255751); // 0.75, 1.0, 0.3
+
+    // Transition to a concave kernel if the center edge val is above thr
+    vec3 dW = pow(mix( w1, w2, smoothstep( 0.3, 0.8, edge)), vec3(2.0));
+
+    float mdiff_c0  = 0.02 + 3.0*( abs(luma[0]-luma[2]) + abs(luma[0]-luma[4])
+                                 + abs(luma[0]-luma[5]) + abs(luma[0]-luma[7])
+                                 + 0.25*(abs(luma[0]-luma[1]) + abs(luma[0]-luma[3])
+                                        +abs(luma[0]-luma[6]) + abs(luma[0]-luma[8])) );
+
+    // Use lower weights for pixels in a more active area relative to center pixel area
+    // This results in narrower and less visible overshoots around sharp edges
+    float weights[12]  = float[](( min((mdiff_c0/mdiff(24, 21, 2,  4,  9,  10, 1)),  dW.y) ),
+                                 ( dW.x ),
+                                 ( min((mdiff_c0/mdiff(23, 18, 5,  2,  9,  11, 3)),  dW.y) ),
+                                 ( dW.x ),
+                                 ( dW.x ),
+                                 ( min((mdiff_c0/mdiff(4,  20, 15, 7,  10, 12, 6)),  dW.y) ),
+                                 ( dW.x ),
+                                 ( min((mdiff_c0/mdiff(5,  7,  17, 14, 12, 11, 8)),  dW.y) ),
+                                 ( min((mdiff_c0/mdiff(2,  24, 23, 22, 1,  3,  9)),  dW.z) ),
+                                 ( min((mdiff_c0/mdiff(20, 19, 21, 4,  1,  6,  10)), dW.z) ),
+                                 ( min((mdiff_c0/mdiff(17, 5,  18, 16, 3,  8,  11)), dW.z) ),
+                                 ( min((mdiff_c0/mdiff(13, 15, 7,  14, 6,  8,  12)), dW.z) ));
+
+    weights[0] = (max(max((weights[8]  + weights[9])/4.0,  weights[0]), 0.25) + weights[0])/2.0;
+    weights[2] = (max(max((weights[8]  + weights[10])/4.0, weights[2]), 0.25) + weights[2])/2.0;
+    weights[5] = (max(max((weights[9]  + weights[11])/4.0, weights[5]), 0.25) + weights[5])/2.0;
+    weights[7] = (max(max((weights[10] + weights[11])/4.0, weights[7]), 0.25) + weights[7])/2.0;
+
+    // Calculate the negative part of the laplace kernel
+    float weightsum   = 0.0;
+    float neg_laplace = 0.0;
+
+    for (int pix = 0; pix < 12; ++pix)
+    {
+        neg_laplace  += luma[pix+1]*weights[pix];
+        weightsum    += weights[pix];
+    }
+
+    neg_laplace = neg_laplace / weightsum;
+
+    // Compute sharpening magnitude function
+    float sharpen_val = (curve_height/(curve_height*curveslope*pow((edge), 3.5) + 0.625));
+
+    // Calculate sharpening diff and scale
+    float sharpdiff = (c0_Y - neg_laplace)*(sharpen_val + 0.01);
+
+    // Calculate local near min & max, partial sort
+    float temp;
+
+    for (int i1 = 0; i1 < 24; i1 += 2)
+    {
+        temp = luma[i1];
+        luma[i1]   = min(luma[i1], luma[i1+1]);
+        luma[i1+1] = max(temp, luma[i1+1]);
+    }
+
+    for (int i2 = 24; i2 > 0; i2 -= 2)
+    {
+        temp = luma[0];
+        luma[0]    = min(luma[0], luma[i2]);
+        luma[i2]   = max(temp, luma[i2]);
+
+        temp = luma[24];
+        luma[24] = max(luma[24], luma[i2-1]);
+        luma[i2-1] = min(temp, luma[i2-1]);
+    }
+
+    for (int i1 = 1; i1 < 24-1; i1 += 2)
+    {
+        temp = luma[i1];
+        luma[i1]   = min(luma[i1], luma[i1+1]);
+        luma[i1+1] = max(temp, luma[i1+1]);
+    }
+
+    for (int i2 = 24-1; i2 > 1; i2 -= 2)
+    {
+        temp = luma[1];
+        luma[1]    = min(luma[1], luma[i2]);
+        luma[i2]   = max(temp, luma[i2]);
+
+        temp = luma[24-1];
+        luma[24-1] = max(luma[24-1], luma[i2-1]);
+        luma[i2-1] = min(temp, luma[i2-1]);
+    }
+
+    float nmax = (max(luma[23], c0_Y)*3.0 + luma[24])/4.0;
+    float nmin = (min(luma[1],  c0_Y)*3.0 + luma[0])/4.0;
+
+    // Calculate tanh scale factors
+    float min_dist  = min(abs(nmax - c0_Y), abs(c0_Y - nmin));
+    float pos_scale = min_dist + min(L_overshoot, 1.0001 - min_dist - c0_Y);
+    float neg_scale = min_dist + min(D_overshoot, 0.0001 + c0_Y - min_dist);
+
+    pos_scale = min(pos_scale, scale_lim*(1.0 - scale_cs) + pos_scale*scale_cs);
+    neg_scale = min(neg_scale, scale_lim*(1.0 - scale_cs) + neg_scale*scale_cs);
+
+    // Soft limited anti-ringing with tanh, wpmean to control compression slope
+    sharpdiff = wpmean(max(sharpdiff, 0.0), soft_lim( max(sharpdiff, 0.0), pos_scale ), L_compr_low )
+              - wpmean(min(sharpdiff, 0.0), soft_lim( min(sharpdiff, 0.0), neg_scale ), D_compr_low );
+
+    return vec4(sharpdiff, c0_Y, 0, 1);
+}
+
+//!HOOK SCALED
+//!BIND HOOKED
+//!BIND ASSD
+//!DESC adaptive-sharpen equalization
+
+#define video_level_out false                // True to preserve BTB & WTW (minor summation error)
+                                             // Normally it should be set to false
+#define SD(x,y)         ASSD_texOff(vec2(x,y)).r
+
+vec4 hook() {
+    vec4 o = HOOKED_texOff(0);
+    float sharpdiff = SD( 0, 0) - 0.6 * 0.25 * (SD(-0.5,-0.5) + SD( 0.5,-0.5) + SD(-0.5, 0.5) + SD( 0.5, 0.5));
+    float c0_Y = ASSD_texOff(vec2(0)).g;
+    float sharpdiff_lim = clamp(c0_Y + sharpdiff, 0.0, 1.0) - c0_Y;
+    float satmul = (c0_Y + max(sharpdiff_lim*0.9, sharpdiff_lim)*1.03 + 0.03)/(c0_Y + 0.03);
+    vec3 res = c0_Y + (sharpdiff_lim*3 + sharpdiff)/4 + (clamp(o.rgb, 0.0, 1.0) - c0_Y)*satmul;
+    o.rgb = video_level_out == true ? res + o.rgb - clamp(o.rgb, 0.0, 1.0) : res;
+    return o;
+}

shaders/filmgrain.glsl

@@ -0,0 +1,41 @@
+//!HOOK LUMA
+//!BIND HOOKED
+//!DESC gaussian film grain
+
+#normal value is 0.05 changed for demo purposes
+#define INTENSITY 0.55
+
+float permute(float x)
+{
+    x = (34.0 * x + 1.0) * x;
+    return fract(x * 1.0/289.0) * 289.0;
+}
+
+float rand(inout float state)
+{
+    state = permute(state);
+    return fract(state * 1.0/41.0);
+}
+
+vec4 hook()
+{
+    vec3 m = vec3(HOOKED_pos, random) + vec3(1.0);
+    float state = permute(permute(m.x) + m.y) + m.z;
+
+    const float a0 = 0.151015505647689;
+    const float a1 = -0.5303572634357367;
+    const float a2 = 1.365020122861334;
+    const float b0 = 0.132089632343748;
+    const float b1 = -0.7607324991323768;
+
+    float p = 0.95 * rand(state) + 0.025;
+    float q = p - 0.5;
+    float r = q * q;
+
+    float grain = q * (a2 + (a1 * r + a0) / (r*r + b1*r + b0));
+    grain *= 0.255121822830526; // normalize to [-1,1)
+
+    vec4 color = HOOKED_tex(HOOKED_pos);
+    color.rgb += vec3(INTENSITY * grain);
+    return color;
+}

softhdcuvid.cpp

@@ -61,7 +61,7 @@ extern "C"
 /// vdr-plugin version number.
 /// Makefile extracts the version number for generating the file name
 /// for the distribution archive.
-static const char *const VERSION = "2.1.0"
+static const char *const VERSION = "3.3.1"
 #ifdef GIT_REV
     "-GIT" GIT_REV
 #endif
@@ -106,7 +106,7 @@ static int ConfigVideoBrightness;       ///< config video brightness
 static int ConfigVideoContrast = 100;   ///< config video contrast
 static int ConfigVideoSaturation = 100; ///< config video saturation
 static int ConfigVideoHue;              ///< config video hue
-static int ConfigGamma;                 ///< config Gamma
+static int ConfigGamma=100;                 ///< config Gamma
 static int ConfigTargetColorSpace;      ///< config Target Colrospace
 static int ConfigScalerTest;            /// Test for Scalers
 static int ConfigColorBlindness;
@@ -136,11 +136,6 @@ static int ConfigVideoCutTopBottom[RESOLUTIONS];
 /// config cut left and right pixels
 static int ConfigVideoCutLeftRight[RESOLUTIONS];
 
-static int ConfigAutoCropEnabled;       ///< auto crop detection enabled
-static int ConfigAutoCropInterval;      ///< auto crop detection interval
-static int ConfigAutoCropDelay;         ///< auto crop detection delay
-static int ConfigAutoCropTolerance;     ///< auto crop detection tolerance
-
 static int ConfigVideoAudioDelay;       ///< config audio delay
 static char ConfigAudioDrift;           ///< config audio drift
 static char ConfigAudioPassthrough;     ///< config audio pass-through mask
@@ -213,109 +208,108 @@ class cSoftRemote:public cRemote, private cThread
   public:
 
     /**
-    **	Soft device remote class constructor.
+    **  Soft device remote class constructor.
     **
-    **	@param name	remote name
+    **  @param name remote name
     */
-    cSoftRemote(void) : cRemote("XKeySym")
+     cSoftRemote(void):cRemote("XKeySym")
     {
-      Start();
+        Start();
     }
 
-    virtual ~cSoftRemote()
+    virtual ~ cSoftRemote()
     {
-      Cancel(3);
+        Cancel(3);
     }
 
     /**
-    **	Receive keycode.
+    **  Receive keycode.
     **
-    **	@param code	key code
+    **  @param code key code
     */
-    void Receive(const char *code) {
-      cMutexLock MutexLock(&mutex);
-      Command = code;
-      keyReceived.Broadcast();
+    void Receive(const char *code)
+    {
+        cMutexLock MutexLock(&mutex);
+
+        Command = code;
+        keyReceived.Broadcast();
     }
 };
 
 void cSoftRemote::Action(void)
 {
-  // see also VDR's cKbdRemote::Action()
-  cTimeMs FirstTime;
-  cTimeMs LastTime;
-  cString FirstCommand = "";
-  cString LastCommand = "";
-  bool Delayed = false;
-  bool Repeat = false;
+    // see also VDR's cKbdRemote::Action()
+    cTimeMs FirstTime;
+    cTimeMs LastTime;
+    cString FirstCommand = "";
+    cString LastCommand = "";
+    bool Delayed = false;
+    bool Repeat = false;
 
-  while (Running()) {
+    while (Running()) {
         cMutexLock MutexLock(&mutex);
+
         if (keyReceived.TimedWait(mutex, Setup.RcRepeatDelta * 3 / 2) && **Command) {
-           if (strcmp(Command, LastCommand) == 0) {
-              // If two keyboard events with the same command come in without an intermediate
-              // timeout, this is a long key press that caused the repeat function to kick in:
-              Delayed = false;
-              FirstCommand = "";
-              if (FirstTime.Elapsed() < (uint)Setup.RcRepeatDelay)
-                 continue; // repeat function kicks in after a short delay
-              if (LastTime.Elapsed() < (uint)Setup.RcRepeatDelta)
-                 continue; // skip same keys coming in too fast
-              cRemote::Put(Command, true);
-              Repeat = true;
-              LastTime.Set();
-              }
-           else if (strcmp(Command, FirstCommand) == 0) {
-              // If the same command comes in twice with an intermediate timeout, we
-              // need to delay the second command to see whether it is going to be
-              // a repeat function or a separate key press:
-              Delayed = true;
-              }
-           else {
-              // This is a totally new key press, so we accept it immediately:
-              cRemote::Put(Command);
-              Delayed = false;
-              FirstCommand = Command;
-              FirstTime.Set();
-              }
-           }
-        else if (Repeat) {
-           // Timeout after a repeat function, so we generate a 'release':
-           cRemote::Put(LastCommand, false, true);
-           Repeat = false;
-           }
-        else if (Delayed && *FirstCommand) {
-           // Timeout after two normal key presses of the same key, so accept the
-           // delayed key:
-           cRemote::Put(FirstCommand);
-           Delayed = false;
-           FirstCommand = "";
-           FirstTime.Set();
-           }
-        else if (**FirstCommand && FirstTime.Elapsed() > (uint)Setup.RcRepeatDelay) {
-           Delayed = false;
-           FirstCommand = "";
-           FirstTime.Set();
-           }
+            if (strcmp(Command, LastCommand) == 0) {
+                // If two keyboard events with the same command come in without an intermediate
+                // timeout, this is a long key press that caused the repeat function to kick in:
+                Delayed = false;
+                FirstCommand = "";
+                if (FirstTime.Elapsed() < (uint) Setup.RcRepeatDelay)
+                    continue;           // repeat function kicks in after a short delay
+                if (LastTime.Elapsed() < (uint) Setup.RcRepeatDelta)
+                    continue;           // skip same keys coming in too fast
+                cRemote::Put(Command, true);
+                Repeat = true;
+                LastTime.Set();
+            } else if (strcmp(Command, FirstCommand) == 0) {
+                // If the same command comes in twice with an intermediate timeout, we
+                // need to delay the second command to see whether it is going to be
+                // a repeat function or a separate key press:
+                Delayed = true;
+            } else {
+                // This is a totally new key press, so we accept it immediately:
+                cRemote::Put(Command);
+                Delayed = false;
+                FirstCommand = Command;
+                FirstTime.Set();
+            }
+        } else if (Repeat) {
+            // Timeout after a repeat function, so we generate a 'release':
+            cRemote::Put(LastCommand, false, true);
+            Repeat = false;
+        } else if (Delayed && *FirstCommand) {
+            // Timeout after two normal key presses of the same key, so accept the
+            // delayed key:
+            cRemote::Put(FirstCommand);
+            Delayed = false;
+            FirstCommand = "";
+            FirstTime.Set();
+        } else if (**FirstCommand && FirstTime.Elapsed() > (uint) Setup.RcRepeatDelay) {
+            Delayed = false;
+            FirstCommand = "";
+            FirstTime.Set();
+        }
         LastCommand = Command;
         Command = "";
-        }
+    }
 }
 
 static cSoftRemote *csoft = NULL;
+
 /**
-**	Feed key press as remote input (called from C part).
+**  Feed key press as remote input (called from C part).
 **
-**	@param keymap	target keymap "XKeymap" name (obsolete, ignored)
-**	@param key	pressed/released key name
-**	@param repeat	repeated key flag (obsolete, ignored)
-**	@param release	released key flag (obsolete, ignored)
-**	@param letter	x11 character string (system setting locale)
+**  @param keymap   target keymap "XKeymap" name (obsolete, ignored)
+**  @param key  pressed/released key name
+**  @param repeat   repeated key flag (obsolete, ignored)
+**  @param release  released key flag (obsolete, ignored)
+**  @param letter   x11 character string (system setting locale)
 */
 extern "C" void FeedKeyPress(const char *keymap, const char *key, int repeat, int release, const char *letter)
 {
     if (!csoft || !keymap || !key) {
-	return;
+        return;
     }
 
     csoft->Receive(key);
@@ -998,10 +992,6 @@ class cMenuSetupSoft:public cMenuSetupPage
     int CutTopBottom[RESOLUTIONS];
     int CutLeftRight[RESOLUTIONS];
 
-    int AutoCropInterval;
-    int AutoCropDelay;
-    int AutoCropTolerance;
-
     int Audio;
     int AudioDelay;
     int AudioDrift;
@@ -1097,10 +1087,10 @@ void cMenuSetupSoft::Create(void)
         "auto", "1920x1080", "1280x720", "custom",
     };
     static const char *const video_display_formats_4_3[] = {
-        "pan&scan", "letterbox", "center cut-out",
+        "pan&scan", "letterbox", "center cut-out", "original"
     };
     static const char *const video_display_formats_16_9[] = {
-        "pan&scan", "pillarbox", "center cut-out",
+        "pan&scan", "pillarbox", "center cut-out", "original"
     };
 #ifdef YADIF
     static const char *const deinterlace[] = {
@@ -1134,7 +1124,7 @@ void cMenuSetupSoft::Create(void)
     static char *scalingtest[100];
 
     if (scalers == 0) {
-        scalingtest[0] = "Off";
+        scalingtest[0] = (char *)"Off";
         for (scalers = 0; pl_named_filters[scalers].filter != NULL; scalers++) {
             scaling[scalers] = (char *)pl_named_filters[scalers].name;
             scalingtest[scalers + 1] = (char *)pl_named_filters[scalers].name;
@@ -1183,9 +1173,9 @@ void cMenuSetupSoft::Create(void)
         Add(new cMenuEditBoolItem(tr("Enable Screensaver(DPMS) at black screen"), &EnableDPMSatBlackScreen,
                 trVDR("no"), trVDR("yes")));
 #endif
-        Add(new cMenuEditStraItem(trVDR("4:3 video display format"), &Video4to3DisplayFormat, 3,
+        Add(new cMenuEditStraItem(trVDR("4:3 video display format"), &Video4to3DisplayFormat, 4,
                 video_display_formats_4_3));
-        Add(new cMenuEditStraItem(trVDR("16:9+other video display format"), &VideoOtherDisplayFormat, 3,
+        Add(new cMenuEditStraItem(trVDR("16:9+other video display format"), &VideoOtherDisplayFormat, 4,
                 video_display_formats_16_9));
 
 #if 0
@@ -1244,15 +1234,6 @@ void cMenuSetupSoft::Create(void)
                 Add(new cMenuEditIntItem(tr("Cut left and right (pixel)"), &CutLeftRight[i], 0, 250));
             }
         }
-#ifdef USE_AUTOCROP
-        //
-        //  auto-crop
-        //
-        Add(SeparatorItem(tr("Auto-crop")));
-        Add(new cMenuEditIntItem(tr("Autocrop interval (frames)"), &AutoCropInterval, 0, 200, tr("off")));
-        Add(new cMenuEditIntItem(tr("Autocrop delay (n * interval)"), &AutoCropDelay, 0, 200));
-        Add(new cMenuEditIntItem(tr("Autocrop tolerance (pixel)"), &AutoCropTolerance, 0, 32));
-#endif
     }
     //
     //  audio
@@ -1262,12 +1243,15 @@ void cMenuSetupSoft::Create(void)
     if (Audio) {
         Add(new cMenuEditIntItem(tr("Audio/Video delay (ms)"), &AudioDelay, -1000, 1000));
         Add(new cMenuEditStraItem(tr("Audio drift correction"), &AudioDrift, 4, audiodrift));
+		
         Add(new cMenuEditBoolItem(tr("Pass-through default"), &AudioPassthroughDefault, trVDR("off"), trVDR("on")));
-        Add(new cMenuEditBoolItem(tr("\040\040PCM pass-through"), &AudioPassthroughPCM, trVDR("no"), trVDR("yes")));
-        Add(new cMenuEditBoolItem(tr("\040\040AC-3 pass-through"), &AudioPassthroughAC3, trVDR("no"), trVDR("yes")));
-        Add(new cMenuEditBoolItem(tr("\040\040E-AC-3 pass-through"), &AudioPassthroughEAC3, trVDR("no"),
-                trVDR("yes")));
-        Add(new cMenuEditBoolItem(tr("Enable (E-)AC-3 (decoder) downmix"), &AudioDownmix, trVDR("no"), trVDR("yes")));
+		if (AudioPassthroughDefault) {
+        	Add(new cMenuEditBoolItem(tr("\040\040PCM pass-through"), &AudioPassthroughPCM, trVDR("no"), trVDR("yes")));
+        	Add(new cMenuEditBoolItem(tr("\040\040AC-3 pass-through"), &AudioPassthroughAC3, trVDR("no"), trVDR("yes")));
+        	Add(new cMenuEditBoolItem(tr("\040\040E-AC-3 pass-through"), &AudioPassthroughEAC3, trVDR("no"),trVDR("yes")));
+		} else {
+        	Add(new cMenuEditBoolItem(tr("Enable (E-)AC-3 (decoder) downmix"), &AudioDownmix, trVDR("no"), trVDR("yes")));
+		}
         Add(new cMenuEditBoolItem(tr("Volume control"), &AudioSoftvol, tr("Hardware"), tr("Software")));
         Add(new cMenuEditBoolItem(tr("Enable normalize volume"), &AudioNormalize, trVDR("no"), trVDR("yes")));
         Add(new cMenuEditIntItem(tr("  Max normalize factor (/1000)"), &AudioMaxNormalize, 0, 10000));
@@ -1323,10 +1307,12 @@ eOSState cMenuSetupSoft::ProcessKey(eKeys key)
     int old_osd_size;
     int old_resolution_shown[RESOLUTIONS];
     int i;
+	int old_pass;
 
     old_general = General;
     old_video = Video;
     old_audio = Audio;
+	old_pass = AudioPassthroughDefault;
 #ifdef USE_PIP
     old_pip = Pip;
 #endif
@@ -1341,6 +1327,7 @@ eOSState cMenuSetupSoft::ProcessKey(eKeys key)
 #ifdef USE_PIP
             || old_pip != Pip
 #endif
+			|| old_pass != AudioPassthroughDefault
             || old_osd_size != OsdSize) {
             Create();                   // update menu
         } else {
@@ -1429,13 +1416,6 @@ cMenuSetupSoft::cMenuSetupSoft(void)
         CutTopBottom[i] = ConfigVideoCutTopBottom[i];
         CutLeftRight[i] = ConfigVideoCutLeftRight[i];
     }
-    //
-    //  auto-crop
-    //
-    AutoCropInterval = ConfigAutoCropInterval;
-    AutoCropDelay = ConfigAutoCropDelay;
-    AutoCropTolerance = ConfigAutoCropTolerance;
-
     //
     //  audio
     //
@@ -1592,12 +1572,6 @@ void cMenuSetupSoft::Store(void)
     VideoSetCutTopBottom(ConfigVideoCutTopBottom);
     VideoSetCutLeftRight(ConfigVideoCutLeftRight);
 
-    SetupStore("AutoCrop.Interval", ConfigAutoCropInterval = AutoCropInterval);
-    SetupStore("AutoCrop.Delay", ConfigAutoCropDelay = AutoCropDelay);
-    SetupStore("AutoCrop.Tolerance", ConfigAutoCropTolerance = AutoCropTolerance);
-    VideoSetAutoCrop(ConfigAutoCropInterval, ConfigAutoCropDelay, ConfigAutoCropTolerance);
-    ConfigAutoCropEnabled = ConfigAutoCropInterval != 0;
-
     SetupStore("AudioDelay", ConfigVideoAudioDelay = AudioDelay);
     VideoSetAudioDelay(ConfigVideoAudioDelay);
     SetupStore("AudioDrift", ConfigAudioDrift = AudioDrift);
@@ -2154,6 +2128,10 @@ void cSoftHdMenu::Create(void)
     int dropped;
     int counter;
     float frametime;
+    int width, height;
+    int color;
+    int eotf;
+    char *colorstr, *eotfstr;
 
     current = Current();                // get current menu item index
     Clear();                            // clear the menu
@@ -2188,10 +2166,31 @@ void cSoftHdMenu::Create(void)
 #endif
     Add(new cOsdItem(NULL, osUnknown, false));
     Add(new cOsdItem(NULL, osUnknown, false));
-    GetStats(&missed, &duped, &dropped, &counter, &frametime);
+    GetStats(&missed, &duped, &dropped, &counter, &frametime, &width, &height, &color, &eotf);
+    switch (color) {
+        case AVCOL_SPC_RGB:
+            colorstr = strdup("BT 601");
+            eotfstr = strdup("BT 1886");
+            break;
+        case AVCOL_SPC_BT709:
+        case AVCOL_SPC_UNSPECIFIED:    //  comes with UHD
+            colorstr = strdup("BT 709");
+            eotfstr = strdup("BT 1886");
+            break;
+        case AVCOL_SPC_BT2020_NCL:
+            colorstr = strdup("BT 2020");
+            eotfstr = strdup("HDR-HLG");
+            break;
+        default:                       // fallback
+            colorstr = strdup("Fallback BT 709");
+            eotfstr = strdup("BT 1886");
+            break;
+    }
     Add(new cOsdItem(cString::sprintf(tr(" Frames missed(%d) duped(%d) dropped(%d) total(%d)"), missed, duped, dropped,
                 counter), osUnknown, false));
-    Add(new cOsdItem(cString::sprintf(tr(" Frame Process time %2.2fms"), frametime), osUnknown, false));
+    Add(new cOsdItem(cString::sprintf(tr(" Video %dx%d Color: %s Gamma: %s"), width, height, colorstr, eotfstr),
+            osUnknown, false));
+    //   Add(new cOsdItem(cString::sprintf(tr(" Frame Process time %2.2fms"), frametime), osUnknown, false));
     SetCurrent(Get(current));           // restore selected menu entry
     Display();                          // display build menu
 }
@@ -2274,33 +2273,6 @@ static void HandleHotkey(int code)
         case 22:                       // toggle full screen
             VideoSetFullscreen(-1);
             break;
-        case 23:                       // disable auto-crop
-            ConfigAutoCropEnabled = 0;
-            VideoSetAutoCrop(0, ConfigAutoCropDelay, ConfigAutoCropTolerance);
-            Skins.QueueMessage(mtInfo, tr("auto-crop disabled and freezed"));
-            break;
-        case 24:                       // enable auto-crop
-            ConfigAutoCropEnabled = 1;
-            if (!ConfigAutoCropInterval) {
-                ConfigAutoCropInterval = 50;
-            }
-            VideoSetAutoCrop(ConfigAutoCropInterval, ConfigAutoCropDelay, ConfigAutoCropTolerance);
-            Skins.QueueMessage(mtInfo, tr("auto-crop enabled"));
-            break;
-        case 25:                       // toggle auto-crop
-            ConfigAutoCropEnabled ^= 1;
-            // no interval configured, use some default
-            if (!ConfigAutoCropInterval) {
-                ConfigAutoCropInterval = 50;
-            }
-            VideoSetAutoCrop(ConfigAutoCropEnabled * ConfigAutoCropInterval, ConfigAutoCropDelay,
-                ConfigAutoCropTolerance);
-            if (ConfigAutoCropEnabled) {
-                Skins.QueueMessage(mtInfo, tr("auto-crop enabled"));
-            } else {
-                Skins.QueueMessage(mtInfo, tr("auto-crop disabled and freezed"));
-            }
-            break;
         case 30:                       // change 4:3 -> window mode
         case 31:
         case 32:
@@ -2473,11 +2445,17 @@ class cSoftHdDevice:public cDevice
         return "softhdcuvid";
     }
 #endif
-#ifdef VAAPI
+#if defined (VAAPI) && !defined (USE_DRM)
     virtual cString DeviceName(void) const
     {
         return "softhdvaapi";
     }
+#endif
+#if defined (VAAPI) && defined (USE_DRM)
+    virtual cString DeviceName(void) const
+    {
+        return "softhddrm";
+    }
 #endif
     virtual bool HasDecoder(void) const;
     virtual bool CanReplay(void) const;
@@ -3093,7 +3071,11 @@ bool cPluginSoftHdDevice::ProcessArgs(int argc, char *argv[])
 bool cPluginSoftHdDevice::Initialize(void)
 {
     // dsyslog("[softhddev]%s:\n", __FUNCTION__);
-
+#if defined PLACEBO
+	const char *d;
+	d = cPlugin::ConfigDirectory("shaders");
+	strcpy(MyConfigDir,d);
+#endif
     MyDevice = new cSoftHdDevice();
 
     return true;
@@ -3115,7 +3097,7 @@ bool cPluginSoftHdDevice::Start(void)
         }
     }
 
-	csoft = new cSoftRemote;
+    csoft = new cSoftRemote;
 
     switch (::Start()) {
         case 1:
@@ -3144,7 +3126,8 @@ void cPluginSoftHdDevice::Stop(void)
     // dsyslog("[softhddev]%s:\n", __FUNCTION__);
 
     ::Stop();
-	delete csoft;
+    delete csoft;
+
     csoft = NULL;
 }
 
@@ -3263,7 +3246,6 @@ bool cPluginSoftHdDevice::SetupParse(const char *name, const char *value)
         ConfigSuspendX11 = atoi(value);
         return true;
     }
-
     if (!strcasecmp(name, "Video4to3DisplayFormat")) {
         Config4to3DisplayFormat = atoi(value);
         VideoSet4to3DisplayFormat(Config4to3DisplayFormat);
@@ -3406,20 +3388,6 @@ bool cPluginSoftHdDevice::SetupParse(const char *name, const char *value)
         }
     }
 
-    if (!strcasecmp(name, "AutoCrop.Interval")) {
-        VideoSetAutoCrop(ConfigAutoCropInterval = atoi(value), ConfigAutoCropDelay, ConfigAutoCropTolerance);
-        ConfigAutoCropEnabled = ConfigAutoCropInterval != 0;
-        return true;
-    }
-    if (!strcasecmp(name, "AutoCrop.Delay")) {
-        VideoSetAutoCrop(ConfigAutoCropInterval, ConfigAutoCropDelay = atoi(value), ConfigAutoCropTolerance);
-        return true;
-    }
-    if (!strcasecmp(name, "AutoCrop.Tolerance")) {
-        VideoSetAutoCrop(ConfigAutoCropInterval, ConfigAutoCropDelay, ConfigAutoCropTolerance = atoi(value));
-        return true;
-    }
-
     if (!strcasecmp(name, "AudioDelay")) {
         VideoSetAudioDelay(ConfigVideoAudioDelay = atoi(value));
         return true;
@@ -3429,11 +3397,11 @@ bool cPluginSoftHdDevice::SetupParse(const char *name, const char *value)
         return true;
     }
     if (!strcasecmp(name, "AudioPassthrough")) {
-        int i;
+        int ii;
 
-        i = atoi(value);
-        AudioPassthroughState = i > 0;
-        ConfigAudioPassthrough = abs(i);
+        ii = atoi(value);
+        AudioPassthroughState = ii > 0;
+        ConfigAudioPassthrough = abs(ii);
         if (AudioPassthroughState) {
             CodecSetAudioPassthrough(ConfigAudioPassthrough);
         } else {
@@ -3675,7 +3643,6 @@ static const char *SVDRPHelpText[] = {
         "    12: toggle audio pass-through\n" "    13: decrease audio delay by 10ms\n"
         "    14: increase audio delay by 10ms\n" "    15: toggle ac3 mixdown\n"
         "    20: disable fullscreen\n\040   21: enable fullscreen\n" "    22: toggle fullscreen\n"
-        "    23: disable auto-crop\n\040   24: enable auto-crop\n" "    25: toggle auto-crop\n"
         "    30: stretch 4:3 to display\n\040   31: pillar box 4:3 in display\n"
         "    32: center cut-out 4:3 to display\n" "    39: rotate 4:3 to display zoom mode\n"
         "    40: stretch other aspect ratios to display\n" "    41: letter box other aspect ratios in display\n"

softhddev.h

@@ -96,7 +96,7 @@ extern "C"
     extern void Resume(void);
 
     /// Get decoder statistics
-    extern void GetStats(int *, int *, int *, int *, float *);
+    extern void GetStats(int *, int *, int *, int *, float *, int *, int *, int *, int *);
     /// C plugin scale video
     extern void ScaleVideo(int, int, int, int);
 

video.h

@@ -44,7 +44,7 @@ extern signed char VideoHardwareDecoder;    ///< flag use hardware decoder
 extern char VideoIgnoreRepeatPict;      ///< disable repeat pict warning
 extern int VideoAudioDelay;             ///< audio/video delay
 extern char ConfigStartX11Server;       ///< flag start the x11 server
-
+extern char MyConfigDir[];
 //----------------------------------------------------------------------------
 //  Prototypes
 //----------------------------------------------------------------------------
@@ -179,9 +179,6 @@ extern void VideoSetBackground(uint32_t);
 /// Set audio delay.
 extern void VideoSetAudioDelay(int);
 
-/// Set auto-crop parameters.
-extern void VideoSetAutoCrop(int, int, int);
-
 /// Clear OSD.
 extern void VideoOsdClear(void);
 
@@ -219,7 +216,7 @@ extern uint8_t *VideoGrab(int *, int *, int *, int);
 extern uint8_t *VideoGrabService(int *, int *, int *);
 
 /// Get decoder statistics.
-extern void VideoGetStats(VideoHwDecoder *, int *, int *, int *, int *, float *);
+extern void VideoGetStats(VideoHwDecoder *, int *, int *, int *, int *, float *, int *, int *, int *, int *);
 
 /// Get video stream size
 extern void VideoGetVideoSize(VideoHwDecoder *, int *, int *, int *, int *);
@@ -234,7 +231,7 @@ extern void VideoExit(void);            ///< Cleanup and exit video module.
 extern int VideoPollInput(VideoStream *);
 
 /// Decode video input buffers.
-extern int VideoDecodeInput(VideoStream *);
+extern int VideoDecodeInput(VideoStream *, int);
 
 /// Get number of input buffers.
 extern int VideoGetBuffers(const VideoStream *);
@@ -245,9 +242,20 @@ extern void SetDPMSatBlackScreen(int);
 /// Raise the frontend window
 extern int VideoRaiseWindow(void);
 
+/// Set Shaders
+extern int VideoSetShader(char *);
+
 #ifdef USE_OPENGLOSD
 extern void ActivateOsd(GLuint, int, int, int, int);
 #endif
+
+#ifdef GAMMA
+extern void Init_Gamma();
+extern void Exit_Gamma();
+extern void Set_Gamma(float, int);
+extern void Get_Gamma();
+#endif
+
 #if 0
 long int gettid()
 {