zebra.c-Dateireferenz

#include "camera_info.h"
#include "conf.h"
#include "keyboard.h"
#include "modes.h"
#include "viewport.h"
#include "properties.h"
#include "gui.h"
#include "gui_draw.h"
#include "gui_lang.h"
#include "gui_osd.h"
#include "gui_mbox.h"
#include "gui_batt.h"
#include "gui_space.h"
#include "histogram.h"
#include "zebra.h"
#include "gui_grid.h"
#include "module_def.h"

Include-Abhängigkeitsdiagramm für zebra.c:

gehe zum Quellcode dieser Datei

Makrodefinitionen
#define	ZFIX_TOP   29
#define	ZFIX_BOTTOM   30

Funktionen
unsigned char	clip8 (signed short x)
static void	gui_osd_zebra_free ()
static int	gui_osd_zebra_init (int show)
static void	draw_pixel_buffered (unsigned int offset, color cl)
int	draw_guard_pixel ()
static void	gui_osd_draw_zebra_osd ()
static void	disp_zebra ()
static int	draw_zebra_aspect_adjust (int mrec, unsigned int f, color *cls)
static unsigned char	get_cur_buf (unsigned int idx)
static int	draw_zebra_no_aspect_adjust (int mrec, unsigned int f, color *cls)
int	gui_osd_draw_zebra (int show)
int	_module_unloader ()
int	_module_can_unload ()

Variablen
static unsigned char *	img_buf
static unsigned char *	scr_buf
static unsigned char *	cur_buf_top
static unsigned char *	cur_buf_bot
static unsigned char *	buf = NULL
static int	buffer_size
static int	timer = 0
static color	cl_under
static color	cl_over
libzebra_sym	_libzebra
ModuleInfo	_module_info

Makro-Dokumentation

#define ZFIX_BOTTOM   30

Definiert in Zeile 103 der Datei zebra.c.

#define ZFIX_TOP   29

Definiert in Zeile 102 der Datei zebra.c.

Dokumentation der Funktionen

int _module_can_unload

(

)

Definiert in Zeile 770 der Datei zebra.c.

{
    return conf.zebra_draw == 0;
}

int _module_unloader

(

)

Definiert in Zeile 764 der Datei zebra.c.

{
    gui_osd_zebra_free();
    return 0;
}

unsigned char clip8

(

signed short

x)

Definiert in Zeile 115 der Datei zebra.c.

{ if (x<0) x=0; else if (x>255) x=255; return x; }

static void disp_zebra ( )

static

Definiert in Zeile 225 der Datei zebra.c.

{
    // draw CHDK osd and histogram to buf[] (if enabled in config)
    gui_osd_draw_zebra_osd();

    // copy buf[] to both display buffers
    if (buf != scr_buf)
        memcpy(scr_buf, buf, buffer_size);
    memcpy(scr_buf+camera_screen.buffer_size, buf, buffer_size);
}

int draw_guard_pixel

(

)

Definiert in Zeile 192 der Datei zebra.c.

                       {
    unsigned char* buffer1 = vid_get_bitmap_fb()+camera_screen.buffer_size/2;
    unsigned char* buffer2 = buffer1+camera_screen.buffer_size;
    int has_disappeared=0;

    if(*buffer1!=COLOR_GREEN) has_disappeared=1;
    if(*buffer2!=COLOR_GREEN) has_disappeared=2;
    *buffer1 = *buffer2 = COLOR_GREEN;
    return has_disappeared;
}

static void draw_pixel_buffered ( unsigned int  offset, color  cl  )

static

Definiert in Zeile 186 der Datei zebra.c.

{
    buf[offset] = cl;
}

static int draw_zebra_aspect_adjust ( int  mrec, unsigned int  f, color *  cls  )

static

Definiert in Zeile 241 der Datei zebra.c.

