Changeset 1365

Timestamp:

10/15/11 04:22:52 (20 months ago)

Author:

philmoz

Message:

Remove the code that is no longer needed from the 9/4 scaling of the CHDK OSD display. See ​http://chdk.setepontos.com/index.php?topic=6395.msg66961#msg66961.

Location:

trunk

Files:

• core/edgeoverlay.c (modified) (4 diffs)
• core/gui.c (modified) (5 diffs)
• core/gui_draw.c (modified) (8 diffs)
• core/gui_draw.h (modified) (1 diff)
• core/gui_grid.c (modified) (1 diff)
• core/motion_detector.c (modified) (1 diff)
• include/camera.h (modified) (3 diffs)
• platform/ixus310_elph500hs/platform_camera.h (modified) (1 diff)

trunk/core/edgeoverlay.c

@@ -36 +36 @@
 static void get_viewport_size()
 {
-    // since screen_height is used in the drawing downwards, we should use it
-    // here too to calculate the buffer we need...
-
-#if defined(CAM_USES_ASPECT_CORRECTION)
-    //nandoide sept-2009 get the viewport dimensions, not the screen dimensions, on sx200is they aren't the same.
     viewport_height = vid_get_viewport_height()-EDGE_HMARGIN*2; //don't trace bottom lines
     viewport_width = vid_get_viewport_width();
     viewport_byte_width = vid_get_viewport_buffer_width() * 3;
-#else
-    viewport_height = screen_height;//vid_get_viewport_height();
-    viewport_width = screen_width;
-    viewport_byte_width = screen_width * 3;
-#endif
 
         viewport_xoffset = vid_get_viewport_xoffset();
@@ -518 +508 @@
                     // If there is no edge based on the newest data, but there is one painted on the screen
                     // from previous calls, delete it from the screen.
-                    const int aspect_correct_x_off = ASPECT_VIEWPORT_XCORRECTION(x_off);
+                    const int aspect_correct_x_off = x_off;
                     const int bEdge = bv_get(edgebuf, y_edgebuf + x);
                     const int bDraw = bEdge || (draw_get_pixel(aspect_correct_x_off, y_off) == conf.edge_overlay_color);
@@ -546 +536 @@
             for (x = x_min_c; x < x_max_c; ++x)
             {
-                const int aspect_correct_x = ASPECT_VIEWPORT_XCORRECTION(x);
+                const int aspect_correct_x = x;
                 if (draw_get_pixel(aspect_correct_x, y) == cl)  // if there is an edge drawn on the screen but there is no edge there based on the newest data, delete it from the screen
                     draw_pixel(aspect_correct_x, y, 0 );
@@ -564 +554 @@
             for (x = x_min; x < x_max; ++x)
             {
-                const int aspect_correct_x = ASPECT_VIEWPORT_XCORRECTION(x);
+                const int aspect_correct_x = x;
                 if (draw_get_pixel(aspect_correct_x, y) == cl)  // if there is an edge drawn on the screen but there is no edge there based on the newest data, delete it from the screen
                     draw_pixel(aspect_correct_x, y, 0 );

trunk/core/gui.c

@@ -2092 +2092 @@
     gui_in_redraw = 1;
     gui_mode_old = gui_mode;
-
-#if CAM_USES_ASPECT_CORRECTION //nandoide sept-2009
-    //the different modes arises because games are designed on a 360x240 basis and are difficult to downscale to 320x240
-    if (gui_mode == GUI_MODE_REVERSI || gui_mode == GUI_MODE_SOKOBAN || gui_mode == GUI_MODE_4WINS || gui_mode == GUI_MODE_MASTERMIND) {
-      draw_set_environment(aspect_xcorrection_games_360, aspect_ycorrection_games_360, GAMES_SCREEN_WIDTH, GAMES_SCREEN_HEIGHT);
-   } else { //default
-      draw_set_environment(NULL, NULL, vid_get_bitmap_screen_width(), vid_get_bitmap_screen_height());
-   }
-#endif
 
 #ifdef CAM_TOUCHSCREEN_UI
@@ -2627 +2618 @@
     }
 
-    #if CAM_USES_ASPECT_CORRECTION //nandoide sept-2009
-      draw_set_environment(aspect_xcorrection_games_360, aspect_ycorrection_games_360, GAMES_SCREEN_WIDTH, GAMES_SCREEN_HEIGHT);
-    #endif
     gui_set_mode(GUI_MODE_REVERSI);
     gui_reversi_init();
@@ -2643 +2631 @@
         return;
     }
-    #if CAM_USES_ASPECT_CORRECTION //nandoide sept-2009
-      draw_set_environment(aspect_xcorrection_games_360, aspect_ycorrection_games_360, GAMES_SCREEN_WIDTH, GAMES_SCREEN_HEIGHT);
-    #endif
     if ( gui_sokoban_init() )
         gui_set_mode(GUI_MODE_SOKOBAN);
@@ -2658 +2643 @@
         return;
     }
