root/core/autoiso.c

/* [<][>][^][v][top][bottom][index][help] */

DEFINITIONS

This source file includes following definitions.
  1. live_histogram_read_y
  2. live_histogram_get_range
  3. shooting_calc_autoiso_coef
  4. shooting_recalc_conf_autoiso_values
  5. shooting_set_autoiso

   1 #include "camera_info.h"
   2 #include "math.h"
   3 #include "conf.h"
   4 #include "viewport.h"
   5 #include "shooting.h"
   6 #include "modes.h"
   7 #include "lens.h"
   8 
   9 //-------------------------------------------------------------------
  10 // AUTO ISO
  11 
  12 //////////////////////////////////////////////////////////////////////////////////////////////
  13 // @tsv
  14 // Module below calculate live histogram in same way as OSD histogram
  15 // Difference from shot_histogram family is that live_histogram give answer before shot
  16 // Regular histogram_process cannot be used, because raw non-summarized 0.255 values required
  17 // This module is used in AutoISO2 mechanizm.
  18 //////////////////////////////////////////////////////////////////////////////////////////////
  19 
  20 // This uses 30 'Y' values from each row (or seccond row for cameras with 2x height YUV viewports).
  21 // Is summing 30 columns of data a good selection for histogram?
  22 
  23 // Define how many viewport bytes to step in each loop iteration. Skip 6 sets of 4 pixels.
  24 #ifdef THUMB_FW
  25 // Digic 6: Each block is 4 bytes (UYVY) 2 Y values
  26 #define HISTO_STEP_SIZE 48
  27 #else
  28 // Each block is 6 bytes (UYVYYY) / 4 Y values
  29 #define HISTO_STEP_SIZE 36
  30 #endif
  31 
  32 static unsigned short live_histogram_proc[256]; // Buffer for histogram
  33 
  34 /*
  35 build histogram of viewport Y values (downsampled by HISTO_STEP_SIZE)
  36 NOTE also used by lua get_live_histo
  37 */
  38 int live_histogram_read_y(unsigned short *h)
  39 {
  40     int yscale = vid_get_viewport_yscale();   // Y scale factor (2 for 480 line high lv buffer)
  41 #ifdef THUMB_FW
  42     int vp_width = vid_get_viewport_width_proper() * 2;             // X bytes per row
  43 #else
  44     int vp_width = vid_get_viewport_width_proper() * 6 / 4;         // X bytes per row
  45 #endif
  46     int vp_height = vid_get_viewport_height_proper() / yscale;      // Number of rows to process (every second row if 480 high lv buffer)
  47 
  48     int total = (vp_width * vp_height) / HISTO_STEP_SIZE;
  49 
  50     unsigned char *img = vid_get_viewport_active_buffer();
  51     if (img)
  52     {
  53         if (h == 0) h = live_histogram_proc;
  54         memset(h, 0, sizeof(unsigned short)*256);
  55 
  56         int vp_offset = vid_get_viewport_byte_width() * yscale;     // Bytes length of each row (or double row)
  57         img += vid_get_viewport_image_offset() + 1; // Skip border and move to 1st Y component in each block
  58 
  59         int x, y;
  60         for (y=0; y<vp_height; y+=1, img+=vp_offset)
  61         {
  62             for (x=HISTO_STEP_SIZE/2; x<vp_width; x+=HISTO_STEP_SIZE)
  63             {
  64                 h[img[x]] += 1;
  65 //                img[x] = img[x+2] = 255;  // Change sampled values on screen for debugging
  66             }
  67         }
  68     }
  69 
  70     return total;
  71 }
  72 
  73 static int live_histogram_get_range(int total,int from, int to)
  74 {
  75     if (from < 0) from = 0;
  76     if (to > 255) to = 255;
  77 
  78     int rv = 0;
  79     for(; from<=to; from++)
  80         rv += live_histogram_proc[from];
  81 
  82     return (rv * 100) / total;
  83 }
  84 
  85 //-------------------------------------------------------------------
  86 
  87 static const int shutter1_values[] = { 0, 2, 4, 6, 8, 15, 30, 60, 125, 250, 500, 1000, 2000 };
  88 static const int shutter2_values[] = { 0, 1, 2, 4, 6, 8, 12, 15, 20, 25, 30, 40, 50, 60, 80, 100, 125, 160, 200, 250, 500, 1000, 2000 };
  89 
  90 static void shooting_calc_autoiso_coef( int min_shutter )
  91 {
  92     if (shutter2_values[conf.autoiso2_shutter_enum] >= min_shutter)
  93     {
  94         conf.autoiso2_coef = 0.0;
  95     }
  96     else
  97     {
  98         conf.autoiso2_coef = (float)(conf.autoiso2_max_iso_auto_real - conf.autoiso_max_iso_auto_real) / 
  99             (float)( shutter2_values[conf.autoiso2_shutter_enum] - min_shutter);
 100     }
 101 }
 102 
 103 static void shooting_recalc_conf_autoiso_values()
 104 {
 105     // convert market to real iso
 106     conf.autoiso_max_iso_hi_real    = shooting_iso_market_to_real(conf.autoiso_max_iso_hi) ;
 107     conf.autoiso_max_iso_auto_real  = shooting_iso_market_to_real(conf.autoiso_max_iso_auto) ; 
 108     conf.autoiso_min_iso_real       = shooting_iso_market_to_real(conf.autoiso_min_iso) ;      
 109     conf.autoiso2_max_iso_auto_real = shooting_iso_market_to_real(conf.autoiso2_max_iso_auto) ;
 110 
 111     // There are two exceptional situation: 
 112     // 1. shutter_numerator2 should be < shutter_numerator1, otherwise exceptional situation 
 113     // 2. autoiso2 <= autoiso1
 114     if ( !shutter2_values[conf.autoiso2_shutter_enum] )
 115         conf.autoiso2_max_iso_auto_real = conf.autoiso_max_iso_auto_real;
 116 
 117     // C2=( iso2_max_auto_real - iso_max_auto_real) / ( tv_num[autoiso2_shutter] - tv_numerator[autoiso_shutter])
 118     shooting_calc_autoiso_coef( shutter1_values[conf.autoiso_shutter_enum] );
 119 }
 120 
 121 void shooting_set_autoiso(int iso_mode)
 122 {
 123     short max_iso;
 124 
 125     if (iso_mode<=0)
 126         shooting_recalc_conf_autoiso_values();
 127 
 128     switch (iso_mode)
 129     {
 130     case -1: // ISO HI
 131         //max_iso = conf.autoiso_max_iso_hi*10;
 132         max_iso = conf.autoiso_max_iso_hi_real;
 133         break;
 134     case 0: // ISO AUTO
 135         //max_iso = conf.autoiso_max_iso_auto*10;
 136         max_iso = conf.autoiso_max_iso_auto_real;
 137         break;
 138     default:
 139         return;
 140     }
 141 
 142     // TODO also long shutter ?
 143     if (camera_info.state.mode_shooting==MODE_M || camera_info.state.mode_shooting==MODE_TV || camera_info.state.mode_shooting==MODE_STITCH)
 144         return; //Only operate outside of M and Tv
 145 
 146     int ev_overexp = 0;
 147     if (conf.overexp_ev_enum)
 148     {
 149         // No shoot_histogram exist here because no future shot exist yet :)
 150         int total = live_histogram_read_y(live_histogram_proc);
 151 
 152         // step 32 is 1/3ev for tv96
 153         if (live_histogram_get_range(total,255-conf.autoiso2_over,255) >= conf.overexp_threshold)
 154             ev_overexp = conf.overexp_ev_enum << 5; 
 155     }
 156 
 157     float current_shutter = shooting_get_shutter_speed_from_tv96(shooting_get_tv96());
 158 
 159     short current_iso = shooting_get_iso_real();
 160 
 161     short min_shutter = shutter1_values[conf.autoiso_shutter_enum];
 162     if (min_shutter == 0)
 163     {
 164         short IS_factor = (shooting_get_is_mode()<=1)?conf.autoiso_is_factor:1;
 165         min_shutter = get_focal_length(lens_get_zoom_point())*conf.autoiso_user_factor / (IS_factor*1000);
 166         //min_shutter is NOT 1/Xs but optimized for the calculation.
 167         if (shutter2_values[conf.autoiso2_shutter_enum])
 168             shooting_calc_autoiso_coef( min_shutter );
 169     }
 170 
 171     short target_iso = current_iso * min_shutter * current_shutter;
 172     short min_iso = conf.autoiso_min_iso_real;
 173 
 174     if (target_iso > max_iso)
 175     {
 176         ev_overexp=0;
 177 
 178         // AutoISO2 if
 179         //      it is turned on (C2!=0.0)
 180         //      and it has valid iso2/shutter2 ( C2<0)
 181         //       and non-IsoHI mode
 182         if ( !iso_mode && conf.autoiso2_coef < 0.0 )
 183         {
 184             target_iso = (max_iso - min_shutter*conf.autoiso2_coef) / ( 1.0 - conf.autoiso2_coef  / (current_shutter * current_iso) );
 185             if ( target_iso > conf.autoiso2_max_iso_auto_real )
 186                 target_iso = conf.autoiso2_max_iso_auto_real;
 187         }
 188         else
 189         {
 190             target_iso = max_iso;
 191         }
 192     }
 193     else if (target_iso < min_iso)
 194     {
 195         target_iso = min_iso;
 196     }
 197 
 198     float target_shutter = current_shutter *  current_iso / target_iso;
 199 
 200         if (target_shutter > 0)
 201         shooting_set_tv96_direct(shooting_get_tv96_from_shutter_speed(target_shutter) + ev_overexp, SET_NOW);
 202 
 203     shooting_set_iso_real(target_iso, SET_NOW);
 204 }
 205 
 206 //-------------------------------------------------------------------

/* [<][>][^][v][top][bottom][index][help] */