{
    int v, s, x, y, over;
    static int need_restore=0;
    int viewport_height;
    int viewport_width; 
    int viewport_image_offset;  // for when viewport memory buffer is wider than viewport
    int viewport_row_offset;    // for when viewport memory buffer is wider than viewport
    int viewport_xoffset;       // used when image size != viewport size
    int viewport_yoffset;       // used when image size != viewport size
    int zebra_drawn=0;

    viewport_height = vid_get_viewport_height();
    viewport_width = vid_get_viewport_width(); 
    viewport_image_offset = vid_get_viewport_image_offset(); 
    viewport_row_offset = vid_get_viewport_row_offset(); 
    viewport_xoffset = vid_get_viewport_display_xoffset();
    viewport_yoffset = vid_get_viewport_display_yoffset();

    // if not in no-zebra phase of blink mode zebra, draw zebra to buf[]
    if (f) {
        if (viewport_yoffset > 0) { // clear top & bottom areas of buffer if image height if smaller than viewport
            memset(buf, COLOR_TRANSPARENT, viewport_yoffset*camera_screen.buffer_width);
            memset(buf+(viewport_yoffset+viewport_height)*camera_screen.buffer_width, COLOR_TRANSPARENT, viewport_yoffset*camera_screen.buffer_width);
        }
        int step_x, step_v, sy, sx;
        over = 255-conf.zebra_over;
        if (conf.zebra_multichannel) {step_x=2; step_v=6;} else {step_x=1; step_v=3;}
        for (y=viewport_yoffset, v=viewport_image_offset; y<viewport_yoffset+viewport_height; ++y) {
            sy = y*camera_screen.buffer_width;
            sx = viewport_xoffset;
            if (viewport_xoffset > 0) { // clear left & right areas of buffer if image width if smaller than viewport
                memset(buf+sy, COLOR_TRANSPARENT, sx*2);
                memset(buf+sy+(sx+viewport_width)*2, COLOR_TRANSPARENT, sx*2);
            }
            for (x=viewport_xoffset; x<viewport_xoffset+viewport_width; x+=step_x, sx+=step_x, v+=step_v) {
                register int yy;
                yy = img_buf[v+1];
                s = sy + sx*2;

                if (conf.zebra_multichannel) {
                    register int uu, vv;
                    int sel;
                    uu = (signed char)img_buf[v];
                    vv = (signed char)img_buf[v+2];
                    sel=0;
                    if (!((conf.zebra_mode == ZEBRA_MODE_ZEBRA_1 || conf.zebra_mode == ZEBRA_MODE_ZEBRA_2) && (y-x-timer)&f)) {
                        if (clip8(((yy<<12) +           vv*5743 + 2048)>>12)>over) sel  = 4; // R
                        if (clip8(((yy<<12) - uu*1411 - vv*2925 + 2048)>>12)>over) sel |= 2; // G
                        if (clip8(((yy<<12) + uu*7258           + 2048)>>12)>over) sel |= 1; // B
                    }
                    buf[s] = buf[s+1] = cls[sel];
                    buf[s+2] = buf[s+3] = cls[sel];
                }
                else if (((conf.zebra_mode == ZEBRA_MODE_ZEBRA_1 || conf.zebra_mode == ZEBRA_MODE_ZEBRA_2) && (y-x-timer)&f))
                    buf[s] = buf[s+1] = COLOR_TRANSPARENT;
                else 
                    buf[s] = buf[s+1] = (yy>over)?cl_over:(yy<conf.zebra_under)?cl_under:COLOR_TRANSPARENT;

                if (buf[s] != COLOR_TRANSPARENT && !zebra_drawn) 
                    zebra_drawn = 1;
            }
            // adjust for cases where buffer is wider than viewport (e.g. on G12)
            v += viewport_row_offset;
        }
        if (!zebra_drawn) f=0;
    }
    // if blink mode is in no-zebra phase OR if there was no over/underexposed pixels to draw zebra on
    if (!f) {
        // if zebra was drawn during previous call of this function
        if (need_restore) {
            if (conf.zebra_restore_screen || conf.zebra_restore_osd) {
                gui_set_need_restore();
            } else {  // clear buf[] of zebra, only leave Canon OSD
                if (!mrec) { // Not REC mode
                    // No Canon OSD restore, fill buf[] with transparent color:
                    memset(buf, COLOR_TRANSPARENT, buffer_size);
                }
                disp_zebra();
            }
            need_restore=0;
        }
        return !(conf.zebra_restore_screen && conf.zebra_restore_osd);
        // if zebra was drawn
    } else {
        disp_zebra();

        need_restore=1;
        return 1;
    }
    return 0;
}

static int draw_zebra_no_aspect_adjust ( int  mrec, unsigned int  f, color *  cls  )

static