-    #if CAM_USES_ASPECT_CORRECTION //nandoide sept-2009
-      draw_set_environment(aspect_xcorrection_games_360, aspect_ycorrection_games_360, GAMES_SCREEN_WIDTH, GAMES_SCREEN_HEIGHT);
-    #endif
     if ( gui_4wins_init() )
         gui_set_mode(GUI_MODE_4WINS);
@@ -2673 +2655 @@
         return;
     }
-    #if CAM_USES_ASPECT_CORRECTION //nandoide sept-2009
-     draw_set_environment(aspect_xcorrection_games_360, aspect_ycorrection_games_360, GAMES_SCREEN_WIDTH, GAMES_SCREEN_HEIGHT);
-    #endif
-   if ( gui_mastermind_init() )
+    if ( gui_mastermind_init() )
         gui_set_mode(GUI_MODE_MASTERMIND);
 }

trunk/core/gui_draw.c

@@ -23 +23 @@
 }
 
-#if CAM_USES_ASPECT_CORRECTION //nandoide sept-2009 
-
-unsigned int (*aspect_xcorrection_proc)(unsigned int x);
-unsigned int (*aspect_ycorrection_proc)(unsigned int y);
-
-//-------------------------------------------------------------------
-unsigned int aspect_xcorrection_std(unsigned int x) {
-   return (ASPECT_XCORRECTION(x));
-}
-//-------------------------------------------------------------------
-static unsigned int aspect_ycorrection_std(unsigned int y) {
-   return (ASPECT_YCORRECTION(y));
-}
-//-------------------------------------------------------------------
-unsigned int aspect_xcorrection_games_360(unsigned int x) {
-   return (ASPECT_GAMES_XCORRECTION(x));
-}
-//-------------------------------------------------------------------
-unsigned int aspect_ycorrection_games_360(unsigned int y) {
-   return (ASPECT_GAMES_YCORRECTION(y));
-}
-//-------------------------------------------------------------------
-void draw_set_aspect_xcorrection_proc(unsigned int (*xcorrection_proc)(unsigned int x)) {
-   aspect_xcorrection_proc = (xcorrection_proc)?xcorrection_proc:aspect_xcorrection_std;
-}
-//-------------------------------------------------------------------
-void draw_set_aspect_ycorrection_proc(unsigned int (*ycorrection_proc)(unsigned int y)) {
-   aspect_ycorrection_proc = (ycorrection_proc)?ycorrection_proc:aspect_ycorrection_std;
-}
-//-------------------------------------------------------------------
-void draw_set_environment(unsigned int (*xcorrection_proc)(unsigned int x), 
-                                       unsigned int (*ycorrection_proc)(unsigned int y),
-                                       int screenx, int screeny ) {
-   screen_width=screenx;
-   screen_height=screeny;
-   draw_set_aspect_xcorrection_proc(xcorrection_proc);
-   draw_set_aspect_ycorrection_proc(ycorrection_proc);
-}
-
-#endif
-
 //-------------------------------------------------------------------
 #ifdef CAM_DETECT_SCREEN_ERASE
