source: trunk/core/edgeoverlay.c @ 580

#include "edgeoverlay.h"
#include "platform.h"
#include "conf.h"
#include "keyboard.h"
#include "stdlib.h"
#include "gui_draw.h"

// This edge overlay code has major changes to the "old" one. One major change
// is, that it doesn cause my cam (ixus 950) to crash anymore by mistaking the
// boundaries of the viewport buffer it can read from and write pixels to.
// Unfortunately it still has the bug (that is also present in the original
// version) that when you move the overlay too much you again overwrite data.
// One might not necessarily notice it at once, or at all, but for me
// unfortunately it overwrote vital data for the chdk menu structure.
// 
// Also the old version was flickering for me and wasn't playing well with the
// chdk osd. I tried to change a bit about that, which makes it also a bit
// faster updating, at least on my cam.
//
// And then of course, this can load the viewport to a seperate file 

// the way we save edge overlays on their own...
#define EDGE_FILE_PREFIX "edge_"
#define EDGE_FILE_FORMAT EDGE_FILE_PREFIX "%04d.edg"

static char * imgbuf = 0;
static char * imgbuf_end = 0;
static int inmem=0;
// whole viewport size in bytes ??
static int viewport_size = 0;
// width in bytes of one viewport line ??
static int viewport_width;// screenwidth * 3
// flag to remember if current buffer is already saved, so hitting save won't
// save it again
static int is_saved = 0;
// set this to 1 when things need to be moved, so that a redraw clears "old"
// pixels... Otherwise it just will write pixels that need edge overlay data.
// This sometimes leaves trails when the pixel alignment isn't nice but it is
// better than writing "transparent" to everwhere, essentially overwriting
// important things that will cause flickering.
static int need_redraw = 0;

// debug output that waits
void out_wait( const char* buf );

void get_viewport_size( ) {
        static int viewport_height;

        // since screen_height is used in the drawing downwards, we should use it
        // here too to calculate the buffer we need...
        viewport_height = screen_height;//vid_get_viewport_height();
        viewport_width = screen_width * 3;
        viewport_size = viewport_height * screen_width * 3;
}

void ensure_allocate_imagebuffer( ) { 
        if(imgbuf == 0)
        {
                imgbuf = malloc( viewport_size );
                imgbuf_end = imgbuf + (viewport_size);
        }
}

// scans a filename for the number of the edge detection file it contains
int get_edge_file_num( const char* fn )
{
        int num = 0;
        if( strncmp(fn,EDGE_FILE_PREFIX,sizeof(EDGE_FILE_PREFIX)-1) == 0 )
        { // has the correct beginning at least, now try to read as a number...
                fn += sizeof(EDGE_FILE_PREFIX);
                while( *fn == '0' ) // skip leading 0s
                {
                        ++fn;
                }
                while( isdigit(*fn) )
                {
                        num *= 10;
                        num += *fn - '0';
                        ++fn;
                }
                // ignore anything else after it, that is like the ending etc.
        }
        return num;
}

// we eat up to 300k of memory, for people needing it we have a menu point
// where they can manually free it. makes of course only sense when the edge
// overlay is not active.
void free_memory_edge_overlay(void){
        char buf[64];
        free(imgbuf);
        imgbuf = 0;
        sprintf(buf,"Freed %u bytes",viewport_size);
        draw_string(30, 10, buf, conf.osd_color);
        viewport_size = 0;
}

// saves the actual active overlay data to a file... Well, actually the
// viewport is saved...
void save_edge_overlay(void){

        char fn[64];
        char msg[64];
        FILE *fd;
        DIR* d;
        int fnum = 0;
        int fr = 0;
        int zoom = shooting_get_zoom();
        struct dirent* de;

        // nothing to save? then dont save
        if( !imgbuf ) return;

        // first figure out the most appropriate filename to use
        d = opendir(EDGE_SAVE_DIR);
        if( ! d )
        {
                return;
        }

        while( (de = readdir(d)) )
        {
                fr = get_edge_file_num(de->name);
                if( fr > fnum )
                {
                        fnum = fr;
                }
        }
        ++fnum; // the highest is set, we use the next one
        get_viewport_size();
        // open the right file
        sprintf(fn, EDGE_SAVE_DIR "/" EDGE_FILE_FORMAT, fnum );
        fd = fopen(fn, "wb");
        if(fd !=NULL)
        {
                // write the data
                fwrite(imgbuf,viewport_size,1,fd);
                fwrite(&zoom,4,1,fd);
                is_saved = 1;
                fclose(fd);
                sprintf(msg, "Saved as %s",fn);
                draw_string(30, 10, msg, conf.osd_color);
        }
        closedir(d);
}