Definiert in Zeile 350 der Datei zebra.c.

                                                                             {
    int v, s, x, y, over;
    static int need_restore=0;
    int viewport_height;
    int zebra_drawn=0;

    unsigned bWide = 1; // if wide (16:9) or standard (4:3) aspect ratio (but 1 in cameras that only have 4:3)
    unsigned aspOffset = 0; // offset to add to x-coord (or buffer address) when drawing zebra

    if (camera_screen.has_variable_aspect && camera_info.props.aspect_ratio)
    {
        if (shooting_get_prop(camera_info.props.aspect_ratio) == 0) // standard requires x-shift to overlay drawing
        {
            bWide = 0;
            //aspOffset = (camera_screen.width - (camera_screen.width * 12 / 16)) / 2; // = actual calculation, simplified below
            aspOffset = camera_screen.width / 8; // half of the difference in width between equal height 16:9 and 4:3 screens, = black bar width
        }
    }

    viewport_height = vid_get_viewport_height();

    // if not in no-zebra phase of blink mode zebra, draw zebra to buf[]
    if (f) {
        int step_x, step_v;
        over = 255-conf.zebra_over;
        if (conf.zebra_multichannel) {step_x=2; step_v=6;} else {step_x=1; step_v=3;}
        s = aspOffset;
        for (y=1, v=0; y<=viewport_height; ++y) {
            for (x=0; x<camera_screen.width; x+=step_x, s+=step_x, v+=step_v) {
                register int yy, uu, vv;
                int sel;

                if (!bWide && (x + aspOffset >= camera_screen.width - aspOffset)) continue; // do not draw "outside screen" 

                yy = img_buf[v+1];
                if (conf.zebra_multichannel) {
                    uu = (signed char)img_buf[v];
                    vv = (signed char)img_buf[v+2];
                    sel=0;
                    if (!((conf.zebra_mode == ZEBRA_MODE_ZEBRA_1 || conf.zebra_mode == ZEBRA_MODE_ZEBRA_2) && (y-x-timer)&f)) {
                        if (clip8(((yy<<12) +           vv*5743 + 2048)>>12)>over) sel  = 4; // R
                        if (clip8(((yy<<12) - uu*1411 - vv*2925 + 2048)>>12)>over) sel |= 2; // G
                        if (clip8(((yy<<12) + uu*7258           + 2048)>>12)>over) sel |= 1; // B
                    }
                    buf[s]=buf[s+1]=cls[sel];
                }
                else if (((conf.zebra_mode == ZEBRA_MODE_ZEBRA_1 || conf.zebra_mode == ZEBRA_MODE_ZEBRA_2) && (y-x-timer)&f)) buf[s]=COLOR_TRANSPARENT;
                else buf[s]=(yy>over)?cl_over:(yy<conf.zebra_under)?cl_under:COLOR_TRANSPARENT;
                if (buf[s] != COLOR_TRANSPARENT && !zebra_drawn) zebra_drawn = 1;
                if (mrec) {
                    // draw Canon OSD to buf[] if in REC mode
                    if(get_cur_buf(s)!=COLOR_TRANSPARENT) buf[s]=get_cur_buf(s); 
                    if(conf.zebra_multichannel && get_cur_buf(s+1)!=COLOR_TRANSPARENT) buf[s+1]=get_cur_buf(s+1); 
                }
            }
            s+=camera_screen.buffer_width-camera_screen.width;
            if (y*camera_screen.height/viewport_height == (s+camera_screen.buffer_width)/camera_screen.buffer_width) {
                memcpy(buf+s, buf+s-camera_screen.buffer_width, camera_screen.buffer_width);
                s+=camera_screen.buffer_width;
            }
        }
        if (!zebra_drawn) f=0;
    }
    // if blink mode is in no-zebra phase OR if there was no over/underexposed pixels to draw zebra on
    if (!f) {
        // if zebra was drawn during previous call of this function
        if (need_restore) {
            if (conf.zebra_restore_screen || conf.zebra_restore_osd) {
                gui_set_need_restore();
            } else {  // clear buf[] of zebra, only leave Canon OSD
                if (mrec) { // REC mode
                    // copy rescued Canon OSD to buf[] top/bottom parts and fill center with transparent color:
                    memcpy(buf, cur_buf_top, camera_screen.buffer_width * ZFIX_TOP);
                    memcpy(buf + buffer_size - camera_screen.buffer_width * ZFIX_BOTTOM, cur_buf_bot, camera_screen.buffer_width * ZFIX_BOTTOM);
                    for (s = camera_screen.buffer_width*ZFIX_TOP; s < buffer_size-camera_screen.buffer_width*ZFIX_BOTTOM; s++) {
                        buf[s]=COLOR_TRANSPARENT;
                    }
                } else { // Not REC mode
                    // No Canon OSD restore, fill buf[] with transparent color:
                    memset(buf, COLOR_TRANSPARENT, buffer_size);
                }
                disp_zebra();
            }
            need_restore=0;
        }
        return !(conf.zebra_restore_screen && conf.zebra_restore_osd);
        // if zebra was drawn
    } else {
        disp_zebra();

        need_restore=1;
        return 1;
    }
    return 0;
}