@@ -86 +45 @@
 {
     if (x >= screen_width || y >= screen_height) return 0;
-#if CAM_USES_ASPECT_CORRECTION
-    return (frame_buffer[0][y * screen_buffer_width + aspect_xcorrection_proc(x)] == c) &&
-           (frame_buffer[1][y * screen_buffer_width + aspect_xcorrection_proc(x)] == c);
-#else
-    return (frame_buffer[0][y * screen_buffer_width + x] == c) &&
-           (frame_buffer[1][y * screen_buffer_width + x] == c);
-#endif
+    return (frame_buffer[0][y * screen_buffer_width + ASPECT_XCORRECTION(x)] == c) &&
+           (frame_buffer[1][y * screen_buffer_width + ASPECT_XCORRECTION(x)] == c);
 }
 
@@ -110 +64 @@
     frame_buffer[1] = frame_buffer[0] + screen_buffer_size;
     draw_set_draw_proc(NULL);
-    #if CAM_USES_ASPECT_CORRECTION
-      draw_set_aspect_xcorrection_proc(NULL);
-      draw_set_aspect_ycorrection_proc(NULL);
-    #endif
 
 #ifdef CAM_DETECT_SCREEN_ERASE
@@ -120 +70 @@
 }
 
-#if CAM_USES_ASPECT_CORRECTION
-
-// nandoide: sept-2009: draw_pixel_xarray draws a horizontal line at height y, from xi to xf
-// includes a correction of aspect ratio on x from buffer to screen
-// can be used to optimize computations (offset calculus) in other primitives (rectangles, and so on...) and compensate tne increase in computation time 
-// of aspect ratio correction.
-// sx200is:
-//    we have a 720x240 efective memory buffer (in a 960x270 physical memory buffer) and a screen of 320x240 (!) 
-//   the drawing primitives work on screen coordinates (the other approach, less modular it's to paint on buffer coordinates, deforming on x direction, I think it would be harder to live with it
-//   and requires a full bunch of changes of the actual software).
-//   then we do paint a x coordinate transformed in buffer by a factor 720/320=9/4 and then we do correct (deform) x  to x*9/4 previously to save it on buffer
-// other:
-//     the default mapping is x=x (NOTE: I think important to check that on every model, and necessary in newer models. it seems to me very strange screen sizes of 360x240 for 4/3 and 480/240 for 16/9 (SX1S).
-
-void draw_pixel_xarray(coord y, coord xi, coord xf, color cl) {
-    if (xi >= screen_width || y >= screen_height) return;
-    else {
-        unsigned int offsetx, offsetxf, offsetxi, offsety;
-        offsety=aspect_ycorrection_proc(y) * screen_buffer_width;
-        offsetxi = aspect_xcorrection_proc(xi);
-        xf++;
-        offsetxf= (xf >= screen_width) ? screen_buffer_width - 1 :  aspect_xcorrection_proc(xf);
-        for (offsetx=offsetxi; offsetx<=offsetxf-1; offsetx++) {
-           draw_pixel_proc(offsety+offsetx, cl);
-        }
-    }
-}
-
-#if  CAM_USES_ASPECT_YCORRECTION
-//generalization for cases than we need to correct both coordinates: symetric algorithm
-void draw_pixel_rectanglearray(coord yi, coord yf, coord xi, coord xf, color cl) {
-    if (xi >= screen_width || yi >= screen_height) return;
-    else {
-        unsigned int offsetx, offsetxf, offsetxi, offsety, offsetyf, offsetyi, offset;
-        offsetyi = aspect_ycorrection_proc(yi);
-        yf++;
-        offsetyf= (yf >= screen_height) ? screen_buffer_height - 1 :  aspect_ycorrection_proc(yf);
-        offsetxi = aspect_xcorrection_proc(xi);
-        xf++;
-        offsetxf= (xf >= screen_width) ? screen_buffer_width - 1 :  aspect_xcorrection_proc(xf);
-        for (offsety=offsetyi; offsety<=offsetyf-1; offsety++) {
-          offset=offsety*screen_buffer_width;
-          for (offsetx=offsetxi; offsetx<=offsetxf-1; offsetx++) {
-             draw_pixel_proc(offset+offsetx, cl);
-          }
-        }
-    }
-}
-#endif
-
-// nandoide sept-2009: draw_pixel version that calls draw_pixel_xarray for calculations. It's necessary to paint more than a pixel. In other case we got holes due
-// to the nature of discrete drawing algoritms and the aspect-ratio correction.
-// so, we need paint a horizontal line from the point coordinate to the next point (x to x+1)
-// it's a brute force algorithm and it's possible that we have aliasing problems ... 
-// but the display seems OK on sx200is ( good!) , due perhaps to the fact that the system makes a final reverse (bilinear?) resize 720 -> 320, to display the buffer data.
-
-void draw_pixel(coord x, coord y, color cl) {
-  #if  CAM_USES_ASPECT_YCORRECTION
-    draw_pixel_rectanglearray(y, y, x, x, cl);
-  #else
-    draw_pixel_xarray(y, x, x, cl);
-  #endif
-}
-
-color draw_get_pixel(coord x, coord y) {
-    if (x >= screen_width || y >= screen_height) return 0;
-    return frame_buffer[0][y * screen_buffer_width + aspect_xcorrection_proc(x) ];
-}
-#else
 //-------------------------------------------------------------------
 void draw_pixel(coord x, coord y, color cl) {
     if (x >= screen_width || y >= screen_height) return;
     else {
-        register unsigned int offset = y * screen_buffer_width + x;
-        draw_pixel_proc(offset, cl);
+        register unsigned int offset = y * screen_buffer_width + ASPECT_XCORRECTION(x);
+        draw_pixel_proc(offset,   cl);
+#if CAM_USES_ASPECT_CORRECTION
+        draw_pixel_proc(offset+1, cl);  // Draw second pixel if screen scaling is needed
+#endif
    }
 }
