source: trunk/core/gui_osd.c @ 655

Revision 655, 48.0 KB checked in by phyrephox, 4 years ago (diff)
  • closing bug 33, 106 & 147 from bugtracker (fudgeys zebra patch and CHDKlovers small fixes for Connect4 & symbols)
  • version changed from 0.8.10 to 0.9.0 to reflect latest 30 revisions
  • Property svn:eol-style set to native
Line 
1#include "camera.h"
2#include "stdlib.h"
3#include "keyboard.h"
4#include "platform.h"
5#include "histogram.h"
6#include "core.h"
7#include "lang.h"
8#include "conf.h"
9#include "gui.h"
10#include "gui_draw.h"
11#include "gui_lang.h"
12#include "gui_batt.h"
13#include "gui_space.h"
14#include "gui_grid.h"
15#include "gui_osd.h"
16
17//-------------------------------------------------------------------
18typedef struct {
19    int     title;
20    OSD_pos *pos;
21    OSD_pos size;
22} OSD_elem;
23
24static OSD_elem osd[]={
25    {LANG_OSD_LAYOUT_EDITOR_HISTO,      &conf.histo_pos,        {HISTO_WIDTH+2, HISTO_HEIGHT}   },
26    {LANG_OSD_LAYOUT_EDITOR_DOF_CALC,   &conf.dof_pos,          {23*FONT_WIDTH, 2*FONT_HEIGHT}  },
27    {LANG_OSD_LAYOUT_EDITOR_STATES,     &conf.mode_state_pos,   {12*FONT_WIDTH, 4*FONT_HEIGHT}   },
28    {LANG_OSD_LAYOUT_EDITOR_RAW,     &conf.mode_raw_pos,   {7*FONT_WIDTH, FONT_HEIGHT}   },
29    {LANG_OSD_LAYOUT_EDITOR_MISC,       &conf.values_pos,       {9*FONT_WIDTH, 9*FONT_HEIGHT}   },
30    {LANG_OSD_LAYOUT_EDITOR_BAT_ICON,   &conf.batt_icon_pos,    {28, 12}                        },
31    {LANG_OSD_LAYOUT_EDITOR_SPACE_ICON,   &conf.space_icon_pos,    {23, 15}                        },
32    {LANG_OSD_LAYOUT_EDITOR_SPACE_ICON,   &conf.space_ver_pos,    {3, 50}                        },
33    {LANG_OSD_LAYOUT_EDITOR_SPACE_ICON,   &conf.space_hor_pos,    {50, 3}                        },
34    {LANG_OSD_LAYOUT_EDITOR_BAT_TEXT,   &conf.batt_txt_pos,     {5*FONT_WIDTH, FONT_HEIGHT}     },
35    {LANG_OSD_LAYOUT_EDITOR_SPACE_TEXT,   &conf.space_txt_pos,     {5*FONT_WIDTH, FONT_HEIGHT}     },
36    {LANG_OSD_LAYOUT_EDITOR_CLOCK,      &conf.clock_pos,        {5*FONT_WIDTH, FONT_HEIGHT}     },
37    {LANG_OSD_LAYOUT_EDITOR_TEMP,      &conf.temp_pos,        {9*FONT_WIDTH, FONT_HEIGHT}     },
38    {LANG_OSD_LAYOUT_EDITOR_VIDEO,     &conf.mode_video_pos,   {9*FONT_WIDTH, 4*FONT_HEIGHT}   },
39    {LANG_OSD_LAYOUT_EDITOR_EV,     &conf.mode_ev_pos,   {12*FONT_WIDTH, FONT_HEIGHT}   },
40#if CAM_EV_IN_VIDEO
41    {LANG_OSD_LAYOUT_EDITOR_EV_VIDEO,         &conf.ev_video_pos,     {70,24}},
42#endif
43    {0}
44};
45static int osd_to_draw;
46static int curr_item;
47static char osd_buf[64];
48static char osd_buf2[10];
49static char osd_buf3[10];
50static char osd_buf4[10];
51
52static int step;
53
54// Width (in pixels) of half-shoot Canon OSD area of the screen buffer, for restore during
55// Zebra draw, to limit RAM usage of zebra. Only these border areas are stored in RAM.
56// Only top and bottom are restored, not left&right.
57#define ZEBRA_CANONOSD_BORDER_RESTORE   1
58#define ZFIX_TOP    29
59#define ZFIX_BOTTOM 30
60
61static unsigned char *img_buf, *scr_buf;
62#if ZEBRA_CANONOSD_BORDER_RESTORE
63static unsigned char *cur_buf_top, *cur_buf_bot;
64#else
65static unsigned char *cur_buf;
66#endif
67static int cur_buf_size;
68static int timer = 0;
69static char *buf = NULL;
70
71
72static DOF_TYPE dof;
73static EXPO_TYPE expo;
74
75#define OSD_STATE    0
76#define OSD_MISC     1
77
78
79//-------------------------------------------------------------------
80void gui_osd_init() {
81    osd_to_draw = 1;
82    curr_item = 0;
83    step = 10;
84    draw_restore();
85}
86
87//-------------------------------------------------------------------
88void gui_osd_draw() {
89    if (osd_to_draw) {
90        int i;
91        draw_restore();
92        gui_osd_draw_histo();
93        gui_osd_draw_dof();
94        gui_batt_draw_osd();
95        gui_space_draw_osd();
96        gui_osd_draw_state();
97        gui_osd_draw_raw_info();
98        gui_osd_draw_values();
99        gui_osd_draw_clock(0,0,0);
100        gui_osd_draw_temp();
101      #if CAM_EV_IN_VIDEO
102        gui_osd_draw_ev_video(1);
103      #endif
104        for (i=1; i<=2; ++i) {
105            draw_rect((osd[curr_item].pos->x>=i)?osd[curr_item].pos->x-i:0, (osd[curr_item].pos->y>=i)?osd[curr_item].pos->y-i:0,
106                      osd[curr_item].pos->x+osd[curr_item].size.x+i-1, osd[curr_item].pos->y+osd[curr_item].size.y+i-1,
107                      COLOR_GREEN);
108        }
109        sprintf(osd_buf, " %s:  x:%d y:%d s:%d ", lang_str(osd[curr_item].title), osd[curr_item].pos->x, osd[curr_item].pos->y, step);
110        draw_string(0, (osd[curr_item].pos->x<strlen(osd_buf)*FONT_WIDTH+4 && osd[curr_item].pos->y<FONT_HEIGHT+4)?screen_height-FONT_HEIGHT:0,
111                    osd_buf, MAKE_COLOR(COLOR_RED, COLOR_WHITE));
112        osd_to_draw = 0;
113    }
114}
115
116//-------------------------------------------------------------------
117void gui_osd_kbd_process() {
118    switch (kbd_get_autoclicked_key()) {
119    case KEY_LEFT:
120        if (osd[curr_item].pos->x > 0) {
121            osd[curr_item].pos->x-=(osd[curr_item].pos->x>=step)?step:osd[curr_item].pos->x;
122            osd_to_draw = 1;
123        }
124        break;
125    case KEY_RIGHT:
126        if (osd[curr_item].pos->x < screen_width-osd[curr_item].size.x) {
127            osd[curr_item].pos->x+=(screen_width-osd[curr_item].size.x-osd[curr_item].pos->x>step)?step:screen_width-osd[curr_item].size.x-osd[curr_item].pos->x;
128            osd_to_draw = 1;
129        } else
130            osd[curr_item].pos->x = screen_width-osd[curr_item].size.x;
131        break;
132    case KEY_UP:
133        if (osd[curr_item].pos->y > 0) {
134            osd[curr_item].pos->y-=(osd[curr_item].pos->y>=step)?step:osd[curr_item].pos->y;
135            osd_to_draw = 1;
136        }
137        break;
138    case KEY_DOWN:
139        if (osd[curr_item].pos->y < screen_height-osd[curr_item].size.y) {
140            osd[curr_item].pos->y+=(screen_height-osd[curr_item].size.y-osd[curr_item].pos->y>step)?step:screen_height-osd[curr_item].size.y-osd[curr_item].pos->y;
141            osd_to_draw = 1;
142        } else
143            osd[curr_item].pos->y = screen_height-osd[curr_item].size.y;
144        break;
145    case KEY_SET:
146        ++curr_item;
147        if (!osd[curr_item].pos)
148            curr_item = 0;
149        osd_to_draw = 1;
150        break;
151    case KEY_DISPLAY:
152        step=(step==1)?10:1;
153        osd_to_draw = 1;
154        break;
155    }
156}
157
158//-------------------------------------------------------------------
159static void gui_osd_draw_single_histo(int hist, coord x, coord y, int small) {
160    register unsigned int i, v, threshold;
161    register color cl, cl_over, cl_bg=conf.histo_color>>8;
162    coord w=HISTO_WIDTH, h=HISTO_HEIGHT;
163
164    switch (hist) {
165        case HISTO_R:
166            cl=COLOR_RED;
167            break;
168        case HISTO_G:
169            cl=COLOR_GREEN;
170            break;
171        case HISTO_B:
172            cl=((mode_get()&MODE_MASK) == MODE_REC)?0xDF:0xCC;
173            break;
174        case HISTO_RGB:
175        case HISTO_Y:
176        default:
177            cl=conf.histo_color;
178            break;
179    }
180
181    if (small) {
182        h>>=1; w>>=1;
183        for (i=0; i<w; ++i) {
184            threshold = (histogram[hist][i<<1]+histogram[hist][(i<<1)+1])>>2;
185
186            for (v=1; v<h-1; ++v)
187                draw_pixel(x+1+i, y+h-v, (v<=threshold)?cl:cl_bg);
188            cl_over = (threshold==h && conf.show_overexp)?conf.histo_color2>>8:cl;
189            for (; v<h; ++v)
190                draw_pixel(x+1+i, y+h-v, (v<=threshold)?cl_over:cl_bg);
191        }
192    } else {
193        for (i=0; i<w; ++i) {
194            threshold = histogram[hist][i];
195
196            for (v=1; v<h-3; ++v)
197                draw_pixel(x+1+i, y+h-v, (v<=threshold)?cl:cl_bg);
198            cl_over = (threshold==h && conf.show_overexp)?conf.histo_color2>>8:cl;
199            for (; v<h; ++v)
200                draw_pixel(x+1+i, y+h-v, (v<=threshold)?cl_over:cl_bg);
201        }
202    }
203     
204    draw_rect(x, y, x+1+w, y+h, conf.histo_color2&0xFF);
205    //Vertical Lines
206    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, conf.histo_color2&0xFF);
207}
208
209//-------------------------------------------------------------------
210void gui_osd_zebra_init() {
211    timer = 0;
212}
213
214//-------------------------------------------------------------------
215static void draw_pixel_buffered(unsigned int offset, color cl) {
216    buf[offset] = cl;
217}
218
219//-------------------------------------------------------------------
220int draw_guard_pixel() {
221    unsigned char* buffer1 = vid_get_bitmap_fb()+screen_buffer_size/2;
222    unsigned char* buffer2 = buffer1+screen_buffer_size;
223    int has_disappeared=0;
224
225    if(*buffer1!=COLOR_GREEN) has_disappeared=1;
226    if(*buffer2!=COLOR_GREEN) has_disappeared=2;
227    *buffer1 = *buffer2 = COLOR_GREEN;
228    return has_disappeared;
229}
230
231//-------------------------------------------------------------------
232#if ZEBRA_CANONOSD_BORDER_RESTORE
233unsigned char get_cur_buf(unsigned int idx) {
234    unsigned int a;
235   
236    a=screen_buffer_size - screen_buffer_width * ZFIX_BOTTOM;
237   
238    if (idx < screen_buffer_width * ZFIX_TOP) return(cur_buf_top[idx]);
239    if (idx >= a && idx < screen_buffer_size) return(cur_buf_bot[idx - a]);
240    return (COLOR_TRANSPARENT);
241}
242#endif
243//-------------------------------------------------------------------
244static void gui_osd_draw_zebra_osd() {
245    switch (conf.zebra_draw_osd) {
246        case ZEBRA_DRAW_NONE:
247            break;
248        case ZEBRA_DRAW_OSD:
249            if (conf.show_osd) {
250                draw_set_draw_proc(draw_pixel_buffered);
251                if ((mode_get()&MODE_MASK) == MODE_REC) {
252                    if (conf.show_dof != DOF_DONT_SHOW) gui_osd_calc_dof();
253                    if (conf.show_grid_lines) {
254                        gui_grid_draw_osd(1);
255                    }
256                    if (conf.show_dof == DOF_SHOW_IN_DOF) {
257                        gui_osd_draw_dof();
258                    }
259                    if (conf.show_state) {
260                        gui_osd_draw_state();
261                    }
262                    if (conf.show_remaining_raw) {
263                        gui_osd_draw_raw_info();
264                    }
265                    if (conf.show_values) {
266                        gui_osd_draw_values();
267                    }
268                }
269                gui_batt_draw_osd();
270                gui_space_draw_osd();
271                if (conf.show_clock) {
272                    gui_osd_draw_clock(0,0,0);
273                }
274                if (conf.show_temp>0) {
275                    gui_osd_draw_temp();
276                }
277                draw_set_draw_proc(NULL);
278            }
279            /* no break here */
280        case ZEBRA_DRAW_HISTO:
281        default:
282            if (conf.show_histo) {
283                draw_set_draw_proc(draw_pixel_buffered);
284                gui_osd_draw_histo();
285                draw_set_draw_proc(NULL);
286            }
287            break;
288    }
289}
290
291
292//-------------------------------------------------------------------
293int gui_osd_draw_zebra() {
294    unsigned int v, s, x, y, f, over;
295    color cl_under=conf.zebra_color>>8, cl_over=conf.zebra_color&0xFF;
296    static int need_restore=0;
297    int viewport_height;
298    int mrec = ((mode_get()&MODE_MASK) == MODE_REC);
299    int zebra_drawn=0;
300    color cls[] = {
301        COLOR_TRANSPARENT,
302        (mrec)?0xDF:0xCC,
303        COLOR_GREEN,
304        (mrec)?COLOR_BLUE_LT:0x99,
305        COLOR_RED,
306        (mrec)?0x66:0xE2,
307        (mrec)?COLOR_YELLOW:0x66,
308        COLOR_BLACK
309    };
310
311
312    if (!buf) {
313        buf = malloc(screen_buffer_size);
314        scr_buf = vid_get_bitmap_fb();
315#if ZEBRA_CANONOSD_BORDER_RESTORE
316        cur_buf_top = malloc(screen_buffer_width * ZFIX_TOP);
317        cur_buf_bot = malloc(screen_buffer_width * ZFIX_BOTTOM);
318#else
319        cur_buf = malloc(screen_buffer_size);
320#endif     
321    }
322
323    if (buf) {
324        if(timer==0) {
325            draw_guard_pixel();
326            timer=1;
327            return 0;
328        }
329        if(timer==1) {
330            int ready;
331            static int n=0;
332            if (!mrec) ready=1;
333            else get_property_case(PROPCASE_SHOOTING, &ready, 4);
334            n=draw_guard_pixel(); // will be 0 in PLAY mode, should be 1 or 2 in REC mode.
335            if(!ready) return 0;
336#if ZEBRA_CANONOSD_BORDER_RESTORE
337            // rescue Canon OSD from scr_buf to cur_buf_top and _bot:
338            if (n==1) {
339                memcpy(cur_buf_top, scr_buf, screen_buffer_width*ZFIX_TOP);
340                memcpy(cur_buf_bot, scr_buf + screen_buffer_size - screen_buffer_width*ZFIX_BOTTOM, screen_buffer_width*ZFIX_BOTTOM);
341            }
342            else {
343                memcpy(cur_buf_top, scr_buf + screen_buffer_size, screen_buffer_width*ZFIX_TOP);
344                memcpy(cur_buf_bot, scr_buf + 2*screen_buffer_size - screen_buffer_width*ZFIX_BOTTOM, screen_buffer_width*ZFIX_BOTTOM);
345            }
346#else
347            // rescue Canon OSD from cur_buf
348            if(n==1) memcpy(cur_buf, scr_buf, screen_buffer_size);
349            else memcpy(cur_buf, scr_buf+screen_buffer_size, screen_buffer_size);
350#endif
351        }
352        ++timer;
353        // Try to get the best viewport buffer. In playmode its the _d one, in
354        // record mode we try to get the fast live one first
355        if (!mrec) {
356            img_buf = vid_get_viewport_fb_d();
357        }
358        else {
359            img_buf = vid_get_viewport_live_fb();
360            if( !img_buf ) {
361                img_buf = vid_get_viewport_fb();
362            }
363        }
364        viewport_height = vid_get_viewport_height();
365        switch (conf.zebra_mode) {
366            case ZEBRA_MODE_ZEBRA_1:
367                f = 4;
368                break;
369            case ZEBRA_MODE_ZEBRA_2:
370                f = 8;
371                break;
372            case ZEBRA_MODE_SOLID:
373                f = 1;
374                break;
375            case ZEBRA_MODE_BLINKED_1:
376                f = timer&1;
377                break;
378            case ZEBRA_MODE_BLINKED_3:
379                f = timer&4;
380                break;
381            case ZEBRA_MODE_BLINKED_2:
382            default:
383                f = timer&2;
384                break;
385        }
386        // if not in no-zebra phase of blink mode zebra, draw zebra to buf[]
387        if (f) {
388            int step_x, step_v;
389            over = 255-conf.zebra_over;
390                if (conf.zebra_multichannel) {step_x=2; step_v=6;} else {step_x=1; step_v=3;}
391                for (s=0, y=1, v=0; y<=viewport_height; ++y) {
392                    for (x=0; x<screen_width; x+=step_x, s+=step_x, v+=step_v) {
393                        register int yy, uu, vv;
394                        int sel;
395                        yy = img_buf[v+1];
396                        if (conf.zebra_multichannel) {
397                            uu = (signed char)img_buf[v];
398                            vv = (signed char)img_buf[v+2];
399                            sel=0;
400                            if (!((conf.zebra_mode == ZEBRA_MODE_ZEBRA_1 || conf.zebra_mode == ZEBRA_MODE_ZEBRA_2) && (y-x-timer)&f)) {
401                                if (((yy<<12) +           vv*5743 + 2048)>>12>over) sel  = 4; // R
402                                if (((yy<<12) - uu*1411 - vv*2925 + 2048)>>12>over) sel |= 2; // G
403                                if (((yy<<12) + uu*7258           + 2048)>>12>over) sel |= 1; // B
404                            }
405                            buf[s]=buf[s+1]=cls[sel];
406                        }
407                        else if (((conf.zebra_mode == ZEBRA_MODE_ZEBRA_1 || conf.zebra_mode == ZEBRA_MODE_ZEBRA_2) && (y-x-timer)&f)) buf[s]=COLOR_TRANSPARENT;
408                        else buf[s]=(yy>over)?cl_over:(yy<conf.zebra_under)?cl_under:COLOR_TRANSPARENT;
409                        if (buf[s] != COLOR_TRANSPARENT && !zebra_drawn) zebra_drawn = 1;
410                        if (mrec) {
411                            // draw Canon OSD to buf[] if in REC mode
412#if ZEBRA_CANONOSD_BORDER_RESTORE                       
413                            if(get_cur_buf(s)!=COLOR_TRANSPARENT) buf[s]=get_cur_buf(s);
414                            if(conf.zebra_multichannel && get_cur_buf(s+1)!=COLOR_TRANSPARENT) buf[s+1]=get_cur_buf(s+1);
415#else
416                            if(cur_buf[s]!=COLOR_TRANSPARENT) buf[s]=cur_buf[s];
417                            if(conf.zebra_multichannel && cur_buf[s+1]!=COLOR_TRANSPARENT) buf[s+1]=cur_buf[s+1];
418#endif
419                        }
420                    }
421                    s+=screen_buffer_width-screen_width;
422                    if (y*screen_height/viewport_height == (s+screen_buffer_width)/screen_buffer_width) {
423                        memcpy(buf+s, buf+s-screen_buffer_width, screen_buffer_width);
424                        s+=screen_buffer_width;
425                    }
426                }
427            if (!zebra_drawn) f=0;
428        }
429        // if blink mode is in no-zebra phase OR if there was no over/underexposed pixels to draw zebra on
430        if (!f) {
431            // if zebra was drawn during previous call of this function
432            if (need_restore) {
433                if (conf.zebra_restore_screen || conf.zebra_restore_osd) {
434                    draw_restore();
435                } else {  // clear buf[] of zebra, only leave Canon OSD
436                    if (mrec) { // REC mode
437#if ZEBRA_CANONOSD_BORDER_RESTORE
438                        // copy rescued Canon OSD to buf[] top/bottom parts and fill center with transparent color:
439                        memcpy(buf, cur_buf_top, screen_buffer_width * ZFIX_TOP);
440                        memcpy(buf + screen_buffer_size - screen_buffer_width * ZFIX_BOTTOM, cur_buf_bot, screen_buffer_width * ZFIX_BOTTOM);
441                        for (s = screen_buffer_width*ZFIX_TOP; s < screen_buffer_size-screen_buffer_width*ZFIX_BOTTOM; s++) {
442                            buf[s]=COLOR_TRANSPARENT;
443                        }
444#else
445                        // copy from a complete Canon OSD rescue screen dump
446                        memcpy(buf, cur_buf, screen_buffer_size);
447#endif
448                    } else { // Not REC mode
449                        // No Canon OSD restore, fill buf[] with transparent color:
450                        memset(buf, COLOR_TRANSPARENT, screen_buffer_size);
451                    }
452                    // draw CHDK osd and histogram to buf[] (if enabled in config)
453                    gui_osd_draw_zebra_osd();
454                    // copy buf[] to both display buffers
455                    memcpy(scr_buf, buf, screen_buffer_size);
456                    memcpy(scr_buf+screen_buffer_size, buf, screen_buffer_size);
457                }
458                need_restore=0;
459            }
460            return !(conf.zebra_restore_screen && conf.zebra_restore_osd);
461        // if zebra was drawn
462        } else {
463            // draw CHDK osd and histogram to buf[] over zebra (if enabled in config)           
464            gui_osd_draw_zebra_osd();
465            // copy buf[] to both display buffers         
466            memcpy(scr_buf, buf, screen_buffer_size);
467            memcpy(scr_buf+screen_buffer_size, buf, screen_buffer_size);
468
469            need_restore=1;
470            return 1;
471        }
472    }
473    return 0;
474}
475
476//-------------------------------------------------------------------
477static void gui_osd_draw_blended_histo(coord x, coord y) {
478    register unsigned int i, v, red, grn, blu, sel;
479    int m = ((mode_get()&MODE_MASK) == MODE_REC);
480    color cls[] = {
481        conf.histo_color>>8,
482        (m)?0xDF:0xCC,
483        COLOR_GREEN,
484        (m)?COLOR_BLUE_LT:0x99,
485        COLOR_RED,
486        (m)?0x66:0xE2,
487        (m)?COLOR_YELLOW:0x66,
488        COLOR_WHITE
489    };
490
491    for (i=0; i<HISTO_WIDTH; ++i) {
492        red = histogram[HISTO_R][i];
493        grn = histogram[HISTO_G][i];
494        blu = histogram[HISTO_B][i];
495
496        for (v=1; v<HISTO_HEIGHT; ++v) {
497            sel = 0;
498
499            if (v < red) sel = 4;
500            if (v < grn) sel |= 2;
501            if (v < blu) sel |= 1;
502
503            draw_pixel(x+1+i, y+HISTO_HEIGHT-v, cls[sel]);
504        }
505    }
506
507    draw_rect(x, y, x+1+HISTO_WIDTH, y+HISTO_HEIGHT, conf.histo_color2&0xFF);
508    //Vertical lines
509    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, conf.histo_color2&0xFF);
510
511}
512
513//-------------------------------------------------------------------
514void gui_osd_draw_histo() {
515    switch (conf.histo_layout) {
516        case OSD_HISTO_LAYOUT_Y:
517                gui_osd_draw_single_histo(HISTO_Y, conf.histo_pos.x, conf.histo_pos.y, 0);
518                break;
519        case OSD_HISTO_LAYOUT_A_Y:
520                gui_osd_draw_single_histo(HISTO_RGB, conf.histo_pos.x, conf.histo_pos.y, 0);
521                gui_osd_draw_single_histo(HISTO_Y, conf.histo_pos.x, conf.histo_pos.y+HISTO_HEIGHT, 0);
522                break;
523        case OSD_HISTO_LAYOUT_R_G_B:
524                gui_osd_draw_single_histo(HISTO_R, conf.histo_pos.x, conf.histo_pos.y, 0);
525                gui_osd_draw_single_histo(HISTO_G, conf.histo_pos.x, conf.histo_pos.y+HISTO_HEIGHT, 0);
526                gui_osd_draw_single_histo(HISTO_B, conf.histo_pos.x, conf.histo_pos.y+HISTO_HEIGHT*2, 0);
527                break;
528        case OSD_HISTO_LAYOUT_A_yrgb:
529                gui_osd_draw_single_histo(HISTO_RGB, conf.histo_pos.x, conf.histo_pos.y, 0);
530                gui_osd_draw_single_histo(HISTO_Y, conf.histo_pos.x, conf.histo_pos.y+HISTO_HEIGHT, 1);
531                gui_osd_draw_single_histo(HISTO_R, conf.histo_pos.x+HISTO_WIDTH/2+1, conf.histo_pos.y+HISTO_HEIGHT, 1);
532                gui_osd_draw_single_histo(HISTO_G, conf.histo_pos.x, conf.histo_pos.y+HISTO_HEIGHT+HISTO_HEIGHT/2, 1);
533                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);
534                break;
535        case OSD_HISTO_LAYOUT_Y_argb:
536                gui_osd_draw_single_histo(HISTO_Y, conf.histo_pos.x, conf.histo_pos.y, 0);
537                gui_osd_draw_single_histo(HISTO_RGB, conf.histo_pos.x, conf.histo_pos.y+HISTO_HEIGHT, 1);
538                gui_osd_draw_single_histo(HISTO_R, conf.histo_pos.x+HISTO_WIDTH/2+1, conf.histo_pos.y+HISTO_HEIGHT, 1);
539                gui_osd_draw_single_histo(HISTO_G, conf.histo_pos.x, conf.histo_pos.y+HISTO_HEIGHT+HISTO_HEIGHT/2, 1);
540                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);
541                break;
542        case OSD_HISTO_LAYOUT_BLEND:
543                gui_osd_draw_blended_histo(conf.histo_pos.x, conf.histo_pos.y);
544                break;
545        case OSD_HISTO_LAYOUT_BLEND_Y:
546                gui_osd_draw_blended_histo(conf.histo_pos.x, conf.histo_pos.y);
547                gui_osd_draw_single_histo(HISTO_Y, conf.histo_pos.x, conf.histo_pos.y+HISTO_HEIGHT, 0);
548                break;
549        case OSD_HISTO_LAYOUT_A:
550        default:
551                gui_osd_draw_single_histo(HISTO_RGB, conf.histo_pos.x, conf.histo_pos.y, 0);
552                break;
553    }
554
555    if (conf.histo_layout != OSD_HISTO_LAYOUT_R_G_B) {
556        if (under_exposed && conf.show_overexp) {
557            draw_filled_ellipse(conf.histo_pos.x+5, conf.histo_pos.y+5, 3, 3, MAKE_COLOR(conf.histo_color2>>8, conf.histo_color2>>8));
558        }
559
560        if (over_exposed && conf.show_overexp) {
561            draw_filled_ellipse(conf.histo_pos.x+HISTO_WIDTH-5, conf.histo_pos.y+5, 3, 3, MAKE_COLOR(conf.histo_color2>>8, conf.histo_color2>>8));
562        }
563    }
564    if ((conf.show_overexp ) && kbd_is_key_pressed(KEY_SHOOT_HALF) && (under_exposed || over_exposed))
565      draw_string(conf.histo_pos.x+HISTO_WIDTH-FONT_WIDTH*3, conf.histo_pos.y-FONT_HEIGHT, "EXP", conf.histo_color);
566    if (conf.histo_auto_ajust){
567      if (histo_magnification) {
568        sprintf(osd_buf, " %d.%02dx ", histo_magnification/1000, histo_magnification/10%100);
569        draw_string(conf.histo_pos.x, conf.histo_pos.y-FONT_HEIGHT, osd_buf, conf.histo_color);
570      } else if (gui_get_mode()==GUI_MODE_OSD){
571        draw_string(conf.histo_pos.x, conf.histo_pos.y-FONT_HEIGHT, " 9.99x ", conf.histo_color);
572      } else {
573        draw_filled_rect(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));
574      }
575    }
576}
577
578//-------------------------------------------------------------------
579static void sprintf_dist(char *buf, float dist) {
580// length of printed string is always 4
581    if (dist<=0 || dist>=MAX_DIST) {
582        sprintf(buf, " inf");
583    } else if (dist<1000) {
584        sprintf(buf, ".%03d", (int)dist);
585    } else if (dist<10000) {
586        sprintf(buf, "%d.%02d", (int)(dist/1000), (int)(dist/10)%100);
587    } else if (dist<100000) {
588        sprintf(buf, "%02d.%d", (int)(dist/1000), (int)(dist/100)%10);
589    } else {
590        sprintf(buf, "%4d", (int)(dist/1000));
591    }
592}
593
594static void sprintf_canon_values(char *buf, short dist)
595{
596short v=((dist<0)?-dist:dist); 
597sprintf(buf, "%s%d.%02d", ((dist<0)?"-":""), v/96, v%96);
598}
599
600
601//-------------------------------------------------------------------
602
603void gui_osd_calc_dof() {
604   
605    int av, av_min, c_of_c, fl, v, v1, m;
606    //long lfpfl=lens_get_focus_pos_fl();
607
608#if CAM_HAS_IRIS_DIAPHRAGM
609    av=shooting_get_real_aperture();
610#else
611    av=shooting_get_min_real_aperture();
612#endif
613    fl=get_focal_length(lens_get_zoom_point());
614    dof.far_limit=-1.0;
615    dof.near_limit=-1.0;
616    dof.depth_of_field=-1.0;
617    dof.hyperfocal_distance=-1.0;
618    dof.subject_distance=-1.0;
619       
620    if ((av!=0) && (fl!=0)) {
621      if (conf.dof_subj_dist_as_near_limit) {
622        v1=(fl*fl);
623        dof.near_limit=shooting_get_canon_subject_distance();
624        av_min=shooting_get_min_real_aperture();
625        c_of_c=circle_of_confusion*10;
626        if ((av_min!=0) && (c_of_c!=0)) dof.hyperfocal_distance=v1/(c_of_c*av_min);
627                if ((dof.near_limit>0) && (dof.near_limit<MAX_DIST)) {
628                        v=(dof.hyperfocal_distance-dof.near_limit);
629                        m=dof.hyperfocal_distance*dof.near_limit;
630                        if ((v>0) && (m>0)) dof.subject_distance=m/v; 
631                }
632        dof.hyperfocal_distance=v1/(c_of_c*av);
633        if ((dof.subject_distance>0) && (dof.subject_distance<MAX_DIST)) {
634          v = (dof.hyperfocal_distance-dof.subject_distance);
635          m=dof.hyperfocal_distance*dof.subject_distance;
636          if ((v>0) && (m>0))  dof.far_limit=m/v;
637          dof.depth_of_field=dof.far_limit-dof.near_limit;
638        }
639     }
640     else {     
641       dof.subject_distance=shooting_get_canon_subject_distance();     
642           dof.hyperfocal_distance=(fl*fl)/(10*circle_of_confusion*av);
643       if (dof.subject_distance>0 && dof.subject_distance<MAX_DIST) {
644          m = dof.hyperfocal_distance*dof.subject_distance;
645          v = (dof.hyperfocal_distance+dof.subject_distance);
646          if ((v>0) && (m>0))  dof.near_limit=m/v;
647          v = (dof.hyperfocal_distance-dof.subject_distance);
648          if ((v>0) && (m>0))  dof.far_limit=m/v;
649          dof.depth_of_field=dof.far_limit-dof.near_limit;   
650        }
651     } 
652    }
653    if (conf.dof_dist_from_lens) {
654      int h=shooting_get_lens_to_focal_plane_width();   
655      if (dof.subject_distance>0) dof.subject_distance-=h;
656      if (dof.far_limit>0) dof.far_limit-=h;
657      if (dof.near_limit>0) dof.near_limit-=h;
658      if (dof.hyperfocal_distance>0) dof.hyperfocal_distance-=h;
659    }
660}
661
662void gui_osd_calc_expo_param() {
663     
664    expo.av96=shooting_get_av96();
665    expo.tv96=shooting_get_tv96();
666    expo.sv96=shooting_get_sv96();
667    expo.iso=shooting_get_iso_real();
668    expo.sv96_market=shooting_get_svm96();
669    expo.iso_market=shooting_get_iso_market();
670    expo.bv96_measured=shooting_get_bv96();
671    expo.ev96_seted=expo.tv96+expo.av96; //Tv96+Av96
672    expo.ev96_measured=expo.bv96_measured+expo.sv96;//Bv96+Sv96
673    expo.dev96=expo.ev96_measured-expo.ev96_seted;// Ev96_external-Ev96_internal
674    expo.bv96_seted=expo.ev96_seted-expo.sv96;
675    expo.dev96_canon=shooting_get_canon_overexposure_value();
676    expo.b=shooting_get_luminance();
677}
678
679void gui_osd_draw_dof() {
680
681    //gui_osd_calc_dof();
682    //strcpy(osd_buf, "");
683    draw_string(conf.dof_pos.x, conf.dof_pos.y, "S/R1/R2:", conf.osd_color);
684    sprintf_dist(osd_buf, dof.subject_distance);
685    int i=strlen(osd_buf);
686    osd_buf[i]='/';
687    sprintf_dist(osd_buf+i+1, dof.near_limit);
688    i=strlen(osd_buf);
689    osd_buf[i]='/';
690    sprintf_dist(osd_buf+i+1, dof.far_limit);
691    draw_string(conf.dof_pos.x+8*FONT_WIDTH, conf.dof_pos.y, osd_buf, conf.osd_color);
692   
693        draw_string(conf.dof_pos.x, conf.dof_pos.y+FONT_HEIGHT, "DOF/HYP:", conf.osd_color);
694    sprintf_dist(osd_buf, dof.depth_of_field);
695    int j=strlen(osd_buf);
696    osd_buf[j]='/';
697    sprintf_dist(osd_buf+j+1, dof.hyperfocal_distance);
698    draw_string(conf.dof_pos.x+8*FONT_WIDTH, conf.dof_pos.y+FONT_HEIGHT, osd_buf, conf.osd_color);
699   
700}
701
702static short n, m; //string number
703
704void gui_print_osd_state_string_int(const char * title, int value) {
705  strcpy(osd_buf, title);
706  sprintf(osd_buf+strlen(osd_buf), "%d", value);
707  sprintf(osd_buf+strlen(osd_buf), "%12s", "");
708  osd_buf[12]=0;
709  draw_string(conf.mode_state_pos.x, conf.mode_state_pos.y+n, osd_buf, conf.osd_color_override);
710  n+=FONT_HEIGHT;
711}
712
713void gui_print_osd_state_string_chr(const char *title, const char *value) {
714  strcpy(osd_buf, title);
715  sprintf(osd_buf+strlen(osd_buf), "%s", value);
716  sprintf(osd_buf+strlen(osd_buf), "%12s", "");
717  osd_buf[12]=0;       
718  draw_string(conf.mode_state_pos.x, conf.mode_state_pos.y+n, osd_buf, conf.osd_color_override);
719  n+=FONT_HEIGHT;
720}
721
722void gui_print_osd_state_string_float(const char * title, const char * fmt, int divisor, int value) {
723  strcpy(osd_buf, title);
724  sprintf(osd_buf+strlen(osd_buf), fmt, (int)(value/divisor), (int)(value%divisor));
725  sprintf(osd_buf+strlen(osd_buf), "%12s", "");
726  osd_buf[12]=0;       
727  draw_string(conf.mode_state_pos.x, conf.mode_state_pos.y+n, osd_buf, conf.osd_color_override);
728  n+=FONT_HEIGHT;
729}
730
731void gui_print_osd_misc_string_int(const char * title, int value) {
732  strcpy(osd_buf, title);
733  sprintf(osd_buf+strlen(osd_buf), "%d", value);
734  sprintf(osd_buf+strlen(osd_buf), "%9s", "");
735  osd_buf[9]=0;
736  draw_string(conf.values_pos.x, conf.values_pos.y+m, osd_buf, conf.osd_color);
737  m+=FONT_HEIGHT;
738}
739
740/*
741void gui_print_osd_misc_string_float(const char * title, const char * fmt, int divisor, int value) {
742  char s[16];   
743  strcpy(osd_buf, title);
744  sprintf(s, fmt, (int)(value/divisor), (int)(value%divisor));
745  sprintf(osd_buf+strlen(osd_buf), "%6s", s);
746  //osd_buf[8]=0;       
747  draw_string(conf.values_pos.x, conf.values_pos.y+m, osd_buf, conf.osd_color);
748  m+=FONT_HEIGHT;
749}
750*/
751
752void gui_print_osd_misc_string_float(const char * title, const char * fmt, int divisor, int value) {
753  strcpy(osd_buf, title);
754  sprintf(osd_buf+strlen(osd_buf), fmt, (int)(value/divisor), (int)(value%divisor));
755  sprintf(osd_buf+strlen(osd_buf), "%9s", "");
756  osd_buf[9]=0;
757  draw_string(conf.values_pos.x, conf.values_pos.y+m, osd_buf, conf.osd_color);
758  m+=FONT_HEIGHT;
759}
760
761
762void gui_print_osd_misc_string_dist(const char * title, int value) {
763  strcpy(osd_buf, title);
764  sprintf_dist(osd_buf+strlen(osd_buf), (float)value);
765  sprintf(osd_buf+strlen(osd_buf), "%9s", "");
766  osd_buf[9]=0;
767  draw_string(conf.values_pos.x, conf.values_pos.y+m, osd_buf, conf.osd_color);
768  m+=FONT_HEIGHT;
769}
770
771void gui_print_osd_misc_string_canon_values(const char * title, short value) {
772  strcpy(osd_buf, title);
773  sprintf_canon_values(osd_buf+strlen(osd_buf), value);
774  sprintf(osd_buf+strlen(osd_buf), "%9s", "");
775  osd_buf[9]=0;
776  draw_string(conf.values_pos.x, conf.values_pos.y+m, osd_buf, conf.osd_color);
777  m+=FONT_HEIGHT;
778}
779
780//-------------------------------------------------------------------
781void gui_osd_draw_raw_info()
782    {
783    int x, m=(mode_get()&MODE_SHOOTING_MASK);
784    static int b;
785    if ((!((movie_status > 1) && conf.save_raw_in_video   )) && (!((m==MODE_SPORTS) && conf.save_raw_in_sports)) && (!((m==MODE_AUTO) && conf.save_raw_in_auto)) && (!(conf.edge_overlay_enable && conf.save_raw_in_edgeoverlay)) && (!((shooting_get_prop(PROPCASE_DRIVE_MODE)==1) && conf.save_raw_in_burst && !(m==MODE_SPORTS)))  && (!((shooting_get_prop(PROPCASE_DRIVE_MODE)>=2) && conf.save_raw_in_timer)) && (!((shooting_get_prop(PROPCASE_BRACKET_MODE)==1) && conf.save_raw_in_ev_bracketing)) )
786    {
787    if (conf.show_remaining_raw)
788        {
789        int raw_count=GetRawCount(); 
790            if (raw_count>conf.remaining_raw_treshold)
791                {
792                if (conf.dng_raw) sprintf(osd_buf, "DNG:%3d", raw_count); else sprintf(osd_buf, "RAW:%3d", raw_count);
793                draw_string(conf.mode_raw_pos.x, conf.mode_raw_pos.y, osd_buf, conf.osd_color);
794                }
795            else
796                {
797
798                if (conf.dng_raw) sprintf(osd_buf, "DNG:%3d", raw_count); else sprintf(osd_buf, "RAW:%3d", raw_count);
799               
800                if (b > 6)
801                    {
802                    draw_string(conf.mode_raw_pos.x, conf.mode_raw_pos.y, osd_buf, conf.osd_color_warn);
803                    b = (b>12) ? 0 : b+1;
804                    }
805                else
806                    {
807                    draw_string(conf.mode_raw_pos.x, conf.mode_raw_pos.y, osd_buf, conf.osd_color);
808                    b = b+1;
809                    }
810                }
811        }
812    else if (conf.dng_raw) draw_string(conf.mode_raw_pos.x, conf.mode_raw_pos.y, "DNG", conf.osd_color); else draw_string(conf.mode_raw_pos.x, conf.mode_raw_pos.y, "RAW", conf.osd_color);
813        }   
814        else if (conf.raw_exceptions_warn)
815                {
816                        if (conf.dng_raw) gui_print_osd_state_string_chr("DNG Disabled",""); else gui_print_osd_state_string_chr("RAW Disabled","");
817                }
818               
819                         
820}
821//-------------------------------------------------------------------
822void gui_osd_draw_state() {
823    int a,  gui_mode=gui_get_mode(), m=(mode_get()&MODE_SHOOTING_MASK);
824    long t;
825   
826    n=0;
827   ///////////////////////////
828   //sprintf(osd_buf,"%s",get_debug());
829   //draw_string(conf.mode_state_pos.x, conf.mode_state_pos.y+6*FONT_HEIGHT, osd_buf, conf.osd_color);
830   //////////////////////////// 
831
832     
833    if ((((conf.tv_enum_type) || (conf.tv_override_value)) && (conf.tv_override_koef)  && !(conf.override_disable==1)) || gui_mode==GUI_MODE_OSD){
834        if(kbd_is_key_pressed(KEY_SHOOT_HALF))
835                 {
836                  t=(int)(shooting_get_shutter_speed_from_tv96(shooting_get_tv96())*100000);   
837          gui_print_osd_state_string_float("TV:", "%d.%05d ", 100000, t);
838         }
839        else
840                 {
841         if (conf.tv_enum_type)
842                   gui_print_osd_state_string_chr("TV:",shooting_get_tv_override_value());
843         else 
844          {
845                  t=(int)(shooting_get_shutter_speed_override_value()*100000);
846          gui_print_osd_state_string_float("TV:", "%d.%05d ", 100000, t);
847          }
848       }
849    }
850    if ((conf.av_override_value && !(conf.override_disable==1))|| gui_mode==GUI_MODE_OSD) 
851           gui_print_osd_state_string_float("AV:", "%d.%02d ", 100, shooting_get_aperture_from_av96(shooting_get_av96_override_value()));
852#if CAM_HAS_ND_FILTER
853    if ((conf.nd_filter_state && !(conf.override_disable==1))|| gui_mode==GUI_MODE_OSD)
854           gui_print_osd_state_string_chr("NDFILTER:", ((conf.nd_filter_state==1)?"IN":"OUT"));
855#endif   
856    if ((conf.autoiso_enable && shooting_get_iso_mode()<=0 && !(m==MODE_M || m==MODE_TV) && shooting_get_flash_mode() && (!(conf.override_disable==1 && conf.override_disable_all))) || gui_mode==GUI_MODE_OSD) 
857            gui_print_osd_state_string_chr("AUTOISO:", ((conf.autoiso_enable==1)?"ON":"OFF"));
858    if ((conf.subj_dist_override_value && conf.subj_dist_override_koef && shooting_can_focus() && !(conf.override_disable==1)) || ((gui_mode==GUI_MODE_ALT) && shooting_get_common_focus_mode())        || gui_mode==GUI_MODE_OSD)   {
859        gui_print_osd_state_string_int("SD:",shooting_get_subject_distance_override_value());
860        if (gui_mode==GUI_MODE_ALT) 
861                  gui_print_osd_state_string_int("FACTOR:",shooting_get_subject_distance_override_koef());     
862      }
863    if ((conf.iso_override_value && conf.iso_override_koef && !(conf.override_disable==1))       || gui_mode==GUI_MODE_OSD)
864        gui_print_osd_state_string_int("ISO:", shooting_get_iso_override_value());
865    if ((gui_mode==GUI_MODE_OSD) || (shooting_get_drive_mode())) {
866    if ((conf.tv_bracket_value && !(conf.override_disable==1 && conf.override_disable_all)) || (conf.av_bracket_value && !(conf.override_disable==1 && conf.override_disable_all))  || (conf.iso_bracket_value && conf.iso_bracket_koef && !(conf.override_disable==1 && conf.override_disable_all)) || ((conf.subj_dist_bracket_value) && (conf.subj_dist_bracket_koef) && (shooting_can_focus() && !(conf.override_disable==1 && conf.override_disable_all)))) 
867        gui_print_osd_state_string_chr("BRACKET:", shooting_get_bracket_type());
868      if (conf.tv_bracket_value && !(conf.override_disable==1 && conf.override_disable_all)) 
869            gui_print_osd_state_string_chr("TV:", shooting_get_tv_bracket_value());
870      else if  (conf.av_bracket_value && !(conf.override_disable==1 && conf.override_disable_all))
871            gui_print_osd_state_string_chr("AV:", shooting_get_av_bracket_value());
872      else if  (conf.iso_bracket_value && conf.iso_bracket_koef   && !(conf.override_disable==1 && conf.override_disable_all))
873            gui_print_osd_state_string_int("ISO:", shooting_get_iso_bracket_value());
874      else if  ((conf.subj_dist_bracket_value  && !(conf.override_disable==1 && conf.override_disable_all)) && (conf.subj_dist_bracket_koef) && (shooting_can_focus()))
875        gui_print_osd_state_string_int("SD:",shooting_get_subject_distance_bracket_value());
876     }
877#ifdef OPT_CURVES
878        if (conf.curve_enable || gui_mode==GUI_MODE_OSD) {
879        if (conf.curve_enable==1) gui_print_osd_state_string_chr("CURVES:", "CSTM");
880        else if (conf.curve_enable==4) gui_print_osd_state_string_chr("CURVES:", "AUTO");
881        else if (conf.curve_enable==3) gui_print_osd_state_string_chr("CURVES:", "+2EV");
882        else if (conf.curve_enable==2) gui_print_osd_state_string_chr("CURVES:", "+1EV");
883    }
884#endif
885    if (conf.override_disable == 1) gui_print_osd_state_string_chr("NO ", "OVERRIDES");
886/*
887 draw_string(conf.mode_state_pos.x, conf.mode_state_pos.y+n, get_debug(), conf.osd_color);
888        n+=FONT_HEIGHT;*/
889}
890
891//-------------------------------------------------------------------
892void gui_osd_draw_values(int showtype) {
893    int iso_mode=shooting_get_iso_mode();
894    float s=-1.0f;
895   
896    m=0;
897   
898    //gui_osd_calc_expo_param();
899   
900    if (conf.values_show_zoom) {
901     int fl, zp=lens_get_zoom_point(), fl1=get_focal_length(zp);     
902     switch (conf.zoom_value) {
903         case ZOOM_SHOW_FL:
904             sprintf(osd_buf, "Z:%d.%dmm%8s", fl1/1000, fl1%1000/100, "");
905             break;
906         case ZOOM_SHOW_EFL:
907             fl=get_effective_focal_length(zp);
908             // scale by users adapter lens eg. Canon Wide .42 or Canon Tele 1.75
909             fl = fl * conf.zoom_scale / 100;
910             sprintf(osd_buf, "Z:%3dmm%8s", fl/1000, "");
911             break;
912         case ZOOM_SHOW_X:
913         default:
914             fl=get_zoom_x(zp);
915             sprintf(osd_buf, "Z:%ld/%d.%dx%8s", zp, fl/10, fl%10, "");
916             break;
917     }
918     osd_buf[9]=0;
919     draw_string(conf.values_pos.x, conf.values_pos.y, osd_buf, conf.osd_color);
920     m+=FONT_HEIGHT;
921    }
922   
923   
924    if ((conf.values_show_real_aperture) && (showtype==1))
925             gui_print_osd_misc_string_float("Av :", "%d.%02d ", 100, shooting_get_real_aperture());
926    if ((conf.show_dof==DOF_SHOW_IN_MISC) && (showtype)) {
927         //if (kbd_is_key_pressed(KEY_SHOOT_HALF) && (mode_photo || (m&MODE_SHOOTING_MASK)==MODE_STITCH))       
928         //gui_osd_calc_dof();
929         if (conf.dof_subj_dist_in_misc) gui_print_osd_misc_string_dist("SD :", dof.subject_distance);
930         if (conf.dof_near_limit_in_misc) gui_print_osd_misc_string_dist("NL :", dof.near_limit);
931         if (conf.dof_far_limit_in_misc) gui_print_osd_misc_string_dist("FL :", dof.far_limit);
932         if (conf.dof_depth_in_misc) gui_print_osd_misc_string_dist("DOF:", dof.depth_of_field);
933         if (conf.dof_hyperfocal_in_misc) gui_print_osd_misc_string_dist("HYP:", dof.hyperfocal_distance);
934    }
935    if (showtype==1) {
936      if ((iso_mode <= 0) || !(conf.values_show_iso_only_in_autoiso_mode)) {
937          if (conf.values_show_real_iso) gui_print_osd_misc_string_int("I-R:", expo.iso);
938          if (conf.values_show_market_iso) gui_print_osd_misc_string_int("I-M:", expo.iso_market);
939      }
940      if (conf.values_show_bv_measured) gui_print_osd_misc_string_canon_values("Bvm:", expo.bv96_measured       );
941      if (conf.values_show_bv_seted) gui_print_osd_misc_string_canon_values("Bvs:", expo.bv96_seted     );
942      if (conf.values_show_ev_measured) gui_print_osd_misc_string_canon_values("Evm:", expo.ev96_measured);
943      if (conf.values_show_ev_seted     ) gui_print_osd_misc_string_canon_values("Evs:", expo.ev96_seted        );
944      if (conf.values_show_overexposure) gui_print_osd_misc_string_canon_values("dE :", expo.dev96);
945      if (conf.values_show_canon_overexposure   ) gui_print_osd_misc_string_canon_values("dEc:", expo.dev96_canon);
946      if (conf.values_show_luminance) gui_print_osd_misc_string_float("B  :", "%d.%02d ", 100, expo.b);
947         
948    }
949   
950}
951
952#define CLOCK_FORMAT_24 0
953#define CLOCK_FORMAT_12 1
954#define CLOCK_WITHOUT_SEC 1
955#define CLOCK_WITH_SEC 2
956
957//-------------------------------------------------------------------
958void gui_osd_draw_clock(int x, int y, color cl) {
959    unsigned long t;
960    static struct tm *ttm;
961    int w = 0;
962    int z;
963    static char am[4];
964    static char pm[4];
965    static char curr[4];
966    t = time(NULL);
967    ttm = localtime(&t);
968    unsigned int hour=(ttm->tm_hour);
969    if (conf.clock_format == CLOCK_FORMAT_12) {
970     switch(conf.clock_indicator)
971      {
972        case 1:
973            sprintf(pm, "P");
974            sprintf(am, "A");
975            w = 1;
976                break;
977        case 2:
978            sprintf(pm, ".");
979            sprintf(am, " ");
980            w = 1;
981                break;
982        default:
983            sprintf(pm, " PM");
984            sprintf(am, " AM");
985            w = 3;
986                break;
987      }
988     sprintf(curr,((hour>=12)?pm:am));
989     if ((ttm->tm_hour)==00)  hour=12;
990     else if ((ttm->tm_hour)>12)  hour=hour-12;
991    }
992    switch(conf.show_clock)
993    {
994      case CLOCK_WITHOUT_SEC:
995        if (conf.clock_format == CLOCK_FORMAT_24)
996                  sprintf(osd_buf, "%2u:%02u", hour, ttm->tm_min);
997        else
998                  sprintf(osd_buf, "%2u:%02u%s", hour, ttm->tm_min,curr);
999            z=0;
1000        break; 
1001      case CLOCK_WITH_SEC:
1002      default:
1003         if (conf.clock_format == CLOCK_FORMAT_24) 
1004                   sprintf(osd_buf, "%2u:%02u:%02u", hour, ttm->tm_min,ttm->tm_sec);
1005         else 
1006                   sprintf(osd_buf, "%2u:%02u:%02u%s", hour, ttm->tm_min,ttm->tm_sec,curr);
1007         z=3;
1008         break; 
1009    }
1010    if ((conf.show_clock==CLOCK_WITH_SEC || (conf.clock_format==CLOCK_FORMAT_12)) && (conf.clock_pos.x>=(z+w)*FONT_WIDTH) )
1011       draw_string((x)?x-(z+w)*FONT_WIDTH:conf.clock_pos.x-(z+w)*FONT_WIDTH, (y)?y:conf.clock_pos.y, osd_buf, (cl)?cl:conf.osd_color);
1012        else
1013           draw_string((x)?x:conf.clock_pos.x, (y)?y:conf.clock_pos.y, osd_buf, (cl)?cl:conf.osd_color);
1014}
1015
1016
1017void gui_osd_draw_seconds() {
1018    unsigned long t;
1019    static struct tm *ttm;
1020 
1021    t = time(NULL);
1022    ttm = localtime(&t);
1023    sprintf(osd_buf, "%02u", ttm->tm_sec);
1024    if (conf.clock_pos.x<4*FONT_WIDTH){
1025    draw_string(conf.clock_pos.x, conf.clock_pos.y, osd_buf, conf.osd_color);
1026    }
1027    else
1028    {
1029    draw_string(conf.clock_pos.x+(3*FONT_WIDTH), conf.clock_pos.y, osd_buf, conf.osd_color);
1030    }
1031   
1032
1033}
1034
1035void gui_osd_draw_movie_time_left()  {
1036 
1037static int card_used, init_space, elapsed, avg_use, time_left;
1038static long init_time;
1039static int record_running = 0;
1040static int init = 0;
1041static unsigned int skipcalls = 1;
1042unsigned int hour=0, min=0, sec=0;
1043int mode_video = MODE_IS_VIDEO(m);
1044
1045
1046#if CAM_CHDK_HAS_EXT_VIDEO_MENU
1047if (mode_video || movie_status > 1) {
1048    // if manual adjust, show the field item to be adjusted
1049   // if any value overriden, show the override value
1050   if ((conf.video_mode == 0 && conf.fast_movie_quality_control==1) || conf.video_bitrate != VIDEO_DEFAULT_BITRATE) {
1051       // gui_print_osd_state_string_chr("Bitrate: ",video_bitrate_strings[conf.video_bitrate]);
1052       sprintf(osd_buf3, "Bit:%5s",video_bitrate_strings[conf.video_bitrate]);
1053       draw_string( conf.mode_video_pos.x, conf.mode_video_pos.y+2*FONT_HEIGHT, osd_buf3, conf.osd_color);
1054   }
1055   if ((conf.video_mode == 1 && conf.fast_movie_quality_control==1) || conf.video_quality != VIDEO_DEFAULT_QUALITY) {
1056       // gui_print_osd_state_string_int("Quality: ",conf.video_quality);
1057                         sprintf(osd_buf4, "Qual:%2i",conf.video_quality);
1058       draw_string( conf.mode_video_pos.x, conf.mode_video_pos.y+3*FONT_HEIGHT, osd_buf4, conf.osd_color);
1059   }
1060   // everything else is for stills
1061         if(mode_video)
1062         return;
1063    }
1064#endif
1065
1066if (movie_reset == 1)
1067        {
1068                init = 0;
1069                movie_reset = 0;
1070        }
1071    if (movie_status > 1) record_running = 1;
1072    else
1073    {record_running = 0;
1074    init = 0;
1075    }
1076   
1077    if (record_running == 1 && init == 0)
1078    {
1079    init = 1;
1080    init_space = GetFreeCardSpaceKb();
1081    init_time  = get_tick_count();
1082    }
1083    if (init == 1)
1084    {
1085 
1086    card_used = init_space - GetFreeCardSpaceKb();
1087    elapsed = (int) ( get_tick_count() - init_time ) / 1000;
1088    avg_use = card_used / elapsed;  // running average Kb/sec
1089    time_left = (GetFreeCardSpaceKb() / avg_use);
1090    hour = time_left / 3600;
1091    min = (time_left % 3600) / 60;
1092    sec = (time_left % 3600) % 60;
1093
1094       if (elapsed<1)
1095   {
1096  sprintf(osd_buf, "Calc...");
1097   draw_string( conf.mode_video_pos.x, conf.mode_video_pos.y, osd_buf, conf.osd_color);
1098    }
1099   
1100   if (--skipcalls ==0) {
1101    if (elapsed>1)
1102     {
1103     if (conf.show_movie_time == 3){
1104      sprintf(osd_buf, "%04d KB/s", avg_use);
1105      draw_string( conf.mode_video_pos.x, conf.mode_video_pos.y, osd_buf, conf.osd_color);
1106      sprintf(osd_buf2, "-%02d:%02d:%02d", hour, min, sec);
1107      draw_string( conf.mode_video_pos.x, conf.mode_video_pos.y+FONT_HEIGHT, osd_buf2, conf.osd_color);
1108    }
1109     if (conf.show_movie_time == 2)
1110      {sprintf(osd_buf, "%04d KB/s", avg_use);
1111      draw_string( conf.mode_video_pos.x, conf.mode_video_pos.y, osd_buf, conf.osd_color);
1112    }
1113      if (conf.show_movie_time == 1)
1114       {
1115        sprintf(osd_buf, "-%02d:%02d:%02d", hour, min, sec);
1116        draw_string( conf.mode_video_pos.x, conf.mode_video_pos.y, osd_buf, conf.osd_color);
1117                                }
1118      }
1119
1120     skipcalls = conf.show_movie_refresh*5;
1121    }
1122    }
1123        }
1124
1125void gui_osd_draw_ev() {
1126#if (CAM_PROPSET == 1) 
1127    sprintf(osd_buf, "EV: %+d,%2d", shooting_get_prop(25)/96,shooting_get_prop(25)%96);
1128#elif (CAM_PROPSET == 2)
1129    sprintf(osd_buf, "EV: %+d,%2d", shooting_get_prop(107)/96,shooting_get_prop(107)%96);
1130#endif
1131
1132    draw_string(conf.mode_ev_pos.x, conf.mode_ev_pos.y, osd_buf, conf.osd_color);
1133
1134}
1135
1136
1137void gui_osd_draw_temp() {
1138                if (conf.show_temp == 1)
1139                        {
1140                                if (conf.temperature_unit == 0)
1141                                                {
1142                                                        sprintf(osd_buf," opt: %i°",get_optical_temp());
1143                                                }
1144                                else
1145                                                {
1146                                                        sprintf(osd_buf,"opt: %i°",(get_optical_temp()*18+320)/10);
1147                                                }
1148                                draw_string(conf.temp_pos.x, conf.temp_pos.y, osd_buf, conf.osd_color);
1149                        }
1150                if (conf.show_temp==2)
1151                        {
1152                                if (conf.temperature_unit == 0)
1153                                                {
1154                                                        sprintf(osd_buf," ccd: %i°",get_ccd_temp());
1155                                                }
1156                                else
1157                                                {
1158                                                        sprintf(osd_buf,"ccd: %i°",(get_ccd_temp()*18+320)/10);
1159                                                }
1160                                draw_string(conf.temp_pos.x, conf.temp_pos.y, osd_buf, conf.osd_color);
1161                        }
1162                if (conf.show_temp==3)
1163                        {
1164                                if (conf.temperature_unit == 0)
1165                                                {
1166                                                        sprintf(osd_buf," batt:%i°",get_battery_temp());
1167                                                }
1168                                else
1169                                                {
1170                                                        sprintf(osd_buf,"batt:%i°",(get_battery_temp()*18+320)/10);
1171                                                }
1172                                draw_string(conf.temp_pos.x, conf.temp_pos.y, osd_buf, conf.osd_color);
1173                        }
1174                if (conf.show_temp==4)
1175                        {
1176                                if (conf.temperature_unit == 0)
1177                                        {                               
1178                                                sprintf(osd_buf," opt: %i°",get_optical_temp());
1179                                                draw_string(conf.temp_pos.x, conf.temp_pos.y, osd_buf, conf.osd_color);
1180                                                sprintf(osd_buf," ccd: %i°",get_ccd_temp());
1181                                                draw_string(conf.temp_pos.x, conf.temp_pos.y+FONT_HEIGHT, osd_buf, conf.osd_color);
1182                                                sprintf(osd_buf," batt:%i°",get_battery_temp());
1183                                                draw_string(conf.temp_pos.x, conf.temp_pos.y+2*FONT_HEIGHT, osd_buf, conf.osd_color);
1184                                        }       
1185                else
1186                                        {
1187                                                sprintf(osd_buf,"opt: %i°",(get_optical_temp()*18+320)/10);
1188                                                draw_string(conf.temp_pos.x, conf.temp_pos.y, osd_buf, conf.osd_color);
1189                                                sprintf(osd_buf,"ccd: %i°",(get_ccd_temp()*18+320)/10);
1190                                                draw_string(conf.temp_pos.x, conf.temp_pos.y+FONT_HEIGHT, osd_buf, conf.osd_color);
1191                                                sprintf(osd_buf,"batt:%i°",(get_battery_temp()*18+320)/10);
1192                                                draw_string(conf.temp_pos.x, conf.temp_pos.y+2*FONT_HEIGHT, osd_buf, conf.osd_color);
1193                                        }                       
1194    }
1195}
1196
1197
1198
1199//-------------------------------------------------------------------
1200#if CAM_EV_IN_VIDEO
1201void gui_osd_draw_ev_video(int visible){
1202 int x0=conf.ev_video_pos.x, y0=conf.ev_video_pos.y;
1203 int i, deltax;
1204
1205 draw_filled_rect(x0,y0,x0+70,y0+24, visible? ((conf.osd_color&0xFF00))|(conf.osd_color>>8): COLOR_TRANSPARENT);
1206
1207 if (!visible) { return; }
1208
1209 for (i=0;i<9;i++) draw_line(x0+2+i*8,   y0+12, x0+2+i*8,   y0+12-(i&1 ? 5 : 10), conf.osd_color);
1210 for (i=0;i<9;i++) draw_line(x0+2+i*8+1, y0+12, x0+2+i*8+1, y0+12-(i&1 ? 5 : 10), conf.osd_color);
1211
1212 deltax=8*get_ev_video();
1213
1214 x0+=deltax;
1215
1216 draw_line(x0+34,y0+16,x0+34,y0+22,conf.osd_color);
1217 draw_line(x0+35,y0+16,x0+35,y0+22,conf.osd_color);
1218
1219 draw_line(x0+32,y0+19,x0+32,y0+22,conf.osd_color);
1220 draw_line(x0+33,y0+18,x0+33,y0+22,conf.osd_color);
1221 draw_line(x0+36,y0+18,x0+36,y0+22,conf.osd_color);
1222 draw_line(x0+37,y0+19,x0+37,y0+22,conf.osd_color);
1223
1224}
1225#endif
Note: See TracBrowser for help on using the repository browser.