root/modules/histogram.c

DEFINITIONS

1. clip
2. identity
3. logarithmic
4. histogram_alloc
5. histogram_sample_stage
6. histogram_process
7. gui_osd_draw_single_histo
8. gui_osd_draw_blended_histo
9. gui_osd_draw_histo
10. _module_unloader
11. _module_can_unload

   1 #include "camera_info.h"
   2 #include "conf.h"
   3 #include "math.h"
   4 #include "modes.h"
   5 #include "viewport.h"
   6 #include "gui.h"
   7 #include "gui_draw.h"
   8 #include "gui_osd.h"
   9 #include "shooting.h"
  10 #include "histogram.h"
  12 //-------------------------------------------------------------------
  14 // Indexes into the various arrays for calculating the histogram channels
  15 #define HISTO_R                     0       // Red channel
  16 #define HISTO_G                     1       // Green channel
  17 #define HISTO_B                     2       // Blue channel
  18 #define HISTO_RGB                   3       // Combined Red, Green and Blue
  19 #define HISTO_Y                     4       // Luminance (Y) from viewport
  21 // Define type of transform to be done to scale the histogram to fit the available height
  22 #define HISTO_MODE_LINEAR           0
  23 #define HISTO_MODE_LOG              1
  25 // Display modes
  26 #define OSD_HISTO_LAYOUT_A          0       // A - RGB
  27 #define OSD_HISTO_LAYOUT_Y          1
  28 #define OSD_HISTO_LAYOUT_A_Y        2
  29 #define OSD_HISTO_LAYOUT_R_G_B      3
  30 #define OSD_HISTO_LAYOUT_A_yrgb     4
  31 #define OSD_HISTO_LAYOUT_Y_argb     5
  32 #define OSD_HISTO_LAYOUT_BLEND      6
  33 #define OSD_HISTO_LAYOUT_BLEND_Y    7
  34 #ifndef THUMB_FW
  35 #define HISTO_DOT_SIZE  3
  36 #else
  37 // digic 6 CHDK screen is ~480 lines instead for 240
  38 #define HISTO_DOT_SIZE  5
  39 #endif
  40 #define HISTO_DOT_PAD   (HISTO_DOT_SIZE + 2)
  42 // Approximate number of pixels to sample, subject to minimums step sizes
  43 // Actual number of samples may exceed target due to rounding/truncation in step calculations
  44 // Actual total must be less than 64K to allow storing histogram counts in unsigned short
  45 // 20k based on typical number in earlier implementation
  46 // cameras typically process 250-600 px/ms uncached, 300-1200 cached
  47 // NOTE target could be adjusted based on cam_info.cam_digic
  48 #define HISTO_TARGET_SAMPLES 20000
  49 // Minimum X step is 4, for alignment with YUV tuples (could technically be 2 on Digic >=6 cams with UYVY viewports)
  50 #define HISTO_XSTEP_MIN 4
  51 // Minimum Y step is 2, no need to sample more densely
  52 #define HISTO_YSTEP_MIN 2
  54 static unsigned char histogram[5][HISTO_WIDTH];             // RGBYG
  55 static unsigned short *histogram_proc[5] = { 0,0,0,0,0 };   // RGBYG (logic in histogram_process stage 0 ensures unsigned short is large enough)
  56 unsigned int histo_max[5], histo_max_center[5];             // RGBYG
  57 static float histo_max_center_invw[5];                      // RGBYG
  59 static long histo_magnification;
  60 static long under_exposed;
  61 static long over_exposed;
  63 static long histogram_stage=0;
  65 //-------------------------------------------------------------------
  66 // Histogram calculation functions
  68 // Clip value to byte range (for YUV -> RGB conversion)
  69 static int clip(int v)
  70 {
  71     if (v<0) v=0;
  72     else if (v>255) v=255;
  73     return v;
  74 }
  76 // Transform functions
  77 static float identity(float x)      { return x; }
  78 static float logarithmic(float x)   { return log(x); }
  80 static void histogram_alloc()
  81 {
  82     // Allocate arrays to store counts during processing
  83     // Each possible value is counted so the array sizes are set to 256, then these are summed to
  84     // convert down to desired width of 128.
  85     // This is faster than scaling each value as it is counted
  86     if (histogram_proc[0] == 0)
  87     {
histogram_proc[0] = malloc(5 * 256 * sizeof(unsigned short));
histogram_proc[1] = histogram_proc[0] + 256;
histogram_proc[2] = histogram_proc[1] + 256;
histogram_proc[3] = histogram_proc[2] + 256;
histogram_proc[4] = histogram_proc[3] + 256;
  93     }
  94 }
  97 /*
  98 do a single stage of reading YUV data from framebuffer
  99 Sampled area has margins of one step at top, right and left and bottom
 100 Each stage samples every 3rd ystep row
 101 */
 102 void histogram_sample_stage(unsigned char *img, int stage, int byte_width, int vis_byte_width, int height, int xstep_bytes, int ystep)
 103 {
 104     // start at stage'th ystep (1-3), plus one step in x
 105     unsigned char *p_row = img + stage*ystep*byte_width + xstep_bytes;
 106     // end one step short of height
 107     unsigned char *p_max = img + byte_width*(height-ystep);
 108     // number of from start to end of sampled row
 109     // -2 xstep_bytes for margins
 110     int row_sample_len = vis_byte_width - 2*xstep_bytes;
 112     // every 3rd ystep for each stage
 113     int ystep_bytes = ystep*byte_width*3;
 115     for(;p_row < p_max; p_row += ystep_bytes) {
 116         // start sample 1 step after start
 117         unsigned char *p = p_row;
 118         unsigned char *p_row_end = p_row + row_sample_len;
 119         for(;p < p_row_end; p+= xstep_bytes) {
 120             int y, v, u, hi;
y = p[1];
 122 #ifndef THUMB_FW
u = (signed char)p[0];
v = (signed char)p[2];
 125 #else
u = (int)p[0] - 128;
v = (int)p[2] - 128;
 128 #endif
 129 //                p[1] = p[3] = 255;    // Draw columns on screen for debugging
 131             ++histogram_proc[HISTO_Y][y];                       // Y
hi = clip(((y<<12)          + v*5743 + 2048)>>12);  // R
 133             ++histogram_proc[HISTO_R][hi];
hi = clip(((y<<12) - u*1411 - v*2925 + 2048)>>12);  // G
 135             ++histogram_proc[HISTO_G][hi];
hi = clip(((y<<12) + u*7258          + 2048)>>12);  // B
 137             ++histogram_proc[HISTO_B][hi];
 138         }
 139     }
 140 }
 142 void histogram_process()
 143 {
 144     static unsigned char *img;
 146     static int viewport_byte_width, viewport_height;
 148     static int viewport_vis_byte_width;
 149     static int xstep_bytes, ystep;
 151     int i, c;
 152     float (*histogram_transform)(float);
 153     unsigned int histo_fill[5];
 154     int histo_main;
 156     long exposition_thresh = camera_screen.size / 500;
 158     // Select transform function
 159     switch (conf.histo_mode)
 160     {
 161         case HISTO_MODE_LOG:
histogram_transform = logarithmic;
 163             break;
 164         case HISTO_MODE_LINEAR:
 165         default:
histogram_transform = identity;
 167             break;
 168     }
 170     // Select which calculated histogram channel determines magnification / scaling
 171     if (conf.histo_layout == OSD_HISTO_LAYOUT_Y || conf.histo_layout == OSD_HISTO_LAYOUT_Y_argb)
histo_main = HISTO_Y;
 173     else
histo_main = HISTO_RGB;
histogram_alloc();
 178     // This function is called in the main spytask loop roughly every 20msec
 179     // To avoid hogging all the CPU it performs it's work in stages controlled by histogram-stage
 180     // Stage  Function
 181     //   0      Initialize global variables used in next stages
 182     //   1,2,3  Count number of values for a third of the viewport image at each stage
 183     //   4      Calculate max values, over and under exposure setting
 184     //   5      Calculate the histogram display values
 185     switch (histogram_stage)
 186     {
 187         case 0: {
img = vid_get_viewport_active_buffer();
 189             if (!img) return;
img += vid_get_viewport_image_offset();             // offset into viewport for when image size != viewport size (e.g. 16:9 image on 4:3 LCD)
viewport_height = vid_get_viewport_height_proper();
viewport_byte_width = vid_get_viewport_byte_width();
 195             int viewport_pix_width = vid_get_viewport_width_proper();
 196             int total_pixels = viewport_pix_width * viewport_height;
 197             int xstep;
 199             if(total_pixels <= HISTO_XSTEP_MIN*HISTO_YSTEP_MIN*HISTO_TARGET_SAMPLES) {
xstep = HISTO_XSTEP_MIN;
ystep = HISTO_YSTEP_MIN;
 202             } else {
 203                 // initial y step based on min x step and total samples
ystep = total_pixels/(HISTO_XSTEP_MIN*HISTO_TARGET_SAMPLES);
 205                 // if Y step is large, redistribute some to X, keeping multiple of 4
 206                 // in practice only hit for FHD HDMI
 207                 if(ystep >= 5*HISTO_YSTEP_MIN) {
xstep = 2*HISTO_XSTEP_MIN;
ystep >>= 1;
 210                 } else {
xstep = HISTO_XSTEP_MIN;
 212                 }
 213             }
 216 #ifndef THUMB_FW
xstep_bytes = (xstep*3)/2; // 4 pixels = 6 bytes, step is multiple of 4
viewport_vis_byte_width = (viewport_pix_width*3)/2;
 219 #else
xstep_bytes = xstep*2;
viewport_vis_byte_width = viewport_pix_width*2;
 222 #endif
 224             for (c=0; c<5; ++c) {
memset(histogram_proc[c],0,256*sizeof(unsigned short));
histo_max[c] = histo_max_center[c] = 0;
 227             }
histogram_stage=1;
 230             break;
 231         }
 233         case 1:
 234         case 2:
 235         case 3: {
histogram_sample_stage(img, histogram_stage, viewport_byte_width, viewport_vis_byte_width, viewport_height, xstep_bytes, ystep);
 237             ++histogram_stage;
 238             break;
 239         }
 241         case 4:
 242             for (i=0, c=0; i<HISTO_WIDTH; ++i, c+=2) { // G
 243                 // Merge each pair of values into a single value (for width = 128)
 244                 // Warning: this is optimised for HISTO_WIDTH = 128, don't change the width unless you re-write this code as well.
 245 #ifndef THUMB_FW
histogram_proc[HISTO_Y][i] = histogram_proc[HISTO_Y][c] + histogram_proc[HISTO_Y][c+1];
histogram_proc[HISTO_R][i] = histogram_proc[HISTO_R][c] + histogram_proc[HISTO_R][c+1];
histogram_proc[HISTO_G][i] = histogram_proc[HISTO_G][c] + histogram_proc[HISTO_G][c+1];
histogram_proc[HISTO_B][i] = histogram_proc[HISTO_B][c] + histogram_proc[HISTO_B][c+1];
 250 #endif
 251                 // Calc combined RGB totals
histogram_proc[HISTO_RGB][i] = histogram_proc[HISTO_R][i] + histogram_proc[HISTO_G][i] + histogram_proc[HISTO_B][i];
 253             }
 255             // calculate maximums
 256             for (c=0; c<5; ++c) {
 257                 for (i=0; i<HISTO_WIDTH; ++i) {
 258                     if (histo_max[c]<histogram_proc[c][i])
histo_max[c]=histogram_proc[c][i];
 260                     if (histo_max_center[c]<histogram_proc[c][i] && i>=conf.histo_ignore_boundary && i<HISTO_WIDTH-conf.histo_ignore_boundary)
histo_max_center[c]=histogram_proc[c][i];
 262                 }
 264                 if (histo_max_center[c] > 0) {
histo_max_center_invw[c] = ((float)HISTO_HEIGHT)/histogram_transform((float)histo_max_center[c]);
 266                 } else if (histo_max[c] > 0) {
histo_max_center_invw[c] = ((float)HISTO_HEIGHT)/histogram_transform((float)histo_max[c]);
 268                 } else {
histo_max_center_invw[c] = 0.0f;
 270                 }
 271             }
 273             if (histo_max[HISTO_RGB] > 0) { // over- / under- expos
under_exposed = (histogram_proc[HISTO_RGB][0]*8
 275                                 +histogram_proc[HISTO_RGB][1]*4
 276                                 +histogram_proc[HISTO_RGB][2]) > exposition_thresh;
over_exposed  = (histogram_proc[HISTO_RGB][HISTO_WIDTH-3]
 279                                 +histogram_proc[HISTO_RGB][HISTO_WIDTH-2]*4
 280                                 +histogram_proc[HISTO_RGB][HISTO_WIDTH-1]*8) > exposition_thresh;
 281             } else {
over_exposed = 0;
under_exposed = 1;
 284             }
histogram_stage=5;
 287             break;
 289         case 5:
 290             for (c=0; c<5; ++c) {
histo_fill[c]=0;
 292                 for (i=0; i<HISTO_WIDTH; ++i) {
histogram[c][i] = (histogram_transform((float)histogram_proc[c][i]))*histo_max_center_invw[c];
 294                     if (histogram[c][i] > HISTO_HEIGHT)
histogram[c][i] = HISTO_HEIGHT;
histo_fill[c]+=histogram[c][i];
 297                 }
 298             }
histo_magnification = 0;
 301             if (conf.histo_auto_ajust) {
 302                 if (histo_fill[histo_main] < (HISTO_HEIGHT*HISTO_WIDTH)/5) { // try to adjust if average level is less than 20%
histo_magnification = (20*HISTO_HEIGHT*HISTO_WIDTH) / histo_fill[histo_main];
 304                     for (c=0; c<5; ++c) {
 305                         for (i=0;i<HISTO_WIDTH;i++) {
histogram[c][i] = histogram[c][i] * histo_magnification / 100;
 307                             if (histogram[c][i] > HISTO_HEIGHT)
histogram[c][i] = HISTO_HEIGHT;
 309                         }
 310                     }
 311                 }
 312             }
histogram_stage=0;
 315             break;
 316     }
 318 }
 320 //-------------------------------------------------------------------
 321 // Histogram display functions
 323 static void gui_osd_draw_single_histo(int hist, coord x, coord y, int small)
 324 {
twoColors hc = user_color(conf.histo_color);
twoColors hc2 = user_color(conf.histo_color2);
 328     register int i, v, threshold;
 329     register color cl, cl_over, cl_bg = BG_COLOR(hc);
coord w=HISTO_WIDTH, h=HISTO_HEIGHT;
 332     switch (hist)
 333     {
 334         case HISTO_R:
cl=COLOR_RED;
 336             break;
 337         case HISTO_G:
cl=COLOR_GREEN;
 339             break;
 340         case HISTO_B:
cl=COLOR_BLUE;
 342             break;
 343         case HISTO_RGB:
 344         case HISTO_Y:
 345         default:
cl=FG_COLOR(hc);
 347             break;
 348     }
 350     if (small) {
h>>=1; w>>=1;
 352         for (i=0; i<w; ++i) {
threshold = (histogram[hist][i<<1]+histogram[hist][(i<<1)+1])>>2;
 355             for (v=1; v<h-1; ++v)
draw_pixel(x+1+i, y+h-v, (v<=threshold)?cl:cl_bg);
cl_over = (threshold==h && conf.show_overexp)?BG_COLOR(hc2):cl;
 358             for (; v<h; ++v)
draw_pixel(x+1+i, y+h-v, (v<=threshold)?cl_over:cl_bg);
 360         }
 361     } else {
 362         for (i=0; i<w; ++i) {
threshold = histogram[hist][i];
 365             for (v=1; v<h-3; ++v)
draw_pixel(x+1+i, y+h-v, (v<=threshold)?cl:cl_bg);
cl_over = (threshold==h && conf.show_overexp)?BG_COLOR(hc2):cl;
 368             for (; v<h; ++v)
draw_pixel(x+1+i, y+h-v, (v<=threshold)?cl_over:cl_bg);
 370         }
 371     }
draw_rectangle(x, y, x+1+w, y+h, hc2, RECT_BORDER1);
 374     //Vertical Lines
 375     if (conf.histo_show_ev_grid) for (i=1;i<=4;i++) draw_line(x+(1+w)*i/5, y, x+(1+w)*i/5, y+h, FG_COLOR(hc2));
 376 }
 378 //-------------------------------------------------------------------
 379 static void gui_osd_draw_blended_histo(coord x, coord y)
 380 {
twoColors hc = user_color(conf.histo_color);
twoColors hc2 = user_color(conf.histo_color2);
 384     register unsigned int i, v, red, grn, blu, sel;
color cls[] = {
BG_COLOR(hc),
COLOR_BLUE,
COLOR_GREEN,
COLOR_CYAN,
COLOR_RED,
COLOR_MAGENTA,
COLOR_YELLOW,
COLOR_WHITE
 394     };
 396     for (i=0; i<HISTO_WIDTH; ++i) {
red = histogram[HISTO_R][i];
grn = histogram[HISTO_G][i];
blu = histogram[HISTO_B][i];
 401         for (v=1; v<HISTO_HEIGHT; ++v) {
sel = 0;
 404             if (v < red) sel = 4;
 405             if (v < grn) sel |= 2;
 406             if (v < blu) sel |= 1;
draw_pixel(x+1+i, y+HISTO_HEIGHT-v, cls[sel]);
 409         }
 410     }
draw_rectangle(x, y, x+1+HISTO_WIDTH, y+HISTO_HEIGHT, hc2, RECT_BORDER1);
 413     //Vertical lines
 414     if (conf.histo_show_ev_grid) for (i=1;i<=4;i++) draw_line(x+(1+HISTO_WIDTH)*i/5, y, x+(1+HISTO_WIDTH)*i/5, y+HISTO_HEIGHT, FG_COLOR(hc2));
 416 }
 418 //-------------------------------------------------------------------
 419 void gui_osd_draw_histo(int is_osd_edit)
 420 {
 421     if (is_osd_edit ||
 422         ((camera_info.state.mode_play || !camera_info.state.mode_video) &&
 423          (
 424           ((conf.show_histo==SHOW_HISTO_HALF) && camera_info.state.is_shutter_half_press) ||
 425           ((conf.show_histo==SHOW_HISTO_REC) && camera_info.state.mode_rec && (recreview_hold==0)) ||
 426           ((conf.show_histo==SHOW_HISTO_ALWAYS) && (recreview_hold==0))
 427          )
 428         )
 429        )
 430     {
twoColors hc = user_color(conf.histo_color);
twoColors hc2 = user_color(conf.histo_color2);
 434         switch (conf.histo_layout)
 435         {
 436             case OSD_HISTO_LAYOUT_Y:
gui_osd_draw_single_histo(HISTO_Y, conf.histo_pos.x, conf.histo_pos.y, 0);
 438                 break;
 439             case OSD_HISTO_LAYOUT_A_Y:
gui_osd_draw_single_histo(HISTO_RGB, conf.histo_pos.x, conf.histo_pos.y, 0);
gui_osd_draw_single_histo(HISTO_Y, conf.histo_pos.x, conf.histo_pos.y+HISTO_HEIGHT, 0);
 442                 break;
 443             case OSD_HISTO_LAYOUT_R_G_B:
gui_osd_draw_single_histo(HISTO_R, conf.histo_pos.x, conf.histo_pos.y, 0);
gui_osd_draw_single_histo(HISTO_G, conf.histo_pos.x, conf.histo_pos.y+HISTO_HEIGHT, 0);
gui_osd_draw_single_histo(HISTO_B, conf.histo_pos.x, conf.histo_pos.y+HISTO_HEIGHT*2, 0);
 447                 break;
 448             case OSD_HISTO_LAYOUT_A_yrgb:
gui_osd_draw_single_histo(HISTO_RGB, conf.histo_pos.x, conf.histo_pos.y, 0);
gui_osd_draw_single_histo(HISTO_Y, conf.histo_pos.x, conf.histo_pos.y+HISTO_HEIGHT, 1);
gui_osd_draw_single_histo(HISTO_R, conf.histo_pos.x+HISTO_WIDTH/2+1, conf.histo_pos.y+HISTO_HEIGHT, 1);
gui_osd_draw_single_histo(HISTO_G, conf.histo_pos.x, conf.histo_pos.y+HISTO_HEIGHT+HISTO_HEIGHT/2, 1);
gui_osd_draw_single_histo(HISTO_B, conf.histo_pos.x+HISTO_WIDTH/2+1, conf.histo_pos.y+HISTO_HEIGHT+HISTO_HEIGHT/2, 1);
 454                 break;
 455             case OSD_HISTO_LAYOUT_Y_argb:
gui_osd_draw_single_histo(HISTO_Y, conf.histo_pos.x, conf.histo_pos.y, 0);
gui_osd_draw_single_histo(HISTO_RGB, conf.histo_pos.x, conf.histo_pos.y+HISTO_HEIGHT, 1);
gui_osd_draw_single_histo(HISTO_R, conf.histo_pos.x+HISTO_WIDTH/2+1, conf.histo_pos.y+HISTO_HEIGHT, 1);
gui_osd_draw_single_histo(HISTO_G, conf.histo_pos.x, conf.histo_pos.y+HISTO_HEIGHT+HISTO_HEIGHT/2, 1);
gui_osd_draw_single_histo(HISTO_B, conf.histo_pos.x+HISTO_WIDTH/2+1, conf.histo_pos.y+HISTO_HEIGHT+HISTO_HEIGHT/2, 1);
 461                 break;
 462             case OSD_HISTO_LAYOUT_BLEND:
gui_osd_draw_blended_histo(conf.histo_pos.x, conf.histo_pos.y);
 464                 break;
 465             case OSD_HISTO_LAYOUT_BLEND_Y:
gui_osd_draw_blended_histo(conf.histo_pos.x, conf.histo_pos.y);
gui_osd_draw_single_histo(HISTO_Y, conf.histo_pos.x, conf.histo_pos.y+HISTO_HEIGHT, 0);
 468                 break;
 469             case OSD_HISTO_LAYOUT_A:
 470             default:
gui_osd_draw_single_histo(HISTO_RGB, conf.histo_pos.x, conf.histo_pos.y, 0);
 472                 break;
 473         }
 475         if (conf.histo_layout != OSD_HISTO_LAYOUT_R_G_B)
 476         {
 477             if (under_exposed && conf.show_overexp)
 478             {
draw_ellipse(conf.histo_pos.x+HISTO_DOT_PAD, conf.histo_pos.y+HISTO_DOT_PAD,
HISTO_DOT_SIZE, HISTO_DOT_SIZE, BG_COLOR(hc2), DRAW_FILLED);
 481             }
 482             if (over_exposed && conf.show_overexp)
 483             {
draw_ellipse(conf.histo_pos.x+HISTO_WIDTH-HISTO_DOT_PAD, conf.histo_pos.y+HISTO_DOT_PAD,
HISTO_DOT_SIZE, HISTO_DOT_SIZE, BG_COLOR(hc2), DRAW_FILLED);
 486             }
 487         }
 488         if ((conf.show_overexp ) && camera_info.state.is_shutter_half_press && (under_exposed || over_exposed))
draw_string(conf.histo_pos.x+HISTO_WIDTH-FONT_WIDTH*3, conf.histo_pos.y-FONT_HEIGHT, "EXP", hc);
 490         if (conf.histo_auto_ajust){
 491             if (histo_magnification) {
 492                 char osd_buf[64];
sprintf(osd_buf, " %d.%02dx ", histo_magnification/100, histo_magnification%100);
draw_string(conf.histo_pos.x, conf.histo_pos.y-FONT_HEIGHT, osd_buf, hc);
 495             } else if (is_osd_edit){
draw_string(conf.histo_pos.x, conf.histo_pos.y-FONT_HEIGHT, " 9.99x ", hc);
 497             } else {
draw_rectangle(conf.histo_pos.x, conf.histo_pos.y-FONT_HEIGHT, conf.histo_pos.x+8*FONT_WIDTH, conf.histo_pos.y-1, MAKE_COLOR(COLOR_TRANSPARENT, COLOR_TRANSPARENT), RECT_BORDER0|DRAW_FILLED);
 499             }
 500         }
 501     }
 502 }
 505 // =========  MODULE INIT =================
 507 /***************** BEGIN OF AUXILARY PART *********************
 508   ATTENTION: DO NOT REMOVE OR CHANGE SIGNATURES IN THIS SECTION
 509  **************************************************************/
 511 //---------------------------------------------------------
 512 // PURPOSE: Finalize module operations (close allocs, etc)
 513 // RETURN VALUE: 0-ok, 1-fail
 514 //---------------------------------------------------------
 515 int _module_unloader()
 516 {
 517     return 0;
 518 }
 520 int _module_can_unload()
 521 {
 522     return conf.show_histo == 0;
 523 }
 525 /******************** Module Information structure ******************/
libhisto_sym _libhisto =
 528 {
 529     {
 530          0, _module_unloader, _module_can_unload, 0, 0
 531     },
histogram_process,
gui_osd_draw_histo
 535 };
ModuleInfo _module_info =
 538 {
MODULEINFO_V1_MAGICNUM,
 540     sizeof(ModuleInfo),
HISTO_VERSION,                              // Module version
ANY_CHDK_BRANCH, 0, OPT_ARCHITECTURE,                       // Requirements of CHDK version
ANY_PLATFORM_ALLOWED,               // Specify platform dependency
 546     (int32_t)"Histogram Overlay (dll)",
MTYPE_EXTENSION,
 549     &_libhisto.base,
CONF_VERSION,               // CONF version
CAM_SCREEN_VERSION,         // CAM SCREEN version
ANY_VERSION,                // CAM SENSOR version
CAM_INFO_VERSION,           // CAM INFO version
 556     0,
 557 };
 559 /*************** END OF AUXILARY PART *******************/