Add light_context_mode enum and '-e' option for exponential light changing.

src/light.c

 #include <inttypes.h> // PRIu64
 
 /* Static helper functions for this file only, prefix with _ */
-
+#include <math.h>
 
 static void _light_add_enumerator_device(light_device_enumerator_t *enumerator, light_device_t *new_device)
 {
     return NULL;
 }
 
-static bool _light_raw_to_percent(light_device_target_t *target, uint64_t inraw, double *outpercent)
+static bool _light_raw_to_percent(light_context_t *ctx, uint64_t inraw, double *outpercent)
 {
+        light_device_target_t *target = ctx->run_params.device_target;
         double inraw_d = (double)inraw;
         uint64_t max_value = 0;
         if(!target->get_max_value(target, &max_value))
             return false;
         }
         double max_value_d = (double)max_value;
-        double percent = light_percent_clamp((inraw_d / max_value_d) * 100.0);
-        *outpercent = percent;
+        double percent = 0;
+        if(ctx->run_params.mode == LC_MODE_EXPONENTIAL)
+            percent = pow((inraw_d / max_value_d), 1.0 / LIGHT_EXPONENT) * 100.0;
+        else
+            percent = (inraw_d / max_value_d) * 100.0;
+        
+        *outpercent = light_percent_clamp(percent);
         
         return true;
 }
 
