Changeset 1499


Ignore:
Timestamp:
12/22/11 21:20:18 (17 months ago)
Author:
philmoz
Message:

Rework of viewport handling to cater for cameras with 480 pixel high viewports (default is 240). Previous solution pretended that the viewport was double width. This patch replaces it with a vertical scale factor instead. Added some comments on the viewport functions in platform.h.

Location:
trunk
Files:
17 edited

Legend:

Unmodified
Added
Removed

  • trunk/core/edgeoverlay.c

    r1365 r1499  
    2929 
    3030static int viewport_byte_width; // width in bytes of one viewport line ?? 
     31static int viewport_yscale;     // Y multiplier (for cameras with 480 pixel high viewports) 
    3132static int viewport_height;     // height of visible / used area of viewport 
    3233static int viewport_width;      // width of visible / used area of viewport (in 3 byte units) 
    … …  
    3839    viewport_height = vid_get_viewport_height()-EDGE_HMARGIN*2; //don't trace bottom lines 
    3940    viewport_width = vid_get_viewport_width(); 
    40     viewport_byte_width = vid_get_viewport_buffer_width() * 3; 
     41    viewport_byte_width = vid_get_viewport_byte_width(); 
     42    viewport_yscale = vid_get_viewport_yscale(); 
    4143 
    4244        viewport_xoffset = vid_get_viewport_xoffset(); 
    … …  
    202204                               int x, int x_max) 
    203205{ 
    204     const unsigned char* ptrh2 = ptrh1 + viewport_byte_width;  // current row 
    205     const unsigned char* ptrh3 = ptrh2 + viewport_byte_width;  // next row 
     206    const unsigned char* ptrh2 = ptrh1 + viewport_byte_width*viewport_yscale;  // current row 
     207    const unsigned char* ptrh3 = ptrh2 + viewport_byte_width*viewport_yscale;  // next row 
    206208 
    207209    for (; x<x_max; x+=6) 
    … …  
    309311            shutter_fullpress |= kbd_is_key_pressed(KEY_SHOOT_FULL); 
    310312 
    311             ptrh1 = img + (y_min+y-1) * viewport_byte_width; 
     313            ptrh1 = img + (y_min+y-1) * viewport_byte_width*viewport_yscale; 
    312314            smptr = smbuf + (y+1) * viewport_byte_width; 
    313315 
    … …  
    332334 
    333335            // Filter new line 
    334             ptrh1 = img + y * viewport_byte_width; 
     336            ptrh1 = img + y * viewport_byte_width*viewport_yscale; 
    335337            smptr = smbuf + 2 * viewport_byte_width; 
    336338            average_filter_row(ptrh1, smptr, x_min, x_max); 
    … …  
    340342        else 
    341343        { 
    342             ptrh1 = img + (y-1) * viewport_byte_width; 
    343         } 
    344         ptrh2 = ptrh1 + viewport_byte_width; 
    345         ptrh3 = ptrh2 + viewport_byte_width; 
     344            ptrh1 = img + (y-1) * viewport_byte_width*viewport_yscale; 
     345        } 
     346        ptrh2 = ptrh1 + viewport_byte_width*viewport_yscale; 
     347        ptrh3 = ptrh2 + viewport_byte_width*viewport_yscale; 
    346348 
    347349        // Now we do sobel on the current line 

  • trunk/core/gui_osd.c

    r1350 r1499  
    398398    int viewport_height; 
    399399    int viewport_width;  
    400     int viewport_buffer_width; // for when viewport memory buffer is wider than viewport 
     400    int viewport_image_offset;  // for when viewport memory buffer is wider than viewport 
     401    int viewport_row_offset;    // for when viewport memory buffer is wider than viewport 
    401402    int viewport_xoffset;       // used when image size != viewport size 
    402403    int viewport_yoffset;       // used when image size != viewport size 
    … …  
    444445    viewport_height = vid_get_viewport_height(); 
    445446    viewport_width = vid_get_viewport_width();  
    446     viewport_buffer_width = vid_get_viewport_buffer_width();  
     447    viewport_image_offset = vid_get_viewport_image_offset();  
     448    viewport_row_offset = vid_get_viewport_row_offset();  
    447449        viewport_xoffset = vid_get_viewport_xoffset(); 
    448450        viewport_yoffset = vid_get_viewport_yoffset(); 
    … …  
    477479        over = 255-conf.zebra_over; 
    478480            if (conf.zebra_multichannel) {step_x=2; step_v=6;} else {step_x=1; step_v=3;} 
    479             for (y=viewport_yoffset, v=(viewport_yoffset*viewport_buffer_width+viewport_xoffset)*3; y<viewport_yoffset+viewport_height; ++y) { 
     481            for (y=viewport_yoffset, v=viewport_image_offset; y<viewport_yoffset+viewport_height; ++y) { 
    480482                sy=y*screen_buffer_width; 
    481483                sx=viewport_xoffset; 
    … …  
    516518                                } 
    517519                                // adjust for cases where buffer is wider than viewport (e.g. on G12) 
    518                                 v += ((viewport_buffer_width - viewport_width) * 3); 
     520                                v += viewport_row_offset; 
    519521            } 
    520522        if (!zebra_drawn) f=0; 

  • trunk/core/histogram.c

    r1104 r1499  
    8181                    } 
    8282                        img += vid_get_viewport_image_offset();         // offset into viewport for when image size != viewport size (e.g. 16:9 image on 4:3 LCD) 
    83             viewport_size = vid_get_viewport_height() * vid_get_viewport_buffer_width(); 
     83            viewport_size = vid_get_viewport_height() * vid_get_viewport_byte_width() * vid_get_viewport_yscale(); 
    8484            for (c=0; c<5; ++c) { 
    8585                for (i=0; i<HISTO_WIDTH; ++i) { 
    … …  
    9696        case 3: 
    9797                        x = 0;  // count how many blocks we have done on the current row (to skip unused buffer space at end of each row) 
    98             for (i=(histogram_stage-1)*6; i<viewport_size*3; i+=HISTO_STEP_SIZE*6) { 
     98            for (i=(histogram_stage-1)*6; i<viewport_size; i+=HISTO_STEP_SIZE*6) { 
    9999                y = img[i+1]; 
    100100                u = *(signed char*)(&img[i]); 

  • trunk/core/motion_detector.c

    r1365 r1499  
    397397 
    398398        vp_h = vid_get_viewport_height(); 
    399         vp_w = vid_get_viewport_buffer_width(); 
     399        vp_w = vid_get_viewport_byte_width() * vid_get_viewport_yscale(); 
    400400        img += vid_get_viewport_image_offset();         // offset into viewport for when image size != viewport size (e.g. 16:9 image on 4:3 LCD) 
    401401 
    402         x_step=vid_get_viewport_width()/motion_detector->columns; 
     402        x_step=(vid_get_viewport_width()*3)/motion_detector->columns; 
    403403        y_step=vp_h/motion_detector->rows; 
    404404 
    … …  
    431431                                y_end=(row+1)*y_step*vp_w; 
    432432                                for(y=row*y_step*vp_w; y<y_end; y+=motion_detector->pixels_step*vp_w){ 
    433                                         for(x=col*x_step; x<x_end; x+=motion_detector->pixels_step){ 
     433                                        for(x=col*x_step; x<x_end; x+=motion_detector->pixels_step*3){ 
    434434 
    435435                                                // ARRAY of UYVYYY values 
    … …  
    439439                                                default: 
    440440                                                case MD_MEASURE_MODE_Y: 
    441                                                         val = img[(y+x)*3 + 1];                         //Y 
     441                                                        val = img[y + x + 1];                           //Y 
    442442                                                        break; 
    443443                                                case MD_MEASURE_MODE_U: 
    444                                                         val = img[(y+(x&0xFFFFFFFE))*3];                //U 
     444                                                        val = img[y + (x&0xFFFFFFFE)];          //U 
    445445                                                        break; 
    446446                                                case MD_MEASURE_MODE_V: 
    447                                                         val = img[(y+(x&0xFFFFFFFE))*3 + 2];    //V 
     447                                                        val = img[y + (x&0xFFFFFFFE) + 2];      //V 
    448448                                                        break; 
    449449 
    450450                                                case MD_MEASURE_MODE_R: 
    451                                                         cy=img[(y+x)*3 + 1]; 
    452                                                         cv=img[(y+(x&0xFFFFFFFE))*3 + 2]; 
     451                                                        cy=img[y + x + 1]; 
     452                                                        cv=img[y + (x&0xFFFFFFFE) + 2]; 
    453453                                                        val = clip(((cy<<12)           + cv*5743 + 2048)>>12); // R 
    454454                                                        break; 
    455455 
    456456                                                case MD_MEASURE_MODE_G: 
    457                                                         cy=img[(y+x)*3 + 1]; 
    458                                                         cu=img[(y+(x&0xFFFFFFFE))*3]; 
    459                                                         cv=img[(y+(x&0xFFFFFFFE))*3 + 2]; 
     457                                                        cy=img[y + x + 1]; 
     458                                                        cu=img[y + (x&0xFFFFFFFE)]; 
     459                                                        cv=img[y + (x&0xFFFFFFFE) + 2]; 
    460460                                                        val = clip(((cy<<12) - cu*1411 - cv*2925 + 2048)>>12); // G 
    461461                                                        break; 
    462462 
    463463                                                case MD_MEASURE_MODE_B: 
    464                                                         cy=img[(y+x)*3 + 1]; 
    465                                                         cu=img[(y+(x&0xFFFFFFFE))*3]; 
     464                                                        cy=img[y + x + 1]; 
     465                                                        cu=img[y + (x&0xFFFFFFFE)]; 
    466466                                                        val = clip(((cy<<12) + cu*7258           + 2048)>>12); // B 
    467467                                                        break; 

  • trunk/include/platform.h

    r1352 r1499  
    215215long vid_get_bitmap_buffer_width(); 
    216216long vid_get_bitmap_buffer_height(); 
     217 
    217218void *vid_get_viewport_fb(); 
    218219void *vid_get_viewport_fb_d(); 
    219220void *vid_get_viewport_live_fb(); 
     221 
    220222void vid_bitmap_refresh(); 
    221 long vid_get_viewport_height(); 
    222 int vid_get_viewport_width(); 
    223 int vid_get_viewport_buffer_width(); 
    224 int vid_get_viewport_xoffset(); 
    225 int vid_get_viewport_yoffset(); 
    226 int vid_get_viewport_image_offset(); 
    227 int vid_get_viewport_row_offset(); 
    228223void vid_turn_off_updates(); 
    229224void vid_turn_on_updates(); 
     225 
     226// These define the viewport dimensions both physically and in terms of the CHDK co-ordinate system 
     227// CHDK works in a 360x240 screen dimension / co-ordinate system 
     228extern long vid_get_viewport_height();          // Viewport height in CHDK screen pixels  
     229extern int vid_get_viewport_width();            // Viewport width in CHDK screen pixels 
     230extern int vid_get_viewport_xoffset();          // X offset of viewport edge relative to LCD screen (in CHDK screen pixels) 
     231extern int vid_get_viewport_yoffset();          // Y offset of viewport top relative to LCD screen (in CHDK screen pixels) 
     232extern int vid_get_viewport_byte_width();       // Physical width of viewport row in bytes 
     233extern int vid_get_viewport_yscale();           // Y multiplier for cameras with 480 pixel high viewports (CHDK code assumes 240) 
     234extern int vid_get_viewport_image_offset();     // Byte offset from start of viewport memory to first displayed pixel 
     235extern int vid_get_viewport_row_offset();       // Difference between physical width of viewport and displayed width (in bytes) 
     236 
    230237 
    231238// PTP Live View functions 
    … …  
    486493void reverse_bytes_order2(char* from, char* to, int count); 
    487494// convert old version calls to new version (to minimise code changes) 
    488 #define reverse_bytes_order(start, count)       reverse_bytes_order2(start,start,count) 
     495#define reverse_bytes_order(start, count) reverse_bytes_order2(start,start,count) 
    489496void save_ext_for_dng(void); 
    490497void change_ext_to_dng(void); 

  • trunk/platform/g12/lib.c

    r1430 r1499  
    9696long vid_get_bitmap_buffer_height() { return 270; } 
    9797 
    98 int vid_get_viewport_buffer_width() { return 720; }     // G12 - viewport is actually 480 high, CHDK not set up for this so we skip every 2nd row 
     98// Y multiplier for cameras with 480 pixel high viewports (CHDK code assumes 240) 
     99int vid_get_viewport_yscale() { 
     100        return 2;               // G12 viewport is 480 pixels high 
     101} 
    99102 
    100103int vid_get_viewport_width() 
    … …  
    128131        static long vp_h[5] = { 0, 30, 13, 0, 0 }; 
    129132        return vp_h[shooting_get_prop(PROPCASE_ASPECT_RATIO)]; 
    130 } 
    131  
    132 // viewport image offset - used when image size != viewport size (zebra, histogram, motion detect & edge overlay) 
    133 // returns the byte offset into the viewport buffer where the image pixels start (to skip any black borders) 
    134 int vid_get_viewport_image_offset() { 
    135         return (vid_get_viewport_yoffset() * vid_get_viewport_buffer_width() + vid_get_viewport_xoffset()) * 3; 
    136 } 
    137  
    138 // viewport image offset - used when image size != viewport size (zebra, histogram, motion detect & edge overlay) 
    139 // returns the byte offset to skip at the end of a viewport buffer row to get to the next row. 
    140 int vid_get_viewport_row_offset() { 
    141         return (vid_get_viewport_buffer_width() - vid_get_viewport_width()) * 3; 
    142133} 
    143134 

  • trunk/platform/generic/wrappers.c

    r1457 r1499  
    11661166} 
    11671167 
    1168 // same as viewport width for most cameras, override in platform/sub/lib.c as needed 
    1169 int __attribute__((weak)) vid_get_viewport_buffer_width() { 
    1170         return vid_get_viewport_width(); 
     1168// Physical width of viewport row in bytes 
     1169int __attribute__((weak)) vid_get_viewport_byte_width() { 
     1170        return 720 * 6 / 4;     // For most cameras viewport is 720 pixels wide, each group of 4 pixels uses 6 bytes (UYVYYY) 
     1171} 
     1172 
     1173// Y multiplier for cameras with 480 pixel high viewports (CHDK code assumes 240) 
     1174int __attribute__((weak)) vid_get_viewport_yscale() { 
     1175        return 1;               // For most cameras viewport is 240 pixels high 
    11711176} 
    11721177 
    … …  
    11841189// returns the byte offset into the viewport buffer where the image pixels start (to skip any black borders) 
    11851190// see G12 port for sample implementation 
    1186 int __attribute__((weak)) vid_get_viewport_image_offset() { 
    1187         return 0; 
     1191int vid_get_viewport_image_offset() { 
     1192        return (vid_get_viewport_yoffset() * vid_get_viewport_byte_width() * vid_get_viewport_yscale()) + (vid_get_viewport_xoffset() * 3); 
    11881193} 
    11891194 
    … …  
    11911196// returns the byte offset to skip at the end of a viewport buffer row to get to the next row. 
    11921197// see G12 port for sample implementation 
    1193 int __attribute__((weak)) vid_get_viewport_row_offset() { 
    1194         return 0; 
     1198int vid_get_viewport_row_offset() { 
     1199        return (vid_get_viewport_byte_width() * vid_get_viewport_yscale()) - (vid_get_viewport_width() * 3); 
    11951200} 
    11961201 

  • trunk/platform/ixus1000_sd4500/sub/100d/lib.c

    r1385 r1499  
    122122// begin 16:9 support 
    123123 
    124 int vid_get_viewport_buffer_width() { return 480; } 
     124// Physical width of viewport row in bytes 
     125int vid_get_viewport_byte_width() { 
     126        return 960 * 6 / 4;     // IXUS 1000 - wide screen LCD is 960 pixels wide, each group of 4 pixels uses 6 bytes (UYVYYY) 
     127} 
    125128 
    126129int vid_get_viewport_width() 
    … …  
    144147} 
    145148 
    146 int vid_get_viewport_image_offset() { 
    147         return (vid_get_viewport_yoffset() * vid_get_viewport_buffer_width() + vid_get_viewport_xoffset()) * 3; 
    148 } 
    149   
    150  
    151 int vid_get_viewport_row_offset() { 
    152         return (vid_get_viewport_buffer_width() - vid_get_viewport_width()) * 3; 
    153 }  
    154  
    155  
    156   
    157149// end 16:9 support 
    158150 

  • trunk/platform/ixus1000_sd4500/sub/100f/lib.c

    r1385 r1499  
    162162} 
    163163 
     164// begin 16:9 support 
     165 
     166// Physical width of viewport row in bytes 
     167int vid_get_viewport_byte_width() { 
     168        return 960 * 6 / 4;     // IXUS 1000 - wide screen LCD is 960 pixels wide, each group of 4 pixels uses 6 bytes (UYVYYY) 
     169} 
    164170 
    165171int vid_get_viewport_width() 
    166172{ 
    167     //return ((mode_get()&MODE_MASK) == MODE_VIDEO_STD ||(mode_get()&MODE_MASK) == MODE_PLAY)?480:320; 
    168     return 480; // as in sd980 
    169     //return 360;                                               // stays at 360 as IN SD990 
    170 } 
     173    extern int kbd_debug1; 
     174    //kbd_debug1 = mode_get(); 
     175    if (movie_status > 1){return 480;} 
     176    if (shooting_get_prop(PROPCASE_ASPECT_RATIO) == 1 ) // on 16:9 shoot mode its 1.switch to video is 100 
     177                return 480;  
     178    else 
     179       return 360;  
     180} 
     181 
     182int vid_get_viewport_xoffset() 
     183{ 
     184    if (movie_status > 1){return 0;} 
     185        if (shooting_get_prop(PROPCASE_ASPECT_RATIO) == 1  || ((mode_get()&MODE_MASK)== 100 ))   
     186           return 0; 
     187        else 
     188       return 60; 
     189} 
     190 
     191// end 16:9 support 
    171192 
    172193long vid_get_viewport_height() 

  • trunk/platform/ixus200_sd980/sub/101c/lib.c

    r1212 r1499  
    5050long vid_get_viewport_height()       { return 240; } 
    5151 
    52 int vid_get_viewport_buffer_width()  { return 480; } 
     52// Physical width of viewport row in bytes 
     53int vid_get_viewport_byte_width() { 
     54        return 960 * 6 / 4;     // IXUS 200 - wide screen LCD is 960 pixels wide, each group of 4 pixels uses 6 bytes (UYVYYY) 
     55} 
    5356 
    5457int vid_get_viewport_width() 
    … …  
    6669        else 
    6770       return 60; 
    68 } 
    69  
    70 int vid_get_viewport_image_offset() { 
    71         return (vid_get_viewport_yoffset() * vid_get_viewport_buffer_width() + vid_get_viewport_xoffset()) * 3; 
    72 } 
    73  
    74 int vid_get_viewport_row_offset() { 
    75         return (vid_get_viewport_buffer_width() - vid_get_viewport_width()) * 3; 
    7671} 
    7772 

  • trunk/platform/ixus200_sd980/sub/101d/lib.c

    r1376 r1499  
    5050long vid_get_viewport_height()       { return 240; } 
    5151 
    52 int vid_get_viewport_buffer_width()  { return 480; } 
     52// Physical width of viewport row in bytes 
     53int vid_get_viewport_byte_width() { 
     54        return 960 * 6 / 4;     // IXUS 200 - wide screen LCD is 960 pixels wide, each group of 4 pixels uses 6 bytes (UYVYYY) 
     55} 
    5356 
    5457int vid_get_viewport_width() 
    … …  
    6669        else 
    6770       return 60; 
    68 } 
    69  
    70 int vid_get_viewport_image_offset() { 
    71         return (vid_get_viewport_yoffset() * vid_get_viewport_buffer_width() + vid_get_viewport_xoffset()) * 3; 
    72 } 
    73  
    74 int vid_get_viewport_row_offset() { 
    75         return (vid_get_viewport_buffer_width() - vid_get_viewport_width()) * 3; 
    7671} 
    7772 

  • trunk/platform/ixus220_elph300hs/lib.c

    r1448 r1499  
    8686        return vp_h[shooting_get_prop(PROPCASE_ASPECT_RATIO)]; 
    8787} 
    88  
    89 // viewport image offset - used when image size != viewport size (zebra, histogram, motion detect & edge overlay) 
    90 // returns the byte offset into the viewport buffer where the image pixels start (to skip any black borders) 
    91 int vid_get_viewport_image_offset() { 
    92         return (vid_get_viewport_yoffset() * vid_get_viewport_buffer_width() + vid_get_viewport_xoffset()) * 3; 
    93 } 
    94  
    95 // viewport image offset - used when image size != viewport size (zebra, histogram, motion detect & edge overlay) 
    96 // returns the byte offset to skip at the end of a viewport buffer row to get to the next row. 
    97 int vid_get_viewport_row_offset() { 
    98         return (vid_get_viewport_buffer_width() - vid_get_viewport_width()) * 3; 
    99 } 

  • trunk/platform/ixus310_elph500hs/lib.c

    r1430 r1499  
    8585long vid_get_bitmap_buffer_height() { return 270; } 
    8686 
    87 int vid_get_viewport_buffer_width() { return 960; }     // IXUS 310 - wide screen LCD (viewport is actually 480 high, CHDK not set up for this so we skip every 2nd row) 
     87// Physical width of viewport row in bytes 
     88int vid_get_viewport_byte_width() { 
     89        return 960 * 6 / 4;     // IXUS 310 - wide screen LCD is 960 pixels wide, each group of 4 pixels uses 6 bytes (UYVYYY) 
     90} 
     91 
     92// Y multiplier for cameras with 480 pixel high viewports (CHDK code assumes 240) 
     93int vid_get_viewport_yscale() { 
     94        return 2;               // IXUS 310 viewport is 480 pixels high 
     95} 
    8896 
    8997int vid_get_viewport_width() 
    … …  
    104112 
    105113long vid_get_viewport_height(){ return 240; } 
    106  
    107 // viewport image offset - used when image size != viewport size (zebra, histogram, motion detect & edge overlay) 
    108 // returns the byte offset into the viewport buffer where the image pixels start (to skip any black borders) 
    109 int vid_get_viewport_image_offset() { 
    110         return vid_get_viewport_xoffset() * 3; 
    111 } 
    112  
    113 // viewport image offset - used when image size != viewport size (zebra, histogram, motion detect & edge overlay) 
    114 // returns the byte offset to skip at the end of a viewport buffer row to get to the next row. 
    115 int vid_get_viewport_row_offset() { 
    116         return (vid_get_viewport_buffer_width() - vid_get_viewport_width()) * 3; 
    117 } 
    118114 
    119115// Functions for PTP Live View system 

  • trunk/platform/sx220hs/lib.c

    r1285 r1499  
    6666long vid_get_bitmap_buffer_height() { return 270; } 
    6767 
    68 int vid_get_viewport_buffer_width() { return 960; } 
     68// Physical width of viewport row in bytes 
     69int vid_get_viewport_byte_width() { 
     70        return 960 * 6 / 4;     // SX220HS - wide screen LCD is 960 pixels wide, each group of 4 pixels uses 6 bytes (UYVYYY) 
     71} 
    6972 
     73// Y multiplier for cameras with 480 pixel high viewports (CHDK code assumes 240) 
     74int vid_get_viewport_yscale() { 
     75        return 2;               // SX220HS viewport is 480 pixels high 
     76} 
    7077 
    7178 
    … …  
    8693} 
    8794 
    88 long vid_get_viewport_height() 
    89 { 
    90         // viewport height table for each image size 
    91         // 0 = 4:3, 1 = 16:9, 2 = 3:2, 3 = 1:1 
    92         static long vp_h[4] = { 240, 240, 240, 240 }; 
    93         return vp_h[shooting_get_prop(PROPCASE_ASPECT_RATIO)]; 
    94 } 
    95  
    96 int vid_get_viewport_yoffset() 
    97 { 
    98         // viewport height offset table for each image size 
    99         // 0 = 4:3, 1 = 16:9, 2 = 3:2, 3 = 1:1 
    100         static long vp_h[4] = { 0, 0, 0, 0 }; 
    101         return vp_h[shooting_get_prop(PROPCASE_ASPECT_RATIO)]; 
    102 } 
    103  
    104 // viewport image offset - used when image size != viewport size (zebra, histogram, motion detect & edge overlay) 
    105 // returns the byte offset into the viewport buffer where the image pixels start (to skip any black borders) 
    106 int vid_get_viewport_image_offset() { 
    107         return (vid_get_viewport_yoffset() * vid_get_viewport_buffer_width() + vid_get_viewport_xoffset()) * 3; 
    108 } 
    109  
    110 // viewport image offset - used when image size != viewport size (zebra, histogram, motion detect & edge overlay) 
    111 // returns the byte offset to skip at the end of a viewport buffer row to get to the next row. 
    112 int vid_get_viewport_row_offset() { 
    113         return (vid_get_viewport_buffer_width() - vid_get_viewport_width()) * 3; 
    114 } 
     95long vid_get_viewport_height(){ return 240; } 

  • trunk/platform/sx230hs/lib.c

    r1331 r1499  
    6666long vid_get_bitmap_buffer_height() { return 270; } 
    6767 
    68 int vid_get_viewport_buffer_width() { return 960; } 
     68// Physical width of viewport row in bytes 
     69int vid_get_viewport_byte_width() { 
     70        return 960 * 6 / 4;     // SX230HS - wide screen LCD is 960 pixels wide, each group of 4 pixels uses 6 bytes (UYVYYY) 
     71} 
    6972 
     73// Y multiplier for cameras with 480 pixel high viewports (CHDK code assumes 240) 
     74int vid_get_viewport_yscale() { 
     75        return 2;               // SX230HS viewport is 480 pixels high 
     76} 
    7077 
    7178 
    … …  
    8693} 
    8794 
    88 long vid_get_viewport_height() 
    89 { 
    90         // viewport height table for each image size 
    91         // 0 = 4:3, 1 = 16:9, 2 = 3:2, 3 = 1:1 
    92         static long vp_h[4] = { 240, 240, 240, 240 }; 
    93         return vp_h[shooting_get_prop(PROPCASE_ASPECT_RATIO)]; 
    94 } 
    95  
    96 int vid_get_viewport_yoffset() 
    97 { 
    98         // viewport height offset table for each image size 
    99         // 0 = 4:3, 1 = 16:9, 2 = 3:2, 3 = 1:1 
    100         static long vp_h[4] = { 0, 0, 0, 0 }; 
    101         return vp_h[shooting_get_prop(PROPCASE_ASPECT_RATIO)]; 
    102 } 
    103  
    104 // viewport image offset - used when image size != viewport size (zebra, histogram, motion detect & edge overlay) 
    105 // returns the byte offset into the viewport buffer where the image pixels start (to skip any black borders) 
    106 int vid_get_viewport_image_offset() { 
    107         return (vid_get_viewport_yoffset() * vid_get_viewport_buffer_width() + vid_get_viewport_xoffset()) * 3; 
    108 } 
    109  
    110 // viewport image offset - used when image size != viewport size (zebra, histogram, motion detect & edge overlay) 
    111 // returns the byte offset to skip at the end of a viewport buffer row to get to the next row. 
    112 int vid_get_viewport_row_offset() { 
    113         return (vid_get_viewport_buffer_width() - vid_get_viewport_width()) * 3; 
    114 } 
     95long vid_get_viewport_height(){ return 240; } 

  • trunk/platform/sx30/lib.c

    r1430 r1499  
    9292long vid_get_bitmap_buffer_height() { return 270; } 
    9393 
    94 int vid_get_viewport_width() { return 360; } 
    95  
    9694long vid_get_viewport_height() 
    9795{ 
    … …  
    106104                return 30; 
    107105        return 0; 
    108 } 
    109  
    110 // viewport image offset - used when image size != viewport size (zebra, histogram, motion detect & edge overlay) 
    111 // returns the byte offset into the viewport buffer where the image pixels start (to skip any black borders) 
    112 int vid_get_viewport_image_offset() { 
    113         return (vid_get_viewport_yoffset() * vid_get_viewport_buffer_width()) * 3; 
    114106} 
    115107 

  • trunk/platform/sx40hs/lib.c

    r1430 r1499  
    9393long vid_get_bitmap_buffer_height() { return 270; } 
    9494 
    95 int vid_get_viewport_buffer_width() { return 360; } 
    96  
    9795int vid_get_viewport_width() 
    9896{ 
    … …  
    125123        static long vp_h[5] = { 0, 30, 13, 0 }; 
    126124        return vp_h[shooting_get_prop(PROPCASE_ASPECT_RATIO)]; 
    127 } 
    128  
    129 // viewport image offset - used when image size != viewport size (zebra, histogram, motion detect & edge overlay) 
    130 // returns the byte offset into the viewport buffer where the image pixels start (to skip any black borders) 
    131 int vid_get_viewport_image_offset() { 
    132         return (vid_get_viewport_yoffset() * vid_get_viewport_buffer_width() + vid_get_viewport_xoffset()) * 3; 
    133 } 
    134  
    135 // viewport image offset - used when image size != viewport size (zebra, histogram, motion detect & edge overlay) 
    136 // returns the byte offset to skip at the end of a viewport buffer row to get to the next row. 
    137 int vid_get_viewport_row_offset() { 
    138         return (vid_get_viewport_buffer_width() - vid_get_viewport_width()) * 3; 
    139125} 
    140126 
Note: See TracChangeset for help on using the changeset viewer.