static unsigned char get_cur_buf ( unsigned int  idx)

static

Definiert in Zeile 336 der Datei zebra.c.

                                                   {
    unsigned int a;

    a=camera_screen.buffer_size - camera_screen.buffer_width * ZFIX_BOTTOM;

    if (idx < (unsigned)camera_screen.buffer_width * ZFIX_TOP) return(cur_buf_top[idx]);
    if (idx >= a && idx < (unsigned)camera_screen.buffer_size) return(cur_buf_bot[idx - a]);
    return (COLOR_TRANSPARENT);
}

int gui_osd_draw_zebra

(

int

show)

Definiert in Zeile 447 der Datei zebra.c.

{
    unsigned int f;

    if (!gui_osd_zebra_init(show))
        return 0;

    color cls[] = {
        COLOR_TRANSPARENT,
        COLOR_BLUE,
        COLOR_GREEN,
        COLOR_CYAN,
        COLOR_RED,
        COLOR_MAGENTA,
        COLOR_YELLOW,
        COLOR_BLACK
    };

    img_buf = vid_get_viewport_active_buffer();
    if (!img_buf) return 0;

    if (timer==0)
    {
        draw_guard_pixel();
        timer = 1;
        return 0;
    }

    if (timer==1)
    {
        int ready;
        static int n=0;
        if (!camera_info.state.mode_rec) ready=1;
        else get_property_case(camera_info.props.shooting, &ready, 4);
        n=draw_guard_pixel(); // will be 0 in PLAY mode, should be 1 or 2 in REC mode.
        if(!ready) return 0;
        if (cur_buf_top)
        {
            // rescue Canon OSD from scr_buf to cur_buf_top and _bot:
            if (n==1) {
                memcpy(cur_buf_top, scr_buf, camera_screen.buffer_width*ZFIX_TOP);
                memcpy(cur_buf_bot, scr_buf + camera_screen.buffer_size - camera_screen.buffer_width*ZFIX_BOTTOM, camera_screen.buffer_width*ZFIX_BOTTOM);
            }
            else {
                memcpy(cur_buf_top, scr_buf + camera_screen.buffer_size, camera_screen.buffer_width*ZFIX_TOP);
                memcpy(cur_buf_bot, scr_buf + 2*camera_screen.buffer_size - camera_screen.buffer_width*ZFIX_BOTTOM, camera_screen.buffer_width*ZFIX_BOTTOM);
            }
        }
    }
    ++timer;

    switch (conf.zebra_mode)
    {
        case ZEBRA_MODE_ZEBRA_1:    f = 4;          break;
        case ZEBRA_MODE_ZEBRA_2:    f = 8;          break;
        case ZEBRA_MODE_SOLID:      f = 1;          break;
        case ZEBRA_MODE_BLINKED_1:  f = timer&1;    break;
        case ZEBRA_MODE_BLINKED_3:  f = timer&4;    break;
        case ZEBRA_MODE_BLINKED_2:  
        default:                    f = timer&2;    break;
    }

    if (camera_screen.zebra_aspect_adjust)
        return draw_zebra_aspect_adjust(camera_info.state.mode_rec,f,cls);    // For newer cameras with 720/960 pixel wide screen
    else
        return draw_zebra_no_aspect_adjust(camera_info.state.mode_rec,f,cls); // For older cameras with 360/480 pixel wide screen
}

static void gui_osd_draw_zebra_osd ( )

static

Definiert in Zeile 204 der Datei zebra.c.

                                     {
    switch (conf.zebra_draw_osd) {
        case ZEBRA_DRAW_NONE:
            break;
        case ZEBRA_DRAW_OSD:
            if (conf.show_osd) {
                draw_set_draw_proc(draw_pixel_buffered);
                gui_draw_osd_elements(0,1);
                draw_set_draw_proc(NULL);
            }
            /* no break here */
        case ZEBRA_DRAW_HISTO:
        default:
            draw_set_draw_proc(draw_pixel_buffered);
            libhisto->gui_osd_draw_histo(0);
            draw_set_draw_proc(NULL);
            break;
    }
}