@@ -201 +85 @@
 color draw_get_pixel(coord x, coord y) {
     if (x >= screen_width || y >= screen_height) return 0;
-    return frame_buffer[0][y * screen_buffer_width + x];
-}
-#endif
+    return frame_buffer[0][y * screen_buffer_width + ASPECT_XCORRECTION(x) ];
+}
 
 //-------------------------------------------------------------------
@@ -237 +120 @@
 void draw_hline(coord x, coord y, int len, color cl)
 {
-    #if CAM_USES_ASPECT_CORRECTION &&  !CAM_USES_ASPECT_YCORRECTION
-      draw_pixel_xarray(y, x, x+len, cl);
-    #else
-      for (; len>=0; len--, x++) {
-          draw_pixel(x, y, cl);
-      }
-    #endif
+    if (x >= screen_width || y >= screen_height) return;
+    if (x < 0) { len += x; x = 0; }
+    if ((x + len) > screen_width) len = screen_width - x;
+    register unsigned int offset = y * screen_buffer_width + ASPECT_XCORRECTION(x);
+    len = ASPECT_XCORRECTION(len);      // Scale the line length if needed
+    for (; len>=0; len--, offset++)
+        draw_pixel_proc(offset, cl);
 }
 
 void draw_vline(coord x, coord y, int len, color cl)
 {
-    for (; len>=0; len--, y++) {
+    if ((x < 0) || (x >= screen_width) || (y >= screen_height)) return;
+    if (y < 0) { len += y; y = 0; }
+    if ((y + len) > screen_height) len = screen_height - y;
+    for (; len>=0; len--, y++)
       draw_pixel(x, y, cl);
-    }
 }
 //-------------------------------------------------------------------