// load the viewport copy thats being used for edge detection (and from that
// displaying) from a file
void load_edge_overlay( const char* fn ) {
        FILE *fd;
        int ret,ret2=0;
        int zoom;

        is_saved = 1; // won't want to save it again, its already there
        get_viewport_size();
        ensure_allocate_imagebuffer( );
        fd = fopen(fn,"rb");
        if( fd != NULL )
        {
                ret = fread(imgbuf,viewport_size,1,fd);
                ret2 = fread (&zoom,4,1,fd);
                fclose(fd);
                if( (ret == 1) && (ret2 == 1) )
                {
                        inmem = 1; // fake having loaded stuff
                        if (conf.edge_overlay_zoom)     shooting_set_zoom(zoom);
                }
        }
}

// paint the edge overlay
void edge_overlay(){

        static int shotTaken = 0;
        static int imgmem = 0;
        static int ymin = 0;
        static int thresh;
        thresh = conf.edge_overlay_thresh; //40
        static int xoffset = 0;
        static int yoffset = 0;
        static int full_press = 0;//cure for flaky behavior. due to multiple  returns to the scrip during one full press
        static char strbuf[7] = "Frozen";
        static unsigned char *img;
        int i, hi, c;
        int x, y, h, v, ymax, y1, x1, y2;
        const char * ptrh1;
        const char * ptrh2;
        const char * ptrv1;
        const char * ptrv2;
        char xbuf[64];
        char * optr;

        is_saved = 0; // a new one, we could potentially save it
        if((mode_get()&MODE_MASK) != MODE_PLAY)
        {
                img = vid_get_viewport_fb();
        }
        else
        {
                img = vid_get_viewport_fb_d();
        }
        get_viewport_size();
        ensure_allocate_imagebuffer( );
        if(imgbuf == 0) return; // ensure failed, make the best we can out of it

        if(conf.edge_overlay_play || ((mode_get()&MODE_MASK) != MODE_PLAY) ) {
                // setup offsets for moving the edge overlay around. Always set
                // need_redraw so that we actually do a complete redraw, overwriting
                // also old pixels
                if (kbd_is_key_pressed(KEY_RIGHT)) {
                        xoffset -=XINC;
                        ++need_redraw;
                }
                if (kbd_is_key_pressed(KEY_LEFT)) {
                        xoffset +=XINC;
                        ++need_redraw;
                }
                if (kbd_is_key_pressed(KEY_DOWN)) {
                        yoffset -=YINC;
                        ++need_redraw;
                }
                if (kbd_is_key_pressed(KEY_UP)) {
                        yoffset +=YINC;
                        ++need_redraw;
                }

                if ((kbd_is_key_pressed(KEY_SHOOT_HALF)||kbd_is_key_pressed(KEY_SHOOT_FULL)) && (conf.edge_overlay_lock!=1)) {
                        if (kbd_is_key_pressed(KEY_SHOOT_FULL) && !full_press) {
                                shotTaken = 1 - shotTaken;
                                memcpy(imgbuf,img,viewport_size);
                                ymin = CALCYMARGIN;
                                inmem = 1;
                                full_press = 1;
                                xoffset = 0;
                                yoffset = 0;
                                return;
                        }
                        if(shotTaken) {
                                return;
                        }
                        memcpy(imgbuf,img,viewport_size);
                        ymin = CALCYMARGIN;
                        inmem = 1;
                        xoffset = 0;
                        yoffset = 0;
                        return;
                }
                else full_press = 0;



                if (inmem && (ymin < screen_height-CALCYMARGIN)) {
                        ymax = ymin + (screen_height - 2 * CALCYMARGIN) / NSTAGES;
                        if(ymax > screen_height - CALCYMARGIN) ymax = screen_height - CALCYMARGIN;
                        for (y=ymin; y<ymax; y++) {
                                ptrh1 = imgbuf + y * viewport_width + 7;
                                ptrh2 = imgbuf + y * viewport_width - 5;
                                ptrv1 = imgbuf + (y + 1) * viewport_width + 1;
                                ptrv2 = imgbuf + (y - 1) * viewport_width + 1;
                                optr = imgbuf + y * viewport_width + 3;
                                for (x=12; x<(screen_width- 4) * 3; x+=6) {
                                        h = ptrh1[x] - ptrh2[x];
                                        if(h  < 0) h = -h;
                                        v = ptrv1[x] - ptrv2[x];
                                        if(v  < 0) v = -v;
                                        optr[x] = h + v;
                                        h = ptrh1[x + 3] - ptrh2[x + 3];
                                        if(h  < 0) h = -h;
                                        v = ptrv1[x + 3] - ptrv2[x + 3];
                                        if(v  < 0) v = -v;
                                        optr[x + 2] = h + v;
                                }
                        }
                        ymin += (screen_height - 2 * CALCYMARGIN) / NSTAGES;
                        return;
                }

                if(inmem &&(ymin >= screen_height-CALCYMARGIN) && 
                        ((gui_get_mode() == GUI_MODE_NONE) || (gui_get_mode() == GUI_MODE_ALT))){

                                for (y=MARGIN; y<screen_height-MARGIN; y++) {
                                        y1 = y + yoffset;
                                        if((y1 < CALCYMARGIN) || (y1 >= screen_height - CALCYMARGIN)) {
                                                /*
                                                for (x=MARGIN; x < screen_width - MARGIN; x+=2) {
                                                        draw_pixel(x, y, 0);
                                                        draw_pixel(x+1, y, 0);
                                                }
                                                */
                                        }
                                        else {
                                                for (x=MARGIN; x < screen_width - MARGIN; x+=2) {
                                                        x1 = x + xoffset;
                                                        // leave a margin normally, only write to it when a
                                                        // full redraw is requested
                                                        if((x1 < 12) || (x1 >= screen_width-13)) {
                                                                if( need_redraw )
                                                                {
                                                                        draw_pixel(x, y, 0);
                                                                        draw_pixel(x+1, y, 0);
                                                                }
                                                        }
                                                        else {
                                                                // draw a pixel if the threshold is reached. If
                                                                // not, draw it transparent only if we want a
                                                                // complete redraw to overwrite spurious pixels
                                                                // or if the color of the existing pixel is the
                                                                // same as the overlay color
                                                                if(imgbuf[y1 * viewport_width + x1 * 3 + 3]  > thresh)
                                                                {
                                                                        draw_pixel(x, y, conf.edge_overlay_color );
                                                                }
                                                                else if( need_redraw || (draw_get_pixel(x,y) == conf.edge_overlay_color) )
                                                                {
                                                                        draw_pixel(x, y, 0);
                                                                }

                                                                if(imgbuf[y1 * viewport_width + x1 * 3 + 5]  > thresh)
                                                                {
                                                                        draw_pixel(x+1, y, conf.edge_overlay_color );
                                                                }
                                                                else if( need_redraw || (draw_get_pixel(x,y) == conf.edge_overlay_color) )
                                                                {
                                                                        draw_pixel(x+1, y, 0);
                                                                }
                                                        }
                                                }
                                }
                                // disabled drawing the grid, the new way of drawing the
                                // overlay should leave the standard grid intact, allowing the
                                // custom grid to remain intact too.
                                if(shotTaken) draw_string(30, 10, strbuf, conf.osd_color);
                        }
                        // If a complete redraw was requested, decrement the request. That
                        // way we do it as much as it was requested, also in one run. Will
                        // cause some flickering, but better than nothing.
                        if( need_redraw )
                        {
                                --need_redraw;
                        }
                        return;
                }
        }
        else {
                full_press = 0;
                inmem = 0;
                shotTaken = 0;
                ymin = 0;
                xoffset = 0;
                yoffset = 0;
        }
        return;
}

// there used to be some commented out version here. it was confusing, so I
// removed it. Its still in the svn anyways.
 
// vim: tabstop=4 shiftwidth=4