static void gui_osd_zebra_free ( )

static

Definiert in Zeile 120 der Datei zebra.c.

{
    if (buf != scr_buf) free(buf);
    buf = NULL;

    free(cur_buf_top);
    cur_buf_top = NULL;

    free(cur_buf_bot);
    cur_buf_bot = NULL;
}

static int gui_osd_zebra_init ( int  show)

static

Definiert in Zeile 133 der Datei zebra.c.

{
    cl_under = BG_COLOR(user_color(conf.zebra_color));
    cl_over = FG_COLOR(user_color(conf.zebra_color));

    if (show)
    {
        if (!buf)
        {
            timer = 0;
            // Determine bitmap buffer size. If physical buffer is taller than displayed height then ignore bottom strip - (used to be ZEBRA_HMARGIN0).
            buffer_size = camera_screen.buffer_size - (camera_screen.buffer_height - camera_screen.height) * camera_screen.buffer_width;
            scr_buf = vid_get_bitmap_fb();
            if (camera_screen.zebra_nobuf == 0)
            {
                buf = malloc(buffer_size);
                //gui_mbox_init(LANG_WARNING, (int)"No space to allocate zebra buffer: restart camera", MBOX_BTN_OK|MBOX_TEXT_CENTER, NULL);
            }
            if (!buf)
            {
                buf = scr_buf;  //without new buffer: directly into screen buffer: we got some flickering in OSD and histogram but it's usable
            }
            if (camera_screen.zebra_aspect_adjust)
            {
                cur_buf_top = cur_buf_bot = 0;
            }
            else
            {
                cur_buf_top = malloc(camera_screen.buffer_width * ZFIX_TOP); 
                cur_buf_bot = malloc(camera_screen.buffer_width * ZFIX_BOTTOM); 
                // cleanup and disable zebra if any mallocs failed
                if (!cur_buf_top || !cur_buf_bot)
                    gui_osd_zebra_free();
                if (cur_buf_top) memset(cur_buf_top,0,camera_screen.buffer_width * ZFIX_TOP);
                if (cur_buf_bot) memset(cur_buf_bot,0,camera_screen.buffer_width * ZFIX_BOTTOM);
            }
            // in variable aspect, the borders would never be cleared
            if (camera_screen.has_variable_aspect)
                memset(buf,0,buffer_size);
        }
    }
    else {
        if (buf) // if zebra was previously on, restore
            gui_set_need_restore();

        gui_osd_zebra_free();
    }
    return (buf != NULL);
}

Variablen-Dokumentation

libzebra_sym _libzebra

Initialisierung:

=
{
    {
         0, _module_unloader, _module_can_unload, 0, 0
    },

    gui_osd_draw_zebra
}

Definiert in Zeile 777 der Datei zebra.c.

ModuleInfo _module_info

Initialisierung:

=
{
    MODULEINFO_V1_MAGICNUM,
    sizeof(ModuleInfo),
    ZEBRA_VERSION,              

    ANY_CHDK_BRANCH, 0, OPT_ARCHITECTURE,           
    ANY_PLATFORM_ALLOWED,       

    (int32_t)"Zebra Overlay (dll)",
    MTYPE_EXTENSION,

    &_libzebra.base,

    CONF_VERSION,               
    CAM_SCREEN_VERSION,         
    ANY_VERSION,                
    CAM_INFO_VERSION,           

    0,
}

Definiert in Zeile 786 der Datei zebra.c.

unsigned char* buf = NULL

static

Definiert in Zeile 109 der Datei zebra.c.

int buffer_size

static

Definiert in Zeile 110 der Datei zebra.c.

color cl_over

static

Definiert in Zeile 113 der Datei zebra.c.

color cl_under

static

Definiert in Zeile 113 der Datei zebra.c.

unsigned char * cur_buf_bot

static

Definiert in Zeile 108 der Datei zebra.c.

unsigned char* cur_buf_top

static

Definiert in Zeile 108 der Datei zebra.c.

unsigned char* img_buf

static

Definiert in Zeile 105 der Datei zebra.c.

unsigned char* scr_buf

static

Definiert in Zeile 107 der Datei zebra.c.

int timer = 0

static

Definiert in Zeile 112 der Datei zebra.c.