@@ -276 +161 @@
     if (yMin>=screen_height) yMin=screen_height-1;
 
-    for (y=yMin+(round<<1); y<=yMax-(round<<1); ++y) {
+    for (y=yMin+(round<<1); y<=yMax-(round<<1); ++y)
+    {
       draw_pixel(xMin, y, cl);
       draw_pixel(xMax, y, cl);
     }
-    #if CAM_USES_ASPECT_CORRECTION &&  !CAM_USES_ASPECT_YCORRECTION
-      draw_pixel_xarray(yMin, xMin+1+round, xMax-1-round, cl);
-      draw_pixel_xarray(yMax, xMin+1+round, xMax-1-round, cl);
-    #else
-      for (x=xMin+1+round; x<=xMax-1-round; ++x) {
-          draw_pixel(x, yMin, cl);
-          draw_pixel(x, yMax, cl);
-      }
-    #endif
+
+    draw_hline(xMin+1+round, yMin, (xMax-1-round) - (xMin+1+round) + 1, cl);
+    draw_hline(xMin+1+round, yMax, (xMax-1-round) - (xMin+1+round) + 1, cl);
 }
 
@@ -331 +211 @@
     register unsigned int x, y;
 
-    for (y=yMin+1; y<=yMax-1; ++y) {
-      #if CAM_USES_ASPECT_CORRECTION &&  !CAM_USES_ASPECT_YCORRECTION
-        draw_pixel_xarray(y, xMin+1, xMax-1, cl>>8);
-      #else  
-        for (x=xMin+1; x<=xMax-1; ++x) {
-          draw_pixel(x, y, cl>>8);
-        }
-      #endif
+    cl = cl >> 8;
+    for (y=yMin+1; y<=yMax-1; ++y)
+    {
+        draw_hline(xMin+1, y, (xMax-1) - (xMin+1) + 1, cl);
     }
 }

trunk/core/gui_draw.h

@@ -733 +733 @@
 #endif
 
-#if CAM_USES_ASPECT_CORRECTION //nandoide sept-2009
-void draw_set_aspect_xcorrection_proc(unsigned int (*xcorrection_proc)(unsigned int x));
-void draw_set_aspect_ycorrection_proc(unsigned int (*ycorrection_proc)(unsigned int y));
-unsigned int aspect_xcorrection_games_360(unsigned int x);
-unsigned int aspect_ycorrection_games_360(unsigned int y);
-void draw_set_environment(unsigned int (*xcorrection_proc)(unsigned int x),
-                                       unsigned int (*ycorrection_proc)(unsigned int y),
-                                       int screenx, int screeny );
-#endif
-
 //-------------------------------------------------------------------
 #endif

trunk/core/gui_grid.c

@@ -86 +86 @@
     if (gptr) {
       gptr->type=type;
-      #if CAM_USES_ASPECT_CORRECTION //nandoide sep-2009
-        gptr->x0=ASPECT_GRID_XCORRECTION(nums[0]);  gptr->y0=ASPECT_GRID_YCORRECTION(nums[1]);
-        gptr->x1=ASPECT_GRID_XCORRECTION(nums[2]);  gptr->y1=ASPECT_GRID_YCORRECTION(nums[3]);
-      #else
-        gptr->x0=nums[0];  gptr->y0=nums[1];
-        gptr->x1=nums[2];  gptr->y1=nums[3];
-      #endif
+      gptr->x0=nums[0];  gptr->y0=nums[1];
+      gptr->x1=nums[2];  gptr->y1=nums[3];
       gptr->clf=nums[4]; gptr->clb=nums[5];
       if (!head) head=gptr;

trunk/core/motion_detector.c

@@ -559 +559 @@
         }
 
-        xoffset = ASPECT_VIEWPORT_XCORRECTION(vid_get_viewport_xoffset());      // used when image size != viewport size
+        xoffset = vid_get_viewport_xoffset();   // used when image size != viewport size
         yoffset = vid_get_viewport_yoffset();   // used when image size != viewport size
 

