; -*- lisp -*- ; The line above sets the editors to LISP mode, which probably ; is the mode with best syntax highlighting for this file. ; This configuration file requires the LISP-esque example ; configuration scripts ; Both ; (semicolon) and # (pound) start commands ending the end of the line ; If you know LISP, you might find this the be a bit different, ; it is only superficially like LISP. Anthing it is inside brackets ; is a list of strings. A string starting with a colon is a function ; call with next string being its argument, or the next list being ; its arguments. The first string in a list may or may not be function ; call, depending on situation; it can be first not to be bit adding ; a dot the string before it, the first string is ignored if it is a dot. ; Quotes have no effect other than cancelling out the effect of whitespace. (blueshift ; Indices of monitors to use. (monitors) ; For all monitors ; For the primary monitor: (monitors 0) ; For the first two monitors: (monitors 0 1) ; For the primary on the screen 0 and screen 1: (monitors 0:0 1:0) ; For all monitors on screen 0: (monitors 0:) ; For monitors with output name DVI-0: (monitors :crtc "DVI-0") ; For monitors with output name DVI-0 or VGA-0: (monitors :crtc ("DVI-0" "VGA-0")) ; For monitors with size 364 mm × 291 mm: (monitors :size (364 291)) ; Geographical coodinates: latitude longitude (northwards and eastwards in degrees) (coordinates 59.3472 18.0728) ; If you have this store in ~/.location you can use ; (coordinates :parse (read "~/.location")) ; If the command `~/.location` prints the information you can use ; (coordinates :parse (spawn "~/.location")) ; Or if you want to the location to be updates continuously: ; (coordinates:cont :parse (spawn "~/.location")) ; You can also store the text "(coordinates 59.3472 18.0728)" in ; file named ~/.location: ; :include "~/.location" ; A more advance alternative is to have a Python file named "~/.location.py" ; that is parsed and have its function `location` invoked with not arguments: ; (source "~/.location.py") ; (coordinates :eval "location()") ; If location can continuously update your location you can use: ; (source "~/.location.py") ; (coordinates:cont :eval location) ; You can combine having a static location and continuously updating, ; which allows Blueshift to use the static location if the dynamic cannot ; be fetch when Blueshift starts: ; (coordinates 59.3472 18.0728) ; (coordinates:cont :parse (spawn "~/.location")) ; Time points when different settings are applied, continuous transition ; betweem them will be used. This are not used by default, be can be ; enabled in the next section. (timepoints 2:00 8:00 22:00) ; Select method for calculating the time the different settings are (fully) applied (points solar) ; Use the two default solar elevations ; (points solar :eval SOLAR_ELEVATION_ASTRONOMICAL_DUSK_DAWN :eval SOLAR_ELEVATION_SUNSET_SUNRISE) ; Use two standard solar elevations ; (points solar -18 -12 -6 0 6) ; Use four custom solar elevations ; (points time) ; Use the time points from (timepoints) (from the previous section) ; (points constant) ; Assume it 100 % are day long, and exit when settings have been applied. ; (One shot mode instead of continuous mode) ; If you have multiple values in (points) they can be reduced to two: ; (dayness 0 1 1) ; For example, if we have (points time) and (timepoints 2:00 8:00 22:00) ; than (dayness 0 1 1) will reduce it so that the settings only have to ; define values for day and night (in that order). At 2:00 it would be ; 100 % night, and at 8:00 to 22:00 it would be 100 % day. ; Colour curve applying method. (method randr) ### --- MODERATE LEVEL --- ; Alternatively (limited to primary monitors): (method vidmode) ; For debugging (or passing to another application) you can use ; (method print) ; It is possible to use both: ; (method print randr) (transfrom randr) ; yes, this it says ‘from’ not ‘form’ ; This lets Blueshift transition from the currently applied settings ; when it starts. If you prefer to use vidmode instead of randr you ; can use ; (transfrom randr) ; If you do not want to do this you can use ; (transfrom nil) ; It an also be configured individually for the monitors: ; (transfrom randr nil) ; This will not do this for the second monitor ;; Important: The following options are applied in order of appearance ;; moving them around can cause inexact monitors calibration ;; or other unwanted effects. But it could perhaps also do ;; something wonderful. ; ICC profile for video filtering (monitor calibration will be later.) ; Replace `nil` with the pathname of the profile. It is assumed to not be ; already applied and it is assumed that it should not be applied on exit. #(icc:filter nil) ### --- MODERATE LEVEL --- ; If you have three monitors: (icc:filter (nil nil nil)) ; On all the monitors but time dependent: (icc:filter nil nil) ; The two above combined: (icc:filter (nil nil nil) (nil nil nil)) ; Negative image settings. (negative no) ; Does nothing ; (negative yes) ; Inverts the colours on the encoding axes ; (negative (yes no no)) ; Inverts the red colour on the encoding axis ; (negative yes no) ; Inverts the colours on the encoding axes on the first monitor ; ; but not the second monitor selected by (monitors) ; (invert yes) ; Inverts the colours on the output axes using the sRGB colour space ; (invert (yes no no)) ; Inverts the red colour on the output axes using the sRGB colour space ; (invert:cie yes) ; Inverts the colours on the output axes using the CIE xyY colour space ; These cannot be time dependent. ; Colour temperature at high day and high night, respectively. (temperature 6500 3700) ; If you the second monitor selected by (monitors) to always be at 6500K you can use ; (temperature (6500 6500) (3700 6500)) ### --- EXPERT LEVEL --- ; If you want a more advance calculation of the correlated colour ; temperature you can replace (temperature) in the step about with ; (temperature') and add the following *before* it: ; (compose temperature' as-is (divide_by_maximum cmf_10deg)) ; This is the default, but you can also use for example and of the following: ; (compose temperature' as-is (divide_by_maximum series_d)) ; (compose temperature' as-is (clip_whitepoint simple_whitepoint)) ; (compose temperature' as-is (divide_by_maximum cmf_2deg)) ; (compose temperature' as-is redshift') ; Where Redshift' needs to be composed by temperature': ; (compose redshift' as-is yes) ; as in redshift<=1.8 ; (compose redshift' as-is no) ; as in redshift>1.8 ; (compose redshift' as-is yes yes) ; as in redshift<=1.8 but interpolating in linear RGB ; (compose redshift' as-is no yes) ; as in redshift>1.8 but interpolating in linear RGB ; See `info blueshift 'configuration api' 'colour curve manipulators'` ; and look for ‘temperature’ for details. ; It is possible to calibrations that were applied when Blueshift started. #(current nil) ### --- EXPERT LEVEL --- ; This is ignored if --panicgate is used (it is assumed that Blueshift ; crashed if --panicgate is used). It also has no effect in one shot mode. ; `nil` means that it does nothing, but you can also use `randr` or ; `vidmode`, but `vidmode` is restricted to primary monitors: ; (current randr) ; of using randr ; (current vidmode) ; of using vidmode ; You can also controll the monitors individually: ; (current randr nil) ; does this only for the first monitor ; Colour brightness at high day and high night, respectively. ; This setting uses the CIE xyY colour space for calculating values. (brightness:cie 1 1) ; If you have multiple monitors, they can be configured indiviudally. ; For example if you have two monitors, we can keep the first monitor ; on full brightness all day long, but make the second monitor be ; at 75 % during the night: ; (brightness:cie (1 1) (1 0.75)) ; Colour brightness of the red, green and blue components, ; respectively, at high day and high night, respectively. ; This settings uses the sRGB colour space for calculating values. (brightness (1 1 1) (1 1 1)) ### --- MODERATE LEVEL --- ; Because red, green and blue are identical in this example, ; writting (brightness 1 1) instead with do the same thing. ; If you want the second monitor selected by (monitors) to always ; be at 100 % but the primary to shift between 100 % and 75 % you can use ; (brightness ((1) (1)) ((1) (0.75))) ; As this indicates you use the following if you want only the blue ; part to shift to 75 %: ; (brightness ((1) (1)) ((1) (0.75 1 1))) ; Or alternatively: ; (brightness:red (1 1) (1 0.75)) ; Colour contrast at high day and high night, respectively. ; This setting uses the CIE xyY colour space for calculating values. #(contrast:cie 1 1) ### --- MODERATE LEVEL --- ; This can be done monitors dependently as in (brightness:cie). ; Colour contrast of the red, green and blue components, ; respectively, at high day and high night, respectively. ; This settings uses the sRGB colour space for calculating values. #(contrast (1 1 1) (1 1 1)) ### --- MODERATE LEVEL --- ; Because red, green and blue are identical in this example, ; writting (contrast 1 1) instead with do the same thing. ; This can be done monitors dependently as in (brightness). ;; Note: brightness and contrast is not intended for colour ;; calibration, it should be calibrated on the monitors' ;; control panels. ; These are fun curve manipulator settings that lowers the ; colour resolution ont encoding and output axes respectively. ; In this example (resolution:encoding) only has one argument, ; it applies all day long on each colour curve. #(resolution:encoding :eval i_size) ### -- ADVANCED LEVEL -- ; This is evaluated into: ; (resolution:encoding 256) ; (resolution:output) in this example one argument that is ; a tuple of three values which represent red, green, and ; blue respectively. Because it is only one argument it ; applies all day long as well. #(resolution:output (:eval (o_size o_size o_size))) ### -- ADVANCED LEVEL -- ; This is evaluated into: ; (resolution:output (65536 65536 65536)) ; As always you can control the monitors individually: ; (resolution:output (:eval ((o_size o_size o_size) (o_size o_size o_size)))) ; This evaluated into: ; (resolution:output ((65536 65536 65536) (65536 65536 65536))) ; Gamma correction for the red, green and blue components, respectively, ; at high day, high night and monitor default, respectively. ; This settings uses the sRGB colour space for calculating values. #(gamma (1 1 1) (1 1 1)) ### --- MODERATE LEVEL --- (gamma:default (1 1 1)) ; All configurations can use :default, but it only makes since ; for gamma because it is the only actual monitors calibration ; configurations, with the exception of ICC profiles and white ; point and black point calibration and sigmoid curve correction. ; (gamma) automatically run (clip) to avoid mathematical errors, ; If you prefer not to run (clip) you can use ; ('gamma (1 1 1) (1 1 1)) ; ('gamma:default (1 1 1)) ; You can also run clip manually: ; (clip) ; Or for the first but not second monitor: ; (clip yes no) ; Clipping cannot time dependent. ;; Note: gamma is supposted to be static, it purpose is to ;; correct the colours on the monitors the monitor's gamma ;; is exactly 2,2 and the colours look correct in relation ;; too each other. It is supported to have different settings ;; at day and night because there are no technical limitings ;; and it can presumable increase readability on text when ;; the colour temperature is low. ; If you have an LCD monitor you can use (well you could on CRT as ; well but it would not make since) sigmoid curve correction to ; calibrate your monitor. 4.5 is a good value to start testing at, ; but be aware, it is very difficult to get right is it depens on ; other calibrations as well. For now we have `nil` which means that ; no sigmoid curve correction will take place. #(sigmoid:default (nil nil nil)) ### -- EXPERT LEVEL -- ; This three `nil`:s are for red, green and blue respectively, ; but you can just one argument instead of a tuple of three, if ; the colour curves should have the same sigmoid curve correction. ; If you have two monitors you can use (and replace nil with ; your correction parameters): ; (sigmoid:default (nil nil nil) (nil nil nil)) ; or ; (sigmoid:default nil nil) ; You can also so time dependent correction: #(sigmoid (nil nil nil) (nil nil nil)) ### -- EXPERT LEVEL -- ; (sigmoid ((nil nil nil) (nil nil nil)) ((nil nil nil) (nil nil nil))) ; (sigmoid (nil nil) (nil nil)) ; If you have require software level brightness and contract ; calibration (needed to calibrate most LCD monitors), you and ; use (limits) and (limits:cie). These will calibrate the ; black point (brightness) and the white point (contrast). This ; brightness and contrast is not the same thing as the settings ; (brightness) and (contrast). (brightness) is more similar to ; backlight and (contrast) is a flattening of the colour curves ; towards 50 %. In (limits:cie) and first argument (for each time) ; is the brightness [black point] and the second is the [white point]. #(limits:cie:default 0 1) ### -- ADVANCED LEVEL -- ; If you have three monitors they can be controlled individually: ; (limits:cie:default (0 1) (0 1) (0 1)) ; You can so also do time dependent correction: ;(cie_limits (0 1) (0 1)) ; (limits:cie ((0 1) (0 1) (0 1)) ((0 1) (0 1) (0 1))) ; ICC profile for monitor calibration will be later. ; Replace `nil` with the pathname of the profile. It is assumed to ; already be applied and that it should be applied on exit. #(icc:calib nil) ### -- MODERATE LEVEL -- ; If you have three monitors: (icc (nil nil nil)) ; On all the monitors but time dependent: (icc nil nil) ; The two above combined: (icc (nil nil nil) (nil nil nil)) ; (icc) is a synonym for (icc:calib). ### -- EXPERT LEVEL -- ; It is also possible to some of your own manipulations: ; where is an example that temporary switches to linear RGB ; change makes the colour curves logarithmical: ; (linearise) ; (manipulate 'lambda x : math.log(x + 1, 2)') ; Or for the colour colurves individually: ; (manipulate 'lambda x : math.log(x + 1, 2)' ; 'lambda x : math.log(x + 1, 2)' ; 'lambda x : math.log(x + 1, 2)' ; ) ; (standardise) ; As with (clip) (linearise) and (standardise) can depend ; on the monitor, so can (manipulate): ; (linearise yes no) ; (manipulate 'lambda x : math.log(x + 1, 2)') ; Or for the colour colurves individually: ; (manipulate ('lambda x : math.log(x + 1, 2)' ; 'lambda x : math.log(x + 1, 2)' ; 'lambda x : math.log(x + 1, 2)' ; ) ; nil ; Do nothing on the second monitor ; ) ; (standardise yes no) )