-static bool _light_percent_to_raw(light_device_target_t *target, double inpercent, uint64_t *outraw)
+static bool _light_percent_to_raw(light_context_t *ctx, double inpercent, uint64_t *outraw)
 {
+    light_device_target_t *target = ctx->run_params.device_target;
     uint64_t max_value = 0;
     if(!target->get_max_value(target, &max_value))
     {
     }
 
     double max_value_d = (double)max_value;
-    double target_value_d = max_value_d * (light_percent_clamp(inpercent) / 100.0);
+    double target_value_d = 0;
+    if(ctx->run_params.mode == LC_MODE_EXPONENTIAL)
+        target_value_d = max_value_d * pow(light_percent_clamp(inpercent) / 100.0, LIGHT_EXPONENT);
+    else
+        target_value_d = max_value_d * (light_percent_clamp(inpercent) / 100.0);
     uint64_t target_value = LIGHT_CLAMP((uint64_t)target_value_d, 0, max_value);
     *outraw = target_value;
     
         "\n"
         "Options:\n"
         "  -r          Interpret input and output values in raw mode (ignored for -T)\n"
+        "  -e          Interpret input and output values in exponential mode (ignored for -r and -T)\n"
         "  -s          Specify device target path to use, use -L to list available\n"
         "  -v          Specify the verbosity level (default 0)\n"
         "                 0: Values only\n"
     bool need_target = true; // default cmd is get brightness
     bool specified_target = false;
     snprintf(ctrl_name, sizeof(ctrl_name), "%s", "sysfs/backlight/auto");
-    
-    while((curr_arg = getopt(argc, argv, "HhVGSLMNPAUTOIv:s:r")) != -1)
+
+    while((curr_arg = getopt(argc, argv, "HhVGSLMNPAUTOIv:s:re")) != -1)
     {
         switch(curr_arg)
         {
                 specified_target = true;
                 break;
             case 'r':
-                ctx->run_params.raw_mode = true;
+                ctx->run_params.mode = LC_MODE_RAW;
+                break;
+            case 'e':
+                ctx->run_params.mode = LC_MODE_EXPONENTIAL;
                 break;
             
             // Commands
                 break;
             case 'T':
                 _light_set_context_command(ctx, light_cmd_mul_brightness);
+                ctx->run_params.mode = LC_MODE_PERCENTAGE;
                 need_target = true;
                 need_float_value = true;
                 break;
 
     if(need_value)
     {
-        if(ctx->run_params.raw_mode)
+        if(ctx->run_params.mode == LC_MODE_RAW)
         {
             if(sscanf(argv[optind], "%lu", &ctx->run_params.value) != 1)
             {
                 return false;
             }
             
-            percent_value = light_percent_clamp(percent_value);
-            
-            uint64_t raw_value = 0;
-            if(!_light_percent_to_raw(ctx->run_params.device_target, percent_value, &raw_value))
-            {
-                LIGHT_ERR("failed to convert from percent to raw for device target");
-                return false;
-            }
-            
-            ctx->run_params.value = raw_value;
+            percent_value = light_percent_clamp(percent_value);                        
+            need_float_value = true;
         }
     }
 
     new_ctx->run_params.command = NULL;
     new_ctx->run_params.device_target = NULL;
     new_ctx->run_params.value = 0;
-    new_ctx->run_params.raw_mode = false;
+    new_ctx->run_params.mode = LC_MODE_PERCENTAGE;
 
     uid_t uid = getuid();
     uid_t euid = geteuid();
         return false;
     }
     
-    if(ctx->run_params.raw_mode)
+    if(ctx->run_params.mode == LC_MODE_RAW)
     {
         printf("%" PRIu64 "\n", value);
     }
     else 
     {
         double percent = 0.0;
-        if(!_light_raw_to_percent(target, value, &percent))
+        if(!_light_raw_to_percent(ctx, value, &percent))
         {
             LIGHT_ERR("failed to convert from raw to percent from device target");
             return false;
         return false;
     }
     
-    if(!ctx->run_params.raw_mode)
+    if(ctx->run_params.mode == LC_MODE_PERCENTAGE ||
+       ctx->run_params.mode == LC_MODE_EXPONENTIAL)
     {
         printf("100.0\n");
         return true;
     uint64_t minimum_value = 0;
     if(!light_file_read_uint64(target_path, &minimum_value))
     {
-        if(ctx->run_params.raw_mode)
+        if(ctx->run_params.mode == LC_MODE_RAW)
         {
             printf("0\n");
         }
         return true;
     }
     
-    if(ctx->run_params.raw_mode)
+    if(ctx->run_params.mode == LC_MODE_RAW)
     {
         printf("%" PRIu64 "\n", minimum_value);
     }
     else 
     {
         double minimum_d = 0.0;
-        if(!_light_raw_to_percent(ctx->run_params.device_target, minimum_value, &minimum_d))
+        if(!_light_raw_to_percent(ctx, minimum_value, &minimum_d))
         {
             LIGHT_ERR("failed to convert value from raw to percent for device target");
             return false;
         LIGHT_ERR("failed to read from target");
         return false;
     }
+
+    double percent = 0.0;
     
-    value += ctx->run_params.value;
+    switch(ctx->run_params.mode)
+    {
+    case LC_MODE_RAW:    
+        value += ctx->run_params.value;
+        break;
+    case LC_MODE_PERCENTAGE:
+    case LC_MODE_EXPONENTIAL:
+        if(!_light_raw_to_percent(ctx, value, &percent))
+        {
+            LIGHT_ERR("failed to convert value from raw to percent for device target");
+            return false;
+        }
+        percent += ctx->run_params.float_value;
+        if(!_light_percent_to_raw(ctx, percent, &value))
+        {
+            LIGHT_ERR("failed to convert value from percent to raw for device target");
+            return false;
+        }        
+        break;
+    }
     
     uint64_t mincap = _light_get_min_cap(ctx);
     if(mincap > value)
     {
         value = mincap;
     }
-    
-    
     if(value > max_value)
     {
         value = max_value;
         LIGHT_ERR("failed to write to target");
         return false;
     }
-    
     return true;
 }
 
         LIGHT_ERR("failed to read from target");
         return false;
     }
+
+    double percent = 0.0;
     
-    if(value > ctx->run_params.value)
-    {
-        value -= ctx->run_params.value;
-    }
-    else 
+    switch(ctx->run_params.mode)
     {
-        value = 0;
+    case LC_MODE_RAW:
+        if(value > ctx->run_params.value)
+            value -= ctx->run_params.value;
+        else 
+            value = 0;
+        break;
+    case LC_MODE_PERCENTAGE:
+    case LC_MODE_EXPONENTIAL:
+        if(!_light_raw_to_percent(ctx, value, &percent))
+        {
+            LIGHT_ERR("failed to convert value from raw to percent for device target");
+            return false;
+        }
+        if(percent > ctx->run_params.float_value)
+            percent -= ctx->run_params.float_value;
+        else
+            percent = 0;
+        if(!_light_percent_to_raw(ctx, percent, &value))
+        {
+            LIGHT_ERR("failed to convert value from percent to raw for device target");
+            return false;
+        }        
+        break;
     }
     
     uint64_t mincap = _light_get_min_cap(ctx);

src/light.h

 typedef bool (*LFUNCMAXVALGET)(light_device_target_t*, uint64_t*);
 typedef bool (*LFUNCCUSTOMCMD)(light_device_target_t*, char const *);
 
+/* Constant for exponential mode */
+#define LIGHT_EXPONENT 4.0
+
 /* Describes a target within a device (for example a led on a keyboard, or a controller for a backlight) */
 struct _light_device_target_t
 {
 // A command that can be run (set, get, add, subtract, print help, print version, list devices etc.)
 typedef bool (*LFUNCCOMMAND)(light_context_t *);
 
+typedef enum _light_context_mode {
+    LC_MODE_PERCENTAGE,
+    LC_MODE_RAW,
+    LC_MODE_EXPONENTIAL
+} light_context_mode;
+
 struct _light_context_t
 {
     struct 
         // Only one of value and raw_value is populated; which one depends on the command
         uint64_t                value; // The input value, in raw mode
         float                   float_value; // The input value as a float
-        bool                    raw_mode; // Whether or not we use raw or percentage mode
+        light_context_mode      mode; // Whether or not we use raw, exponential or percentage mode
         light_device_target_t   *device_target; // The device target to act on
     } run_params;