trunk/include/camera.h

@@ -96 +96 @@
 #define ZEBRA_HMARGIN0              0
 
-// aspect corrections
-#define CAM_USES_ASPECT_CORRECTION  0           // if true, camera uses a modified graphics primitives to draw with exact display aspect-ratio.
-                                                // Could slow the graphics output (but not perceived on sx200is), but adds rectangle drawing optimizations to compensate.
-                                                // To extend to other cameras see sx200is camera.h comments in  and comments on core gui_draw.c
-#define CAM_USES_ASPECT_YCORRECTION 0
-
-// menu, alt (default)
-#define ASPECT_XCORRECTION(x)  ( ((x)<<1) )     // see comments on 200is
-#define ASPECT_YCORRECTION(y)  ( (y) )          // no correction the same for coordinate y. I think there are no cameras actually needing both corrections.
-// viewport, defaults used if there is no aspect correction
-#define ASPECT_VIEWPORT_XCORRECTION(x) ( (x) )  // see comments on 200is
-#define ASPECT_VIEWPORT_YCORRECTION(y) ( (y) )  // no correction
+// Older cameras had a screen/bitmap buffer that was 360 pixels wide (or 480 for wide screen models)
+// CHDK was built around this 360 pixel wide display model
+// Newer cameras have a 720 pixel wide bitmap (960 for wide screen cameras)
+// To accomadate this the CHDK co-ordinate system assumes a 360/480 wide buffer and the
+// pixel drawing routines draw every pixel twice to scale the image up to the actual buffer size
+// Define CAM_USES_ASPECT_CORRECTION with a value of 1 to enable this scaled display
+#define CAM_USES_ASPECT_CORRECTION  0
 
 #define EDGE_HMARGIN                0           // define sup and inf screen margins on edge overlay without overlay.  Necessary to save memory buffer space. sx200is needs values other than 0
@@ -153 +148 @@
                                                 // This reduces the file size by approx 45%
 
-// Games definitions
-#define GAMES_SCREEN_WIDTH            360        // Logical screen width for games
-#define GAMES_SCREEN_HEIGHT            240       // Logical screen height for games
-#define ASPECT_GAMES_XCORRECTION(x)    ((x)<<1)  // Aspect ratio correction for games. Default for games is 360x240 logical screen. Physical camera screen is
-#define ASPECT_GAMES_YCORRECTION(y)    (y)       // 720x240 so x*2 needed for X axis correction, no correction for Y.
-
-// Grid definitions
-#define ASPECT_GRID_XCORRECTION(x)    (x)        // Aspect ratio correction for grids. Grids are designed on a 360x240 logical screen size which matches the
-#define ASPECT_GRID_YCORRECTION(y)    (y)        // default CHDK logical screen size so no correction needed.
-
 #undef  PARAM_CAMERA_NAME                        // parameter number for GetParameterData to get camera name
 
@@ -200 +185 @@
 //==========================================================
 
+// For newer cameras where the screen bitmap is double the width we need to scale
+// the CHDK horizontal (X) co-ordinates
+#if CAM_USES_ASPECT_CORRECTION
+#define ASPECT_XCORRECTION(x)   ((x)<<1)    // See comments for CAM_USES_ASPECT_CORRECTION above
+#else
+#define ASPECT_XCORRECTION(x)   (x)         // See comments for CAM_USES_ASPECT_CORRECTION above
+#endif
 
 // curves only work in 10bpp for now

trunk/platform/ixus310_elph500hs/platform_camera.h

@@ -79 +79 @@
     #undef CAM_USES_ASPECT_CORRECTION
     #define CAM_USES_ASPECT_CORRECTION  1       //camera uses the modified graphics primitives to map screens an viewports to buffers more sized
-    #undef GAMES_SCREEN_WIDTH
-    #define GAMES_SCREEN_WIDTH          480     // Logical screen width for games
 
     #undef EDGE_HMARGIN