Changeset 1770


Ignore:
Timestamp:
03/28/12 08:36:37 (14 months ago)
Author:
philmoz
Message:

Merge CHDK-DE revision 975 into CHDK.

Location:
branches/release-1_0/platform
Files:
42 edited

Legend:

Unmodified
Added
Removed

  • branches/release-1_0/platform/a1000/main.c

    r1639 r1770  
    2828} 
    2929 
    30 static const int fl_tbl[] = {5800, 6420, 7060, 7700, 8340, 9950, 11550, 13160, 14750, 17150, 19570, 22760, 26750, 30750, 34800}; 
    31 #define NUM_FL (sizeof(fl_tbl)/sizeof(fl_tbl[0])) 
    32 #define CF_EFL 60345 
     30// Focus length table in firmware @0xfffe297c 
     31#define NUM_FL      8   // 0 - 7, entries in firmware 
     32#define NUM_DATA    3   // 3 words each entry, first is FL 
     33extern int focus_len_table[NUM_FL*NUM_DATA]; 
     34 
     35// Conversion factor lens FL --> 35mm equiv 
     36// lens      35mm     CF 
     37// ----      ----     -- 
     38// 6.2       35       ( 35/ 6.2) * 62 = 350  (min FL) 
     39// 24.8      140      (140/24.8) * 62 = 350  (max FL) 
     40#define CF_EFL      350 
     41#define CF_EFL_DIV  62 
    3342 
    3443const int zoom_points = NUM_FL; 
    3544 
    3645int get_effective_focal_length(int zp) { 
    37     return (CF_EFL*get_focal_length(zp))/10000; 
     46    return (CF_EFL*get_focal_length(zp))/CF_EFL_DIV; 
    3847} 
    3948 
    4049int get_focal_length(int zp) { 
    41     if (zp<0) return fl_tbl[0]; 
    42     else if (zp>NUM_FL-1) return fl_tbl[NUM_FL-1]; 
    43     else return fl_tbl[zp]; 
     50    if (zp < 0) zp = 0; 
     51    else if (zp >= NUM_FL) zp = NUM_FL-1; 
     52    return focus_len_table[zp*NUM_DATA]; 
    4453} 
    4554 
    4655int get_zoom_x(int zp) { 
    47     if (zp<1) return 10; 
    48     else if (zp>NUM_FL-1) return fl_tbl[NUM_FL-1]*10/fl_tbl[0]; 
    49     else return fl_tbl[zp]*10/fl_tbl[0]; 
     56    return get_focal_length(zp)*10/focus_len_table[0]; 
    5057} 
    5158 

  • branches/release-1_0/platform/a1100/main.c

    r1233 r1770  
    2929} 
    3030 
    31 static const int fl_tbl[] = {6200, 7780, 9410, 11370, 13790, 16770, 20180, 24800}; 
    32 #define NUM_FL (sizeof(fl_tbl)/sizeof(fl_tbl[0])) 
    33 #define CF_EFL 56451   //---corect 
     31// Focus length table in firmware @0xfffe2a8c 
     32#define NUM_FL      8   // 0 - 7, entries in firmware 
     33#define NUM_DATA    3   // 3 words each entry, first is FL 
     34extern int focus_len_table[NUM_FL*NUM_DATA]; 
     35 
     36// Conversion factor lens FL --> 35mm equiv 
     37// lens      35mm     CF 
     38// ----      ----     -- 
     39// 6.2       35       ( 35/ 6.2) * 62 = 350  (min FL) 
     40// 24.8      140      (140/24.8) * 62 = 350  (max FL) 
     41#define CF_EFL      350 
     42#define CF_EFL_DIV  62 
    3443 
    3544const int zoom_points = NUM_FL; 
    3645 
    3746int get_effective_focal_length(int zp) { 
    38     return (CF_EFL*get_focal_length(zp))/10000; 
     47    return (CF_EFL*get_focal_length(zp))/CF_EFL_DIV; 
    3948} 
    4049 
    4150int get_focal_length(int zp) { 
    42     if (zp<0) return fl_tbl[0]; 
    43     else if (zp>NUM_FL-1) return fl_tbl[NUM_FL-1]; 
    44     else return fl_tbl[zp]; 
     51    if (zp < 0) zp = 0; 
     52    else if (zp >= NUM_FL) zp = NUM_FL-1; 
     53    return focus_len_table[zp*NUM_DATA]; 
    4554} 
    4655 
    4756int get_zoom_x(int zp) { 
    48     if (zp<1) return 10; 
    49     else if (zp>NUM_FL-1) return fl_tbl[NUM_FL-1]*10/fl_tbl[0]; 
    50     else return fl_tbl[zp]*10/fl_tbl[0]; 
     57    return get_focal_length(zp)*10/focus_len_table[0]; 
    5158} 
    5259 

  • branches/release-1_0/platform/a2000/main.c

    r847 r1770  
    2929} 
    3030 
    31 static const int fl_tbl[] = {6400, 6800, 7600, 8800, 10500, 12300, 14100, 16100, 18500, 21200, 24000, 27100, 30700, 35100, 38400}; 
    32 #define NUM_FL (sizeof(fl_tbl)/sizeof(fl_tbl[0])) 
     31// Focus length table in firmware @0xfffe297c 
     32#define NUM_FL      15  // 0 - 14, entries in firmware 
     33#define NUM_DATA    3   // 3 words each entry, first is FL 
     34extern int focus_len_table[NUM_FL*NUM_DATA]; 
    3335 
    34 // focal length range is 6.4 - 38.4 mm, 36 - 216 in 35-mm equivalent. 
    35 // So, CF_EFL = 36/6.4 * 1000 = 56250 or 216/38.4 * 1000 = 56250. 
    36 #define CF_EFL 5625 
     36// Conversion factor lens FL --> 35mm equiv 
     37// lens      35mm     CF 
     38// ----      ----     -- 
     39// 6.4       36       ( 36/ 6.4) * 64 = 360  (min FL) 
     40// 38.4      216      (216/38.4) * 64 = 360  (max FL) 
     41#define CF_EFL      360 
     42#define CF_EFL_DIV  64 
    3743 
    3844const int zoom_points = NUM_FL; 
    3945 
    4046int get_effective_focal_length(int zp) { 
    41         return (CF_EFL*get_focal_length(zp))/1000; 
     47    return (CF_EFL*get_focal_length(zp))/CF_EFL_DIV; 
    4248} 
    4349 
    4450int get_focal_length(int zp) { 
    45     if (zp<0) return fl_tbl[0]; 
    46     else if (zp>NUM_FL-1) return fl_tbl[NUM_FL-1]; 
    47     else return fl_tbl[zp]; 
     51    if (zp < 0) zp = 0; 
     52    else if (zp >= NUM_FL) zp = NUM_FL-1; 
     53    return focus_len_table[zp*NUM_DATA]; 
    4854} 
    4955 
    5056int get_zoom_x(int zp) { 
    51     if (zp<1) return 10; 
    52     else if (zp>NUM_FL-1) return fl_tbl[NUM_FL-1]*10/fl_tbl[0]; 
    53     else return fl_tbl[zp]*10/fl_tbl[0]; 
     57    return get_focal_length(zp)*10/focus_len_table[0]; 
    5458} 
    55  
    5659 
    5760long get_vbatt_min() 

  • branches/release-1_0/platform/a3000/main.c

    r1372 r1770  
    2626} 
    2727 
    28 //zoom position is get_parameter_data(87) 
    29 static const struct { 
    30         int zp, fl; 
    31 } fl_tbl[] = { 
    32   {   0,   6200}, 
    33   {   1,   7780}, 
    34   {   2,   9410}, 
    35   {   3,   11370}, 
    36   {   4,   13790}, 
    37   {   5,   16770}, 
    38   {   6,   20180}, 
    39   {   7,   24800}, 
    40 }; 
     28// Focus length table in firmware @0xfffe29b0 
     29#define NUM_FL      8   // 0 - 7, entries in firmware 
     30#define NUM_DATA    3   // 3 words each entry, first is FL 
     31extern int focus_len_table[NUM_FL*NUM_DATA]; 
    4132 
    42 #define NUM_FL (sizeof(fl_tbl)/sizeof(fl_tbl[0])) 
    43 // A3000IS focal lenght range 6.2 - 24.8 mm (35 mm equivalent: 34.8 - 139.4 mm)(1/2.3" (7.7mm, crop 5.62) Type CCD, Scale Factor To 35 mm Equivalent: 4.6) 
    44 // 34.8/6.2*10000=56129 
    45 // 139.4/24.8*10000=56210 
    46  
    47 #define CF_EFL 56200 
     33// Conversion factor lens FL --> 35mm equiv 
     34// lens      35mm     CF 
     35// ----      ----     -- 
     36// 6.2       35       ( 35/ 6.2) * 62 = 350  (min FL) 
     37// 24.8      140      (140/24.8) * 62 = 350  (max FL) 
     38#define CF_EFL      350 
     39#define CF_EFL_DIV  62 
    4840 
    4941const int zoom_points = NUM_FL; 
    5042 
    5143int get_effective_focal_length(int zp) { 
    52     return (CF_EFL*get_focal_length(zp))/10000; 
     44    return (CF_EFL*get_focal_length(zp))/CF_EFL_DIV; 
    5345} 
    5446 
    5547int get_focal_length(int zp) { 
    56         int i; 
    57  
    58         if (zp<fl_tbl[0].zp) 
    59                 return fl_tbl[0].fl; 
    60         else if (zp>fl_tbl[NUM_FL-1].zp) 
    61                 return fl_tbl[NUM_FL-1].fl; 
    62         else  
    63                 for (i=1; i<NUM_FL; ++i) { 
    64                         if (zp==fl_tbl[i-1].zp)  
    65                                 return fl_tbl[i-1].fl; 
    66                         else if (zp==fl_tbl[i].zp)  
    67                                 return fl_tbl[i].fl; 
    68                         else if (zp<fl_tbl[i].zp) 
    69                                 return fl_tbl[i-1].fl+(zp-fl_tbl[i-1].zp)*(fl_tbl[i].fl-fl_tbl[i-1].fl)/(fl_tbl[i].zp-fl_tbl[i-1].zp); 
    70                 } 
    71         return fl_tbl[NUM_FL-1].fl; 
     48    if (zp < 0) zp = 0; 
     49    else if (zp >= NUM_FL) zp = NUM_FL-1; 
     50    return focus_len_table[zp*NUM_DATA]; 
    7251} 
    7352 
    7453int get_zoom_x(int zp) { 
    75         return get_focal_length(zp)*10/fl_tbl[0].fl; 
     54    return get_focal_length(zp)*10/focus_len_table[0]; 
    7655} 
    77  
    7856 
    7957long get_vbatt_min() 

  • branches/release-1_0/platform/a3300/main.c

    r1617 r1770  
    2828} 
    2929 
     30// Focus length table in firmware @0xfffe2f88 
     31#define NUM_FL      12  // 0 - 11, entries in firmware 
     32#define NUM_DATA    3   // 3 words each entry, first is FL 
     33extern int focus_len_table[NUM_FL*NUM_DATA]; 
    3034 
    31 #define NUM_FL 12 
    32 extern int focus_len_table[NUM_FL*3]; 
    33 //a3300is 
    34 // Focal length range is 5.0 - 25.0 mm, 28 - 140 in 35-mm equivalent. 
    35 // So, CF_EFL = 28/5.0*10000=56000 or 140/25*10000=56000 
    36 // divide by 10 to avoid overflow in get_effective_focal_length() 
    37 #define CF_EFL  5600 
     35// Conversion factor lens FL --> 35mm equiv 
     36// lens      35mm     CF 
     37// ----      ----     -- 
     38// 5.0       28       ( 28/ 5.0) * 50 = 280  (min FL) 
     39// 25.0      140      (140/25.0) * 50 = 280  (max FL) 
     40#define CF_EFL      280 
     41#define CF_EFL_DIV  50 
     42 
    3843const int zoom_points = NUM_FL; 
    3944 
    40  
    4145int get_effective_focal_length(int zp) { 
    42         return (CF_EFL*get_focal_length(zp))/10000; 
     46    return (CF_EFL*get_focal_length(zp))/CF_EFL_DIV; 
    4347} 
    4448 
    45  
    4649int get_focal_length(int zp) { 
    47          
    48         if (zp < 0) zp = 0; 
    49         else if (zp >= NUM_FL) zp = NUM_FL-1; 
    50         return focus_len_table[zp*3]; 
    51  
     50    if (zp < 0) zp = 0; 
     51    else if (zp >= NUM_FL) zp = NUM_FL-1; 
     52    return focus_len_table[zp*NUM_DATA]; 
    5253} 
    5354 
    54  
    5555int get_zoom_x(int zp) { 
    56         return get_focal_length(zp)*10/focus_len_table[0]; 
    57  
     56    return get_focal_length(zp)*10/focus_len_table[0]; 
    5857} 
    59  
    60  
    6158 
    6259long get_vbatt_min() 

  • branches/release-1_0/platform/a480/main.c

    r884 r1770  
    2828} 
    2929 
    30 static const int fl_tbl[] = {6600, 8060, 9840, 12050, 14800, 17550, 21600}; 
    31 #define NUM_FL (sizeof(fl_tbl)/sizeof(fl_tbl[0])) 
    32 #define CF_EFL 56481L 
     30// Focus length table in firmware @0xfffe297c 
     31#define NUM_FL      7   // 0 - 6, entries in firmware 
     32#define NUM_DATA    3   // 3 words each entry, first is FL 
     33extern int focus_len_table[NUM_FL*NUM_DATA]; 
     34 
     35// Conversion factor lens FL --> 35mm equiv 
     36// lens      35mm     CF 
     37// ----      ----     -- 
     38// 6.6       37       ( 37/ 6.6) * 66 = 370  (min FL) 
     39// 21.6      122      (122/21.6) * 66 = 372,8  (max FL) 
     40#define CF_EFL      370 
     41#define CF_EFL_DIV  66 
    3342 
    3443const int zoom_points = NUM_FL; 
    3544 
    3645int get_effective_focal_length(int zp) { 
    37     return (CF_EFL*get_focal_length(zp))/10000; 
     46    return (CF_EFL*get_focal_length(zp))/CF_EFL_DIV; 
    3847} 
    3948 
    4049int get_focal_length(int zp) { 
    41     if (zp<0) return fl_tbl[0]; 
    42     else if (zp>NUM_FL-1) return fl_tbl[NUM_FL-1]; 
    43     else return fl_tbl[zp]; 
     50    if (zp < 0) zp = 0; 
     51    else if (zp >= NUM_FL) zp = NUM_FL-1; 
     52    return focus_len_table[zp*NUM_DATA]; 
    4453} 
    4554 
    4655int get_zoom_x(int zp) { 
    47     if (zp<1) return 10; 
    48     else if (zp>NUM_FL-1) return fl_tbl[NUM_FL-1]*10/fl_tbl[0]; 
    49     else return fl_tbl[zp]*10/fl_tbl[0]; 
     56    return get_focal_length(zp)*10/focus_len_table[0]; 
    5057} 
    51  
    5258 
    5359long get_vbatt_min() 

  • branches/release-1_0/platform/a490/main.c

    r1205 r1770  
    2828} 
    2929 
    30 // TODO: Check focal length table 
    31 static const int fl_tbl[] = {6600, 8060, 9840, 12050, 14800, 17550, 21600}; 
    32 #define NUM_FL (sizeof(fl_tbl)/sizeof(fl_tbl[0])) 
    33 #define CF_EFL 56481L 
     30// Focus length table in firmware @0xfffe2990 
     31#define NUM_FL      7   // 0 - 6, entries in firmware 
     32#define NUM_DATA    3   // 3 words each entry, first is FL 
     33extern int focus_len_table[NUM_FL*NUM_DATA]; 
     34 
     35// Conversion factor lens FL --> 35mm equiv 
     36// lens      35mm     CF 
     37// ----      ----     -- 
     38// 6.6       37       ( 37/ 6.6) * 66 = 370  (min FL) 
     39// 21.6      122      (122/21.6) * 66 = 372.8  (max FL) 
     40#define CF_EFL      370 
     41#define CF_EFL_DIV  66 
    3442 
    3543const int zoom_points = NUM_FL; 
    3644 
    3745int get_effective_focal_length(int zp) { 
    38     return (CF_EFL*get_focal_length(zp))/10000; 
     46    return (CF_EFL*get_focal_length(zp))/CF_EFL_DIV; 
    3947} 
    4048 
    4149int get_focal_length(int zp) { 
    42     if (zp<0) return fl_tbl[0]; 
    43     else if (zp>NUM_FL-1) return fl_tbl[NUM_FL-1]; 
    44     else return fl_tbl[zp]; 
     50    if (zp < 0) zp = 0; 
     51    else if (zp >= NUM_FL) zp = NUM_FL-1; 
     52    return focus_len_table[zp*NUM_DATA]; 
    4553} 
    4654 
    4755int get_zoom_x(int zp) { 
    48     if (zp<1) return 10; 
    49     else if (zp>NUM_FL-1) return fl_tbl[NUM_FL-1]*10/fl_tbl[0]; 
    50     else return fl_tbl[zp]*10/fl_tbl[0]; 
     56    return get_focal_length(zp)*10/focus_len_table[0]; 
    5157} 
    5258 

  • branches/release-1_0/platform/a495/main.c

    r1376 r1770  
    2828} 
    2929 
    30 // TODO: Check focal length table 
    31 static const int fl_tbl[] = {6600, 8060, 9840, 12050, 14800, 17550, 21600}; 
    32 #define NUM_FL (sizeof(fl_tbl)/sizeof(fl_tbl[0])) 
    33 #define CF_EFL 56481L 
     30// Focus length table in firmware @0xfffe2990 
     31#define NUM_FL      7   // 0 - 6, entries in firmware 
     32#define NUM_DATA    3   // 3 words each entry, first is FL 
     33extern int focus_len_table[NUM_FL*NUM_DATA]; 
     34 
     35// Conversion factor lens FL --> 35mm equiv 
     36// lens      35mm     CF 
     37// ----      ----     -- 
     38// 6.6       37       ( 37/ 6.6) * 66 = 370  (min FL) 
     39// 21.6      122      (122/21.6) * 66 = 372,8  (max FL) 
     40#define CF_EFL      370 
     41#define CF_EFL_DIV  66 
    3442 
    3543const int zoom_points = NUM_FL; 
    3644 
    3745int get_effective_focal_length(int zp) { 
    38     return (CF_EFL*get_focal_length(zp))/10000; 
     46    return (CF_EFL*get_focal_length(zp))/CF_EFL_DIV; 
    3947} 
    4048 
    4149int get_focal_length(int zp) { 
    42     if (zp<0) return fl_tbl[0]; 
    43     else if (zp>NUM_FL-1) return fl_tbl[NUM_FL-1]; 
    44     else return fl_tbl[zp]; 
     50    if (zp < 0) zp = 0; 
     51    else if (zp >= NUM_FL) zp = NUM_FL-1; 
     52    return focus_len_table[zp*NUM_DATA]; 
    4553} 
    4654 
    4755int get_zoom_x(int zp) { 
    48     if (zp<1) return 10; 
    49     else if (zp>NUM_FL-1) return fl_tbl[NUM_FL-1]*10/fl_tbl[0]; 
    50     else return fl_tbl[zp]*10/fl_tbl[0]; 
     56    return get_focal_length(zp)*10/focus_len_table[0]; 
    5157} 
    5258 

  • branches/release-1_0/platform/a580/main.c

    r1308 r1770  
    2929} 
    3030 
     31// Focus length table in firmware @0xfffe297c 
     32#define NUM_FL      8   // 0 - 7, entries in firmware 
     33#define NUM_DATA    3   // 3 words each entry, first is FL 
     34extern int focus_len_table[NUM_FL*NUM_DATA]; 
    3135 
    32 static const int fl_tbl[] = {5800, 6700, 8000, 10000, 12600, 15800, 19300, 23200}; 
    33 #define NUM_FL (sizeof(fl_tbl)/sizeof(fl_tbl[0])) 
    34 #define CF_EFL 60345 //OK 
     36// Conversion factor lens FL --> 35mm equiv 
     37// lens      35mm     CF 
     38// ----      ----     -- 
     39// 5.8       35       ( 35/ 5.8) * 58 = 350  (min FL) 
     40// 23.2      140      (140/23.2) * 58 = 350  (max FL) 
     41#define CF_EFL      350 
     42#define CF_EFL_DIV  58 
    3543 
    3644const int zoom_points = NUM_FL; 
    3745 
    3846int get_effective_focal_length(int zp) { 
    39     return (CF_EFL*get_focal_length(zp))/10000; 
     47    return (CF_EFL*get_focal_length(zp))/CF_EFL_DIV; 
    4048} 
    4149 
    4250int get_focal_length(int zp) { 
    43     if (zp<0) return fl_tbl[0]; 
    44     else if (zp>NUM_FL-1) return fl_tbl[NUM_FL-1]; 
    45     else return fl_tbl[zp]; 
     51    if (zp < 0) zp = 0; 
     52    else if (zp >= NUM_FL) zp = NUM_FL-1; 
     53    return focus_len_table[zp*NUM_DATA]; 
    4654} 
    4755 
    4856int get_zoom_x(int zp) { 
    49     if (zp<1) return 10; 
    50     else if (zp>NUM_FL-1) return fl_tbl[NUM_FL-1]*10/fl_tbl[0]; 
    51     else return fl_tbl[zp]*10/fl_tbl[0]; 
     57    return get_focal_length(zp)*10/focus_len_table[0]; 
    5258} 
    5359 

  • branches/release-1_0/platform/a590/main.c

    r847 r1770  
    3030} 
    3131 
    32 static const int fl_tbl[] = {5800, 6600, 7900, 9900, 12700, 16000, 19600, 23200}; 
    33 #define NUM_FL (sizeof(fl_tbl)/sizeof(fl_tbl[0])) 
    34 #define CF_EFL 60345 
     32// Focus length table in firmware @0xfffe29ac 
     33#define NUM_FL      8   // 0 - 7, entries in firmware 
     34#define NUM_DATA    3   // 3 words each entry, first is FL 
     35extern int focus_len_table[NUM_FL*NUM_DATA]; 
     36 
     37// Conversion factor lens FL --> 35mm equiv 
     38// lens      35mm     CF 
     39// ----      ----     -- 
     40// 5.8       35       ( 35/ 5.8) * 58 = 350  (min FL) 
     41// 23.2      140      (140/23.2) * 58 = 350  (max FL) 
     42#define CF_EFL      350 
     43#define CF_EFL_DIV  58 
    3544 
    3645const int zoom_points = NUM_FL; 
    3746 
    3847int get_effective_focal_length(int zp) { 
    39     return (CF_EFL*get_focal_length(zp))/10000; 
     48    return (CF_EFL*get_focal_length(zp))/CF_EFL_DIV; 
    4049} 
    4150 
    4251int get_focal_length(int zp) { 
    43     if (zp<0) return fl_tbl[0]; 
    44     else if (zp>NUM_FL-1) return fl_tbl[NUM_FL-1]; 
    45     else return fl_tbl[zp]; 
     52    if (zp < 0) zp = 0; 
     53    else if (zp >= NUM_FL) zp = NUM_FL-1; 
     54    return focus_len_table[zp*NUM_DATA]; 
    4655} 
    4756 
    4857int get_zoom_x(int zp) { 
    49     if (zp<1) return 10; 
    50     else if (zp>NUM_FL-1) return fl_tbl[NUM_FL-1]*10/fl_tbl[0]; 
    51     else return fl_tbl[zp]*10/fl_tbl[0]; 
     58    return get_focal_length(zp)*10/focus_len_table[0]; 
    5259} 
    5360 

  • branches/release-1_0/platform/a720/main.c

    r847 r1770  
    2929} 
    3030 
     31// Focus length table in firmware @0xfffe299c 
     32#define NUM_FL      15  // 0 - 14, entries in firmware 
     33#define NUM_DATA    3   // 3 words each entry, first is FL 
     34extern int focus_len_table[NUM_FL*NUM_DATA]; 
    3135 
    32 static const int fl_tbl[] = {5800, 6420, 7060, 7700, 8340, 9950, 11550, 13160, 14750, 17150, 19570, 22760, 26750, 30750, 34800}; 
    33 #define NUM_FL (sizeof(fl_tbl)/sizeof(fl_tbl[0])) 
    34 #define CF_EFL 60345 
     36// Conversion factor lens FL --> 35mm equiv 
     37// lens      35mm     CF 
     38// ----      ----     -- 
     39// 5.8       35       ( 35/ 5.8) * 58 = 350  (min FL) 
     40// 34.8      210      (210/34.8) * 58 = 350  (max FL) 
     41#define CF_EFL      350 
     42#define CF_EFL_DIV  58 
    3543 
    3644const int zoom_points = NUM_FL; 
    3745 
    3846int get_effective_focal_length(int zp) { 
    39     return (CF_EFL*get_focal_length(zp))/10000; 
     47    return (CF_EFL*get_focal_length(zp))/CF_EFL_DIV; 
    4048} 
    4149 
    4250int get_focal_length(int zp) { 
    43     if (zp<0) return fl_tbl[0]; 
    44     else if (zp>NUM_FL-1) return fl_tbl[NUM_FL-1]; 
    45     else return fl_tbl[zp]; 
     51    if (zp < 0) zp = 0; 
     52    else if (zp >= NUM_FL) zp = NUM_FL-1; 
     53    return focus_len_table[zp*NUM_DATA]; 
    4654} 
    4755 
    4856int get_zoom_x(int zp) { 
    49     if (zp<1) return 10; 
    50     else if (zp>NUM_FL-1) return fl_tbl[NUM_FL-1]*10/fl_tbl[0]; 
    51     else return fl_tbl[zp]*10/fl_tbl[0]; 
     57    return get_focal_length(zp)*10/focus_len_table[0]; 
    5258} 
    5359 

  • branches/release-1_0/platform/a800/main.c

    r1726 r1770  
    2828} 
    2929 
    30 // TODO: Check focal length table 
    31 static const int fl_tbl[] = {6600, 8060, 9840, 12050, 14800, 21600}; 
    32 #define NUM_FL (sizeof(fl_tbl)/sizeof(fl_tbl[0])) 
    33 #define CF_EFL 56481L 
     30// Focus length table in firmware @0xfffe2ee8 
     31#define NUM_FL      7   // 0 - 6, entries in firmware 
     32#define NUM_DATA    3   // 3 words each entry, first is FL 
     33extern int focus_len_table[NUM_FL*NUM_DATA]; 
     34 
     35// Conversion factor lens FL --> 35mm equiv 
     36// lens      35mm     CF 
     37// ----      ----     -- 
     38// 6.6       37       ( 37/ 6.6) * 66 = 370  (min FL) 
     39// 21.6      122      (122/21.6) * 66 = 372.7  (max FL) 
     40#define CF_EFL      370 
     41#define CF_EFL_DIV  66 
    3442 
    3543const int zoom_points = NUM_FL; 
    3644 
    3745int get_effective_focal_length(int zp) { 
    38     return (CF_EFL*get_focal_length(zp))/10000; 
     46    return (CF_EFL*get_focal_length(zp))/CF_EFL_DIV; 
    3947} 
    4048 
    4149int get_focal_length(int zp) { 
    42     if (zp<0) return fl_tbl[0]; 
    43     else if (zp>NUM_FL-1) return fl_tbl[NUM_FL-1]; 
    44     else return fl_tbl[zp]; 
     50    if (zp < 0) zp = 0; 
     51    else if (zp >= NUM_FL) zp = NUM_FL-1; 
     52    return focus_len_table[zp*NUM_DATA]; 
    4553} 
    4654 
    4755int get_zoom_x(int zp) { 
    48     if (zp<1) return 10; 
    49     else if (zp>NUM_FL-1) return fl_tbl[NUM_FL-1]*10/fl_tbl[0]; 
    50     else return fl_tbl[zp]*10/fl_tbl[0]; 
     56    return get_focal_length(zp)*10/focus_len_table[0]; 
    5157} 
    5258 

  • branches/release-1_0/platform/d10/main.c

    r897 r1770  
    4343CF_EFL ~54800-56000 
    4444*/ 
    45 static const int fl_tbl[] = {6200, 7200, 8300, 9700, 11600, 14300, 18600}; 
    46 #define NUM_FL (sizeof(fl_tbl)/sizeof(fl_tbl[0])) 
    47 #define CF_EFL 55400 
     45 
     46// Focus length table in firmware @0xfffe2a8c 
     47#define NUM_FL      7   // 0 - 6, entries in firmware 
     48#define NUM_DATA    3   // 3 words each entry, first is FL 
     49extern int focus_len_table[NUM_FL*NUM_DATA]; 
     50 
     51// Conversion factor lens FL --> 35mm equiv 
     52// lens      35mm     CF 
     53// ----      ----     -- 
     54// 6.2       35       ( 35/ 6.2) * 62 = 350  (min FL) 
     55// 18.6      105      (105/18.6) * 62 = 350  (max FL) 
     56#define CF_EFL      350 
     57#define CF_EFL_DIV  62 
    4858 
    4959const int zoom_points = NUM_FL; 
    5060 
    5161int get_effective_focal_length(int zp) { 
    52     return (CF_EFL*get_focal_length(zp))/10000; 
     62    return (CF_EFL*get_focal_length(zp))/CF_EFL_DIV; 
    5363} 
    5464 
    5565int get_focal_length(int zp) { 
    56     if (zp<0) return fl_tbl[0]; 
    57     else if (zp>NUM_FL-1) return fl_tbl[NUM_FL-1]; 
    58     else return fl_tbl[zp]; 
     66    if (zp < 0) zp = 0; 
     67    else if (zp >= NUM_FL) zp = NUM_FL-1; 
     68    return focus_len_table[zp*NUM_DATA]; 
    5969} 
    6070 
    6171int get_zoom_x(int zp) { 
    62     if (zp<1) return 10; 
    63     else if (zp>NUM_FL-1) return fl_tbl[NUM_FL-1]*10/fl_tbl[0]; 
    64     else return fl_tbl[zp]*10/fl_tbl[0]; 
     72    return get_focal_length(zp)*10/focus_len_table[0]; 
    6573} 
    66  
    6774 
    6875// uses NB-6L, similar specs to NB-5L, copied from sd990 below  

  • branches/release-1_0/platform/g10/main.c

    r1329 r1770  
    2828} 
    2929 
    30 // G10 focus length table in firmware @ FFFE2A8C for 1.02a, 1.03b & 1.04a 
    31 // Note: same lens & table as G12 
    32  
    33 #define NUM_FL 14               // 0 - 13, entries in firmware (3 words each entry, first is FL) 
    34 extern int focus_len_table[NUM_FL*3]; 
     30// Focus length table in firmware @0xfffe2a8c 
     31#define NUM_FL      14  // 0 - 13, entries in firmware 
     32#define NUM_DATA    3   // 3 words each entry, first is FL 
     33extern int focus_len_table[NUM_FL*NUM_DATA]; 
    3534 
    3635// Conversion factor lens FL --> 35mm equiv 
    3736// lens      35mm     CF 
    3837// ----      ----     -- 
    39 // 6.1       28       (28/6.1) * 61 = 280  (min FL) 
     38// 6.1       28       ( 28/ 6.1) * 61 = 280  (min FL) 
    4039// 30.5      140      (140/30.5) * 61 = 280  (max FL) 
    41  
    42 #define CF_EFL 280 
    43 #define CF_EFL_DIV 61 
     40#define CF_EFL      280 
     41#define CF_EFL_DIV  61 
    4442 
    4543const int zoom_points = NUM_FL; 
    4644 
    4745int get_effective_focal_length(int zp) { 
    48         return (CF_EFL*get_focal_length(zp))/CF_EFL_DIV; 
     46    return (CF_EFL*get_focal_length(zp))/CF_EFL_DIV; 
    4947} 
    5048 
    5149int get_focal_length(int zp) { 
    52         if (zp < 0) zp = 0; 
    53         else if (zp >= NUM_FL) zp = NUM_FL-1; 
    54         return focus_len_table[zp*3]; 
     50    if (zp < 0) zp = 0; 
     51    else if (zp >= NUM_FL) zp = NUM_FL-1; 
     52    return focus_len_table[zp*NUM_DATA]; 
    5553} 
    5654 
    5755int get_zoom_x(int zp) { 
    58         return get_focal_length(zp)*10/focus_len_table[0]; 
     56    return get_focal_length(zp)*10/focus_len_table[0]; 
    5957} 
    6058 

  • branches/release-1_0/platform/g11/main.c

    r1637 r1770  
    2626} 
    2727 
    28 //zoom position is get_parameter_data(87) 
    29 static const struct { 
    30         int zp, fl; 
    31 } fl_tbl[] = { 
    32   {   0,   6100}, 
    33   {   1,   6800}, 
    34   {   2,   7400}, 
    35   {   3,   8100}, 
    36   {   4,   8900}, 
    37   {   5,   9800}, 
    38   {   6,   10800}, 
    39   {   7,   12100}, 
    40   {   8,   13800}, 
    41   {   9,   15700}, 
    42   {  10,   18100}, 
    43   {  11,   21500}, 
    44   {  12,   25000}, 
    45   {  13,   30500}, 
    46 }; 
     28// Focus length table in firmware @0xfffe2a8c 
     29#define NUM_FL      14  // 0 - 13, entries in firmware 
     30#define NUM_DATA    3   // 3 words each entry, first is FL 
     31extern int focus_len_table[NUM_FL*NUM_DATA]; 
    4732 
    48 #define NUM_FL (sizeof(fl_tbl)/sizeof(fl_tbl[0])) 
    49 // G11 focal lenght range 6.1 - 30.5 mm (35 mm equivalent: 27.8 - 139.1 mm)(1/1.7" Type CCD, Scale Factor To 35 mm Equivalent: 4.6) 
    50 // 27,8/6,1*10000=45574 
    51 // 139,1/30,5*10000=45607 
    52 #define CF_EFL 45574 
     33// Conversion factor lens FL --> 35mm equiv 
     34// lens      35mm     CF 
     35// ----      ----     -- 
     36// 6.1       28       ( 28/ 6.1) * 61 = 280  (min FL) 
     37// 30.5      140      (140/30.5) * 61 = 280  (max FL) 
     38#define CF_EFL      280 
     39#define CF_EFL_DIV  61 
    5340 
    5441const int zoom_points = NUM_FL; 
    5542 
    5643int get_effective_focal_length(int zp) { 
    57     return (CF_EFL*get_focal_length(zp))/10000; 
     44    return (CF_EFL*get_focal_length(zp))/CF_EFL_DIV; 
    5845} 
    5946 
    6047int get_focal_length(int zp) { 
    61         int i; 
    62  
    63         if (zp<fl_tbl[0].zp) 
    64                 return fl_tbl[0].fl; 
    65         else if (zp>fl_tbl[NUM_FL-1].zp) 
    66                 return fl_tbl[NUM_FL-1].fl; 
    67         else  
    68                 for (i=1; i<NUM_FL; ++i) { 
    69                         if (zp==fl_tbl[i-1].zp)  
    70                                 return fl_tbl[i-1].fl; 
    71                         else if (zp==fl_tbl[i].zp)  
    72                                 return fl_tbl[i].fl; 
    73                         else if (zp<fl_tbl[i].zp) 
    74                                 return fl_tbl[i-1].fl+(zp-fl_tbl[i-1].zp)*(fl_tbl[i].fl-fl_tbl[i-1].fl)/(fl_tbl[i].zp-fl_tbl[i-1].zp); 
    75                 } 
    76         return fl_tbl[NUM_FL-1].fl; 
     48    if (zp < 0) zp = 0; 
     49    else if (zp >= NUM_FL) zp = NUM_FL-1; 
     50    return focus_len_table[zp*NUM_DATA]; 
    7751} 
    7852 
    7953int get_zoom_x(int zp) { 
    80         return get_focal_length(zp)*10/fl_tbl[0].fl; 
     54    return get_focal_length(zp)*10/focus_len_table[0]; 
    8155} 
    82  
    8356 
    8457long get_vbatt_min() 

  • branches/release-1_0/platform/g12/main.c

    r1564 r1770  
    3636} 
    3737 
    38 // Focus length table in firmware @ FFFE2A80 
    39 #define NUM_FL 14               // 0 - 13, entries in firmware (3 words each entry, first is FL) 
    40 extern int focus_len_table[NUM_FL*3]; 
     38// Focus length table in firmware @0xfffe2a80 
     39#define NUM_FL      14  // 0 - 13, entries in firmware 
     40#define NUM_DATA    3   // 3 words each entry, first is FL 
     41extern int focus_len_table[NUM_FL*NUM_DATA]; 
    4142 
    4243// Conversion factor lens FL --> 35mm equiv 
    4344// lens      35mm     CF 
    4445// ----      ----     -- 
    45 // 6.1       28       (28/6.1) * 61 = 280  (min FL) 
     46// 6.1       28       ( 28/ 6.1) * 61 = 280  (min FL) 
    4647// 30.5      140      (140/30.5) * 61 = 280  (max FL) 
    47 #define CF_EFL 280 
    48 #define CF_EFL_DIV 61 
     48#define CF_EFL      280 
     49#define CF_EFL_DIV  61 
    4950 
    50 const int zoom_points = NUM_FL;  // OK 
     51const int zoom_points = NUM_FL; 
    5152 
    5253int get_effective_focal_length(int zp) { 
    53         return (CF_EFL*get_focal_length(zp))/CF_EFL_DIV; 
     54    return (CF_EFL*get_focal_length(zp))/CF_EFL_DIV; 
    5455} 
    5556 
    5657int get_focal_length(int zp) { 
    57         if (zp < 0) zp = 0; 
    58         else if (zp >= NUM_FL) zp = NUM_FL-1; 
    59         return focus_len_table[zp*3]; 
     58    if (zp < 0) zp = 0; 
     59    else if (zp >= NUM_FL) zp = NUM_FL-1; 
     60    return focus_len_table[zp*NUM_DATA]; 
    6061} 
    6162 
    6263int get_zoom_x(int zp) { 
    63         return get_focal_length(zp)*10/focus_len_table[0]; 
     64    return get_focal_length(zp)*10/focus_len_table[0]; 
    6465} 
    6566 

  • branches/release-1_0/platform/ixus1000_sd4500/main.c

    r1385 r1770  
    3131} 
    3232 
     33// Focus length table in firmware @0xfffe9eac 
     34#define NUM_FL      101 // 0 - 100, entries in firmware 
     35#define NUM_DATA    3   // 3 words each entry, first is FL 
     36extern int focus_len_table[NUM_FL*NUM_DATA]; 
    3337 
    34 //zoom position is get_parameter_data(87) 
     38// Conversion factor lens FL --> 35mm equiv 
     39// lens      35mm     CF 
     40// ----      ----     -- 
     41// 6.3       36       ( 36/ 6.3) * 63 = 360  (min FL) 
     42// 63.0      360      (360/63.0) * 63 = 360  (max FL) 
     43#define CF_EFL      360 
     44#define CF_EFL_DIV  63 
    3545 
    36 // Ixus 1000 576 =1 
    37 static const struct { 
    38         int zp, fl; 
    39 } fl_tbl[] = { 
    40   {   0,   6300}, 
    41   {   5,  5*576+6300}, 
    42   {   10, 10*576+6300}, 
    43   {  20,  20*576+6300}, 
    44   {  30,  30*576+6300}, 
    45   {  40,  40*576+6300}, 
    46   {  50,  50*576+6300}, 
    47   {  60,  60*576+6300}, 
    48   {  70,  70*576+6300}, 
    49   {  80,  80*576+6300}, 
    50   {  90,  90*576+6300}, 
    51   { 100,  63000}, 
    52 }; 
    53 #define NUM_FL (sizeof(fl_tbl)/sizeof(fl_tbl[0])) 
    54  
    55 // Focal length range is 6.3 - 63,0 mm, 36.0 - 360 in 35-mm equivalent. for Ixus 1000 HS 
    56  
    57 // Focal length range is 6.0 - 70,0 mm, 27.3 - 392 in 35-mm equivalent. for Sx210 
    58 // So, CF_EFL = 27.3/5.0*10000=54600 or392/70*10000=56000 
    59 // diff = 54600 - 54566.6 = 1400, split it 1400 / 2 = 700 
    60 // add to base 56000 + 700 = 56700 
    61 // divide by 10 to avoid overflow in get_effective_focal_length() 
    62 #define CF_EFL  5714 
    63 const int zoom_points = 100; 
     46const int zoom_points = NUM_FL; 
    6447 
    6548int get_effective_focal_length(int zp) { 
    66         return (CF_EFL*get_focal_length(zp))/1000; 
     49    return (CF_EFL*get_focal_length(zp))/CF_EFL_DIV; 
    6750} 
    6851 
    6952int get_focal_length(int zp) { 
    70         int i; 
    71  
    72         if (zp<fl_tbl[0].zp) 
    73                 return fl_tbl[0].fl; 
    74         else if (zp>fl_tbl[NUM_FL-1].zp) 
    75                 return fl_tbl[NUM_FL-1].fl; 
    76         else 
    77                 for (i=1; i<NUM_FL; ++i) { 
    78                         if (zp==fl_tbl[i-1].zp) 
    79                                 return fl_tbl[i-1].fl; 
    80                         else if (zp==fl_tbl[i].zp) 
    81                                 return fl_tbl[i].fl; 
    82                         else if (zp<fl_tbl[i].zp) 
    83                                 return fl_tbl[i-1].fl+(zp-fl_tbl[i-1].zp)*(fl_tbl[i].fl-fl_tbl[i-1].fl)/(fl_tbl[i].zp-fl_tbl[i-1].zp); 
    84                 } 
    85         return fl_tbl[NUM_FL-1].fl; 
     53    if (zp < 0) zp = 0; 
     54    else if (zp >= NUM_FL) zp = NUM_FL-1; 
     55    return focus_len_table[zp*NUM_DATA]; 
    8656} 
    8757 
    8858int get_zoom_x(int zp) { 
    89         return get_focal_length(zp)*10/fl_tbl[0].fl; 
     59    return get_focal_length(zp)*10/focus_len_table[0]; 
    9060} 
    91  
    9261 
    9362long get_vbatt_min() 

  • branches/release-1_0/platform/ixus100_sd780/main.c

    r1712 r1770  
    6666#define MODESCNT (sizeof(modemap)/sizeof(modemap[0])) 
    6767 
    68 //SD780 is [f/3.2 is 6mm] [f/3.5 7mm] [f/4.5 11mm] [f/5   15mm] [f/5.8 18mm] 
    69 //SD780 is 5.9-17.9mm f/3.2-5.8 (35mm film equivalent: 33-100mm) 
    70 static const int fl_tbl[] = {5900,7170,8740,10550,12490,14780,17900}; 
    71 #define NUM_FL (sizeof(fl_tbl)/sizeof(fl_tbl[0])) 
    72 #define CF_EFL 55932 
     68// Focus length table in firmware @0xfffe2a8c 
     69#define NUM_FL      7   // 0 - 6, entries in firmware 
     70#define NUM_DATA    3   // 3 words each entry, first is FL 
     71extern int focus_len_table[NUM_FL*NUM_DATA]; 
     72 
     73// Conversion factor lens FL --> 35mm equiv 
     74// lens      35mm     CF 
     75// ----      ----     -- 
     76// 5.9       33       ( 33/ 5.9) * 59 = 330  (min FL) 
     77// 17.9      100      (100/17.9) * 59 = 329.6  (max FL) 
     78#define CF_EFL      330 
     79#define CF_EFL_DIV  59 
    7380 
    7481const int zoom_points = NUM_FL; 
    7582 
    7683int get_effective_focal_length(int zp) { 
    77     return (CF_EFL*get_focal_length(zp))/10000; 
     84    return (CF_EFL*get_focal_length(zp))/CF_EFL_DIV; 
    7885} 
    7986 
    8087int get_focal_length(int zp) { 
    81     if (zp<0) return fl_tbl[0]; 
    82     else if (zp>NUM_FL-1) return fl_tbl[NUM_FL-1]; 
    83     else return fl_tbl[zp]; 
     88    if (zp < 0) zp = 0; 
     89    else if (zp >= NUM_FL) zp = NUM_FL-1; 
     90    return focus_len_table[zp*NUM_DATA]; 
    8491} 
    8592 
    8693int get_zoom_x(int zp) { 
    87     if (zp<1) return 10; 
    88     else if (zp>NUM_FL-1) return fl_tbl[NUM_FL-1]*10/fl_tbl[0]; 
    89     else return fl_tbl[zp]*10/fl_tbl[0]; 
     94    return get_focal_length(zp)*10/focus_len_table[0]; 
    9095} 
    9196 

  • branches/release-1_0/platform/ixus120_sd940/main.c

    r1421 r1770  
    2828} 
    2929 
     30// Focus length table in firmware @0xfffe2a8c 
     31#define NUM_FL      10  // 0 - 9, entries in firmware 
     32#define NUM_DATA    3   // 3 words each entry, first is FL 
     33extern int focus_len_table[NUM_FL*NUM_DATA]; 
    3034 
    31  
    32 static const int fl_tbl[] = {5000, 6000, 7000, 8000, 9500, 10900, 12800,15000,173000,20000}; 
    33 #define NUM_FL (sizeof(fl_tbl)/sizeof(fl_tbl[0])) 
    34 // SD940 focal length range is 5 - 20 mm 
    35 // So, CF_EFL = 15/5*10000=30000 
    36 #define CF_EFL 30000 
     35// Conversion factor lens FL --> 35mm equiv 
     36// lens      35mm     CF 
     37// ----      ----     -- 
     38// 5.0       28       ( 28/ 5.0) * 50 = 280  (min FL) 
     39// 20.0      112      (112/20.0) * 50 = 280  (max FL) 
     40#define CF_EFL      280 
     41#define CF_EFL_DIV  50 
    3742 
    3843const int zoom_points = NUM_FL; 
    3944 
    4045int get_effective_focal_length(int zp) { 
    41     return (CF_EFL*get_focal_length(zp))/10000; 
     46    return (CF_EFL*get_focal_length(zp))/CF_EFL_DIV; 
    4247} 
    4348 
    4449int get_focal_length(int zp) { 
    45     if (zp<0) return fl_tbl[0]; 
    46     else if (zp>NUM_FL-1) return fl_tbl[NUM_FL-1]; 
    47     else return fl_tbl[zp]; 
     50    if (zp < 0) zp = 0; 
     51    else if (zp >= NUM_FL) zp = NUM_FL-1; 
     52    return focus_len_table[zp*NUM_DATA]; 
    4853} 
    4954 
    5055int get_zoom_x(int zp) { 
    51     if (zp<1) return 10; 
    52     else if (zp>NUM_FL-1) return fl_tbl[NUM_FL-1]*10/fl_tbl[0]; 
    53     else return fl_tbl[zp]*10/fl_tbl[0]; 
     56    return get_focal_length(zp)*10/focus_len_table[0]; 
    5457} 
    5558 

  • branches/release-1_0/platform/ixus200_sd980/main.c

    r1212 r1770  
    2828} 
    2929 
     30// Focus length table in firmware @0xfffe2ac8 
     31#define NUM_FL      12  // 0 - 11, entries in firmware 
     32#define NUM_DATA    3   // 3 words each entry, first is FL 
     33extern int focus_len_table[NUM_FL*NUM_DATA]; 
    3034 
    31  
    32 static const int fl_tbl[] = {4000, 5000, 6000, 7000, 8000, 9000, 11000, 13000,15000,18000,22000}; 
    33 #define NUM_FL (sizeof(fl_tbl)/sizeof(fl_tbl[0])) 
    34 // SD980 focal length range is 4 - 22 mm 
    35 // So, CF_EFL = 22/4*10000=55000 
    36 #define CF_EFL 55000 
     35// Conversion factor lens FL --> 35mm equiv 
     36// lens      35mm     CF 
     37// ----      ----     -- 
     38// 4.3       24       ( 24/ 4.3) * 43 = 240  (min FL) 
     39// 21.5      120      (120/21.5) * 43 = 240  (max FL) 
     40#define CF_EFL      240 
     41#define CF_EFL_DIV  43 
    3742 
    3843const int zoom_points = NUM_FL; 
    3944 
    4045int get_effective_focal_length(int zp) { 
    41     return (CF_EFL*get_focal_length(zp))/10000; 
     46    return (CF_EFL*get_focal_length(zp))/CF_EFL_DIV; 
    4247} 
    4348 
    4449int get_focal_length(int zp) { 
    45     if (zp<0) return fl_tbl[0]; 
    46     else if (zp>NUM_FL-1) return fl_tbl[NUM_FL-1]; 
    47     else return fl_tbl[zp]; 
     50    if (zp < 0) zp = 0; 
     51    else if (zp >= NUM_FL) zp = NUM_FL-1; 
     52    return focus_len_table[zp*NUM_DATA]; 
    4853} 
    4954 
    5055int get_zoom_x(int zp) { 
    51     if (zp<1) return 10; 
    52     else if (zp>NUM_FL-1) return fl_tbl[NUM_FL-1]*10/fl_tbl[0]; 
    53     else return fl_tbl[zp]*10/fl_tbl[0]; 
     56    return get_focal_length(zp)*10/focus_len_table[0]; 
    5457} 
    5558 

  • branches/release-1_0/platform/ixus220_elph300hs/main.c

    r1448 r1770  
    3030 
    3131// Focus length table in firmware @0xfffea288 
    32 #define NUM_FL 60               // 0 - 59, entries in firmware (3 words each entry, first is FL) 
    33 extern int focus_len_table[NUM_FL*3]; 
     32#define NUM_FL      64  // 0 - 63, entries in firmware 
     33#define NUM_DATA    3   // 3 words each entry, first is FL 
     34extern int focus_len_table[NUM_FL*NUM_DATA]; 
    3435 
     36// Conversion factor lens FL --> 35mm equiv 
     37// lens      35mm     CF 
     38// ----      ----     -- 
     39// 4.3       24       ( 24/ 4.3) * 43 = 240  (min FL) 
     40// 21.5      120      (120/21.5) * 43 = 240  (max FL) 
     41#define CF_EFL      240 
     42#define CF_EFL_DIV  43 
    3543 
    36 // Focal length range is 4.3 - 21.5 mm, 24 - 120 in 35-mm equivalent. 
    37 // So, CF_EFL = 21.5/4.3*10000=50000 or 120/24*10000=50000 
    38 // divide by 10 to avoid overflow in get_effective_focal_length() 
    39 #define CF_EFL  5000 
    40 const int zoom_points = 60; 
     44const int zoom_points = NUM_FL; 
    4145 
    4246int get_effective_focal_length(int zp) { 
    43         return (CF_EFL*get_focal_length(zp))/1000; 
     47    return (CF_EFL*get_focal_length(zp))/CF_EFL_DIV; 
    4448} 
    4549 
    4650int get_focal_length(int zp) { 
    47         if (zp < 0) zp = 0; 
    48         else if (zp >= NUM_FL) zp = NUM_FL-1; 
    49         return focus_len_table[zp*3]; 
    50          
     51    if (zp < 0) zp = 0; 
     52    else if (zp >= NUM_FL) zp = NUM_FL-1; 
     53    return focus_len_table[zp*NUM_DATA]; 
    5154} 
    5255 
    5356int get_zoom_x(int zp) { 
    54         return get_focal_length(zp)*10/focus_len_table[0]; 
     57    return get_focal_length(zp)*10/focus_len_table[0]; 
    5558} 
    56  
    5759 
    5860long get_vbatt_min() 

  • branches/release-1_0/platform/ixus230_elph310hs/main.c

    r1566 r1770  
    2929} 
    3030 
    31 // Focus length table in firmware @0xFFF4ABC8 
    32 #define NUM_FL 127 
    33 extern int focus_len_table[NUM_FL*3]; 
     31// Focus length table in firmware @0xfff4abc8 
     32#define NUM_FL      127 // 0 - 126, entries in firmware 
     33#define NUM_DATA    2   // 2 words each entry, first is FL 
     34extern int focus_len_table[NUM_FL*NUM_DATA]; 
    3435 
     36// Conversion factor lens FL --> 35mm equiv 
     37// lens      35mm     CF 
     38// ----      ----     -- 
     39// 5.0       28       ( 28/ 5.0) * 50 = 280  (min FL) 
     40// 40.0      224      (224/40.0) * 50 = 280  (max FL) 
     41#define CF_EFL      280 
     42#define CF_EFL_DIV  50 
    3543 
    36 // Focal length range is 5.0 - 40.0 mm, 28 - 224 in 35-mm equivalent. 
    37 // So, CF_EFL = 28/5*10000=56000 or 224/40*10000=56000 
    38 // divide by 10 to avoid overflow in get_effective_focal_length() 
    39 #define CF_EFL  5600 
    4044const int zoom_points = NUM_FL; 
    4145 
    4246int get_effective_focal_length(int zp) { 
    43         return (CF_EFL*get_focal_length(zp))/1000; 
     47    return (CF_EFL*get_focal_length(zp))/CF_EFL_DIV; 
    4448} 
    4549 
    4650int get_focal_length(int zp) { 
    47         if (zp < 0) zp = 0; 
    48         else if (zp >= NUM_FL) zp = NUM_FL-1; 
    49         return focus_len_table[zp*3]; 
    50          
     51    if (zp < 0) zp = 0; 
     52    else if (zp >= NUM_FL) zp = NUM_FL-1; 
     53    return focus_len_table[zp*NUM_DATA]; 
    5154} 
    5255 
    5356int get_zoom_x(int zp) { 
    54         return get_focal_length(zp)*10/focus_len_table[0]; 
     57    return get_focal_length(zp)*10/focus_len_table[0]; 
    5558} 
    56  
    5759 
    5860long get_vbatt_min() 

  • branches/release-1_0/platform/ixus300_sd4000/main.c

    r1377 r1770  
    3333} 
    3434 
    35 // F/2.0 - 5.3 
    36 // 4.9 - 18.6mm 
    37 static const int fl_tbl[] = {5800, 6420, 7060, 7700, 8340, 9950, 11550, 13160, 14750, 17150, 19570, 22760, 26750, 30750, 34800};    // ToDo, convert a focus position to a focal length (* 1000), http://chdk.setepontos.com/index.php?topic=5722.msg59333#msg59333 
    38 #define NUM_FL (sizeof(fl_tbl)/sizeof(fl_tbl[0])) 
    39 #define CF_EFL 60345    // ToDo, convert a camera focal length to a 35mm effective focal length, http://chdk.setepontos.com/index.php?topic=5722.msg59333#msg59333 
     35// Focus length table in firmware @0xfffe9718  
     36#define NUM_FL      64  // 0 - 63, entries in firmware 
     37#define NUM_DATA    3   // 3 words each entry, first is FL 
     38extern int focus_len_table[NUM_FL*NUM_DATA]; 
     39 
     40// Conversion factor lens FL --> 35mm equiv 
     41// lens      35mm     CF 
     42// ----      ----     -- 
     43// 4.9       28       ( 28/ 4.9) * 49 = 280  (min FL) 
     44// 18.6      105      (105/18.6) * 49 = 276.6  (max FL) 
     45#define CF_EFL      280 
     46#define CF_EFL_DIV  49 
    4047 
    4148const int zoom_points = NUM_FL; 
    4249 
    43 // ToDo, http://chdk.setepontos.com/index.php?topic=5722.msg59333#msg59333 
    4450int get_effective_focal_length(int zp) { 
    45     return (CF_EFL*get_focal_length(zp))/10000; 
     51    return (CF_EFL*get_focal_length(zp))/CF_EFL_DIV; 
    4652} 
    4753 
    48 // ToDo 
    4954int get_focal_length(int zp) { 
    50     if (zp<0) return fl_tbl[0]; 
    51     else if (zp>NUM_FL-1) return fl_tbl[NUM_FL-1]; 
    52     else return fl_tbl[zp]; 
     55    if (zp < 0) zp = 0; 
     56    else if (zp >= NUM_FL) zp = NUM_FL-1; 
     57    return focus_len_table[zp*NUM_DATA]; 
    5358} 
    5459 
    55 // ToDo 
    5660int get_zoom_x(int zp) { 
    57     if (zp<1) return 10; 
    58     else if (zp>NUM_FL-1) return fl_tbl[NUM_FL-1]*10/fl_tbl[0]; 
    59     else return fl_tbl[zp]*10/fl_tbl[0]; 
     61    return get_focal_length(zp)*10/focus_len_table[0]; 
    6062} 
    6163 

  • branches/release-1_0/platform/ixus300_sd4000/platform_camera.h

    r1695 r1770  
    5656 
    5757    #define PARAM_CAMERA_NAME               4        // parameter number for GetParameterData to get camera name 
     58 
     59    #undef  DNG_BADPIXEL_VALUE_LIMIT 
     60    #define DNG_BADPIXEL_VALUE_LIMIT        16      // Camera sensor apparently has bad pixels with value > 0 & <=16 
    5861 
    5962    #define CAM_DNG_LENS_INFO               { 49,10, 186,10, 20,10, 53,10 } // See comments in camera.h 

  • branches/release-1_0/platform/ixus310_elph500hs/main.c

    r1339 r1770  
    2828} 
    2929 
    30 // Focus length table in firmware @ 0xFFF4A30C 
    31 #define NUM_FL 64               // 0 - 63, entries in firmware (3 words each entry, first is FL) 
    32 extern int focus_len_table[NUM_FL*3]; 
     30// Focus length table in firmware @0xfff4a30c 
     31#define NUM_FL      64  // 0 - 63, entries in firmware 
     32#define NUM_DATA    3   // 3 words each entry, first is FL 
     33extern int focus_len_table[NUM_FL*NUM_DATA]; 
    3334 
    3435// Conversion factor lens FL --> 35mm equiv 
    3536// lens      35mm     CF 
    3637// ----      ----     -- 
    37 // 4.3       24       (24/4.3) * 430 = 2400  (min FL) 
    38 // 18.8      105      (105/18.8) * 430 = 2401.6  (max FL) 
    39 #define CF_EFL 2402     // rounded up 
    40 #define CF_EFL_DIV 430 
     38// 4.3       24       ( 24/ 4.3) * 43 = 240  (min FL) 
     39// 18.8      105      (105/18.8) * 43 = 240.2  (max FL) 
     40#define CF_EFL      240 
     41#define CF_EFL_DIV  43 
    4142 
    42 const int zoom_points = NUM_FL;  // OK 
     43const int zoom_points = NUM_FL; 
    4344 
    4445int get_effective_focal_length(int zp) { 
    45         return (CF_EFL*get_focal_length(zp))/CF_EFL_DIV; 
     46    return (CF_EFL*get_focal_length(zp))/CF_EFL_DIV; 
    4647} 
    4748 
    4849int get_focal_length(int zp) { 
    49         if (zp < 0) zp = 0; 
    50         else if (zp >= NUM_FL) zp = NUM_FL-1; 
    51         return focus_len_table[zp*3]; 
     50    if (zp < 0) zp = 0; 
     51    else if (zp >= NUM_FL) zp = NUM_FL-1; 
     52    return focus_len_table[zp*NUM_DATA]; 
    5253} 
    5354 
    5455int get_zoom_x(int zp) { 
    55         return get_focal_length(zp)*10/focus_len_table[0]; 
     56    return get_focal_length(zp)*10/focus_len_table[0]; 
    5657} 
    5758 

  • branches/release-1_0/platform/ixus85_sd770/main.c

    r1376 r1770  
    2626} 
    2727 
     28// Focus length table in firmware @0xfffe297c 
     29#define NUM_FL      7   // 0 - 6, entries in firmware 
     30#define NUM_DATA    3   // 3 words each entry, first is FL 
     31extern int focus_len_table[NUM_FL*NUM_DATA]; 
    2832 
    29 static const int fl_tbl[] = {6200, 7230, 8295, 9681, 11614, 14303, 18600}; 
    30 #define NUM_FL (sizeof(fl_tbl)/sizeof(fl_tbl[0])) 
    31 #define CF_EFL 56460 
     33// Conversion factor lens FL --> 35mm equiv 
     34// lens      35mm     CF 
     35// ----      ----     -- 
     36// 6.2       35       ( 35/ 6.2) * 62 = 350  (min FL) 
     37// 18.6      105      (105/18.6) * 62 = 350  (max FL) 
     38#define CF_EFL      350 
     39#define CF_EFL_DIV  62 
    3240 
    3341const int zoom_points = NUM_FL; 
    3442 
    35 int get_effective_focal_length(int zp) 
    36 { 
    37         return (CF_EFL*get_focal_length(zp))/10000; 
     43int get_effective_focal_length(int zp) { 
     44    return (CF_EFL*get_focal_length(zp))/CF_EFL_DIV; 
    3845} 
    3946 
    40 int get_focal_length(int zp) 
    41 { 
    42         if (zp<0) { 
    43                 return fl_tbl[0]; 
    44         } else if (zp>NUM_FL-1) { 
    45                 return fl_tbl[NUM_FL-1]; 
    46         } else { 
    47                 return fl_tbl[zp]; 
    48         } 
     47int get_focal_length(int zp) { 
     48    if (zp < 0) zp = 0; 
     49    else if (zp >= NUM_FL) zp = NUM_FL-1; 
     50    return focus_len_table[zp*NUM_DATA]; 
    4951} 
    5052 
    51 int get_zoom_x(int zp) 
    52 { 
    53         if (zp<1) { 
    54                 return 10; 
    55         } else if (zp>NUM_FL-1) { 
    56                 return fl_tbl[NUM_FL-1]*10/fl_tbl[0]; 
    57         } else { 
    58                 return fl_tbl[zp]*10/fl_tbl[0]; 
    59         } 
     53int get_zoom_x(int zp) { 
     54    return get_focal_length(zp)*10/focus_len_table[0]; 
    6055} 
    6156 

  • branches/release-1_0/platform/ixus860_sd870/main.c

    r847 r1770  
    2929} 
    3030 
     31// Focus length table in firmware @0xfffe2990 
     32#define NUM_FL      8   // 0 - 7, entries in firmware 
     33#define NUM_DATA    3   // 3 words each entry, first is FL 
     34extern int focus_len_table[NUM_FL*NUM_DATA]; 
    3135 
    32 static const int fl_tbl[] = {4600, 6140, 7560, 9110, 10830, 12670, 14690, 17300}; 
    33 #define NUM_FL (sizeof(fl_tbl)/sizeof(fl_tbl[0])) 
    34 #define CF_EFL 60869 
     36// Conversion factor lens FL --> 35mm equiv 
     37// lens      35mm     CF 
     38// ----      ----     -- 
     39// 4.6       28       ( 28/ 4.6) * 46 = 280  (min FL) 
     40// 17.3      105      (105/17.3) * 46 = 279.2  (max FL) 
     41#define CF_EFL      280 
     42#define CF_EFL_DIV  46 
    3543 
    3644const int zoom_points = NUM_FL; 
    3745 
    3846int get_effective_focal_length(int zp) { 
    39     return (CF_EFL*get_focal_length(zp))/10000; 
     47    return (CF_EFL*get_focal_length(zp))/CF_EFL_DIV; 
    4048} 
    4149 
    4250int get_focal_length(int zp) { 
    43     if (zp<0) return fl_tbl[0]; 
    44     else if (zp>NUM_FL-1) return fl_tbl[NUM_FL-1]; 
    45     else return fl_tbl[zp]; 
     51    if (zp < 0) zp = 0; 
     52    else if (zp >= NUM_FL) zp = NUM_FL-1; 
     53    return focus_len_table[zp*NUM_DATA]; 
    4654} 
    4755 
    4856int get_zoom_x(int zp) { 
    49     if (zp<1) return 10; 
    50     else if (zp>NUM_FL-1) return fl_tbl[NUM_FL-1]*10/fl_tbl[0]; 
    51     else return fl_tbl[zp]*10/fl_tbl[0]; 
     57    return get_focal_length(zp)*10/focus_len_table[0]; 
    5258} 
    5359 

  • branches/release-1_0/platform/ixus95_sd1200/main.c

    r1376 r1770  
    6767#define MODESCNT (sizeof(modemap)/sizeof(modemap[0])) 
    6868 
    69 static const int fl_tbl[] = {6200,7230,8295,9681,11614,14303,18600}; 
    70 #define NUM_FL (sizeof(fl_tbl)/sizeof(fl_tbl[0])) 
    71 #define CF_EFL 56452 
     69// Focus length table in firmware @0xfffe2a8c 
     70#define NUM_FL      7   // 0 - 6, entries in firmware 
     71#define NUM_DATA    3   // 3 words each entry, first is FL 
     72extern int focus_len_table[NUM_FL*NUM_DATA]; 
     73 
     74// Conversion factor lens FL --> 35mm equiv 
     75// lens      35mm     CF 
     76// ----      ----     -- 
     77// 6.2       35       ( 35/ 6.2) * 62 = 350  (min FL) 
     78// 18.6      105      (105/18.6) * 62 = 350  (max FL) 
     79#define CF_EFL      350 
     80#define CF_EFL_DIV  62 
    7281 
    7382const int zoom_points = NUM_FL; 
    7483 
    7584int get_effective_focal_length(int zp) { 
    76     return (CF_EFL*get_focal_length(zp))/10000; 
     85    return (CF_EFL*get_focal_length(zp))/CF_EFL_DIV; 
    7786} 
    7887 
    7988int get_focal_length(int zp) { 
    80     if (zp<0) return fl_tbl[0]; 
    81     else if (zp>NUM_FL-1) return fl_tbl[NUM_FL-1]; 
    82     else return fl_tbl[zp]; 
     89    if (zp < 0) zp = 0; 
     90    else if (zp >= NUM_FL) zp = NUM_FL-1; 
     91    return focus_len_table[zp*NUM_DATA]; 
    8392} 
    8493 
    8594int get_zoom_x(int zp) { 
    86     if (zp<1) return 10; 
    87     else if (zp>NUM_FL-1) return fl_tbl[NUM_FL-1]*10/fl_tbl[0]; 
    88     else return fl_tbl[zp]*10/fl_tbl[0]; 
     95    return get_focal_length(zp)*10/focus_len_table[0]; 
    8996} 
    9097 

  • branches/release-1_0/platform/ixus960_sd950/main.c

    r847 r1770  
    2525} 
    2626 
     27// Focus length table in firmware @0xfffe296c 
     28#define NUM_FL      8   // 0 - 7, entries in firmware 
     29#define NUM_DATA    3   // 3 words each entry, first is FL 
     30extern int focus_len_table[NUM_FL*NUM_DATA]; 
    2731 
    28 static const int fl_tbl[] = {7700, 9572, 11454, 13683, 16293, 19548, 23495, 28500}; 
    29 #define NUM_FL (sizeof(fl_tbl)/sizeof(fl_tbl[0])) 
    30 #define CF_EFL 60869 
     32// Conversion factor lens FL --> 35mm equiv 
     33// lens      35mm     CF 
     34// ----      ----     -- 
     35// 7.7       36       ( 36/ 7.7) * 77 = 360  (min FL) 
     36// 28.5      133      (133/28.5) * 77 = 359.3  (max FL) 
     37#define CF_EFL      360 
     38#define CF_EFL_DIV  77 
     39 
    3140const int zoom_points = NUM_FL; 
     41 
    3242int get_effective_focal_length(int zp) { 
    33 return (CF_EFL*get_focal_length(zp))/10000; 
     43    return (CF_EFL*get_focal_length(zp))/CF_EFL_DIV; 
    3444} 
     45 
    3546int get_focal_length(int zp) { 
    36 if (zp<0) return fl_tbl[0]; 
    37 else if (zp>NUM_FL-1) return fl_tbl[NUM_FL-1]; 
    38 else return fl_tbl[zp]; 
     47    if (zp < 0) zp = 0; 
     48    else if (zp >= NUM_FL) zp = NUM_FL-1; 
     49    return focus_len_table[zp*NUM_DATA]; 
    3950} 
     51 
    4052int get_zoom_x(int zp) { 
    41 if (zp<1) return 10; 
    42 else if (zp>NUM_FL-1) return fl_tbl[NUM_FL-1]*10/fl_tbl[0]; 
    43 else return fl_tbl[zp]*10/fl_tbl[0]; 
     53    return get_focal_length(zp)*10/focus_len_table[0]; 
    4454} 
     55 
    4556#if 0 
    4657int rec_switch_state(void) { 

  • branches/release-1_0/platform/ixus970_sd890/main.c

    r1377 r1770  
    2626} 
    2727 
     28// Focus length table in firmware @0xfffe297c 
     29#define NUM_FL      12  // 0 - 11, entries in firmware 
     30#define NUM_DATA    3   // 3 words each entry, first is FL 
     31extern int focus_len_table[NUM_FL*NUM_DATA]; 
    2832 
    29 static const int fl_tbl[] = {6600, 7800, 9000, 10300, 11900,13500, 15400, 17700, 20400, 23700, 28000, 33000}; 
    30 #define NUM_FL (sizeof(fl_tbl)/sizeof(fl_tbl[0])) 
    31 #define CF_EFL 56060 
     33// Conversion factor lens FL --> 35mm equiv 
     34// lens      35mm     CF 
     35// ----      ----     -- 
     36// 6.6       37       ( 37/ 6.6) * 66 = 370  (min FL) 
     37// 33.0      185      (185/33.0) * 66 = 370  (max FL) 
     38#define CF_EFL      370 
     39#define CF_EFL_DIV  66 
    3240 
    3341const int zoom_points = NUM_FL; 
    3442 
    35 int get_effective_focal_length(int zp) 
    36 { 
    37         return (CF_EFL*get_focal_length(zp))/10000; 
     43int get_effective_focal_length(int zp) { 
     44    return (CF_EFL*get_focal_length(zp))/CF_EFL_DIV; 
    3845} 
    3946 
    40 int get_focal_length(int zp) 
    41 { 
    42         if (zp<0) { 
    43                 return fl_tbl[0]; 
    44         } else if (zp>NUM_FL-1) { 
    45                 return fl_tbl[NUM_FL-1]; 
    46         } else { 
    47                 return fl_tbl[zp]; 
    48         } 
     47int get_focal_length(int zp) { 
     48    if (zp < 0) zp = 0; 
     49    else if (zp >= NUM_FL) zp = NUM_FL-1; 
     50    return focus_len_table[zp*NUM_DATA]; 
    4951} 
    5052 
    51 int get_zoom_x(int zp) 
    52 { 
    53         if (zp<1) { 
    54                 return 10; 
    55         } else if (zp>NUM_FL-1) { 
    56                 return fl_tbl[NUM_FL-1]*10/fl_tbl[0]; 
    57         } else { 
    58                 return fl_tbl[zp]*10/fl_tbl[0]; 
    59         } 
     53int get_zoom_x(int zp) { 
     54    return get_focal_length(zp)*10/focus_len_table[0]; 
    6055} 
    6156 

  • branches/release-1_0/platform/ixus980_sd990/main.c

    r847 r1770  
    2929} 
    3030 
    31 // from sd950, zoom steps and sensor size same 
    32 static const int fl_tbl[] = {7700, 9572, 11454, 13683, 16293, 19548, 23495, 28500}; 
    33 #define NUM_FL (sizeof(fl_tbl)/sizeof(fl_tbl[0])) 
    34 // sd950 uses wrong value 
    35 // #define CF_EFL 60869 
    36 // ewavr 
    37 // SD990 focal length range is 7,7 - 28,5 mm, 36 - 133 in 35-mm equivalent. 
    38 // So, CF_EFL = 36/7.7*10000=46753 or 133/28.5*10000=46666. 
    39 #define CF_EFL 46710 // split the difference 
     31// Focus length table in firmware @0xfffe2a8c 
     32#define NUM_FL      8   // 0 - 7, entries in firmware 
     33#define NUM_DATA    3   // 3 words each entry, first is FL 
     34extern int focus_len_table[NUM_FL*NUM_DATA]; 
     35 
     36// Conversion factor lens FL --> 35mm equiv 
     37// lens      35mm     CF 
     38// ----      ----     -- 
     39// 7.7       36       ( 36/ 7.7) * 77 = 360  (min FL) 
     40// 28.5      133      (133/28.5) * 77 = 359.3  (max FL) //360 on 133.2mm(T) 
     41#define CF_EFL      360 
     42#define CF_EFL_DIV  77 
    4043 
    4144const int zoom_points = NUM_FL; 
    4245 
    4346int get_effective_focal_length(int zp) { 
    44     return (CF_EFL*get_focal_length(zp))/10000; 
     47    return (CF_EFL*get_focal_length(zp))/CF_EFL_DIV; 
    4548} 
    4649 
    4750int get_focal_length(int zp) { 
    48     if (zp<0) return fl_tbl[0]; 
    49     else if (zp>NUM_FL-1) return fl_tbl[NUM_FL-1]; 
    50     else return fl_tbl[zp]; 
     51    if (zp < 0) zp = 0; 
     52    else if (zp >= NUM_FL) zp = NUM_FL-1; 
     53    return focus_len_table[zp*NUM_DATA]; 
    5154} 
    5255 
    5356int get_zoom_x(int zp) { 
    54     if (zp<1) return 10; 
    55     else if (zp>NUM_FL-1) return fl_tbl[NUM_FL-1]*10/fl_tbl[0]; 
    56     else return fl_tbl[zp]*10/fl_tbl[0]; 
     57    return get_focal_length(zp)*10/focus_len_table[0]; 
    5758} 
    5859 

  • branches/release-1_0/platform/s95/main.c

    r1059 r1770  
    2626} 
    2727 
     28// Focus length table in firmware @0xfffe2d2c 
     29#define NUM_FL      10  // 0 - 9, entries in firmware 
     30#define NUM_DATA    3   // 3 words each entry, first is FL 
     31extern int focus_len_table[NUM_FL*NUM_DATA]; 
    2832 
    29 //zoom position is get_parameter_data(87) 
    30 static const struct { 
    31         int zp, fl; 
    32 } fl_tbl[] = { 
    33   {   0,   6000}, 
    34   {   1,   6850}, 
    35   {   2,   7490}, 
    36   {   3,   8560}, 
    37   {   4,   9640}, 
    38   {   5,   10700}, 
    39   {   6,   12850}, 
    40   {   7,   14980}, 
    41   {   8,   18190}, 
    42   {   9,   22500}, 
    43 }; 
    44  
    45  
    46 #define NUM_FL (sizeof(fl_tbl)/sizeof(fl_tbl[0])) 
    47 // S90 focal lenght range 6.0 - 22.5 mm (35 mm equivalent: 28 - 105 mm)(1/1.7" Type CCD, Scale Factor To 35 mm Equivalent: 4.6) 
    48 // 28/6,0*10000=46666 
    49 // 105/22,5*10000=46666 
    50  
    51 #define CF_EFL 46666 
     33// Conversion factor lens FL --> 35mm equiv 
     34// lens      35mm     CF 
     35// ----      ----     -- 
     36// 6.0       28       ( 28/ 6.0) * 60 = 280  (min FL) 
     37// 22.5      105      (105/22.5) * 60 = 280  (max FL) 
     38#define CF_EFL      280 
     39#define CF_EFL_DIV  60 
    5240 
    5341const int zoom_points = NUM_FL; 
    5442 
    5543int get_effective_focal_length(int zp) { 
    56     return (CF_EFL*get_focal_length(zp))/10000; 
     44    return (CF_EFL*get_focal_length(zp))/CF_EFL_DIV; 
    5745} 
    5846 
    5947int get_focal_length(int zp) { 
    60         int i; 
    61  
    62         if (zp<fl_tbl[0].zp) 
    63                 return fl_tbl[0].fl; 
    64         else if (zp>fl_tbl[NUM_FL-1].zp) 
    65                 return fl_tbl[NUM_FL-1].fl; 
    66         else { 
    67                 for (i=1; i<NUM_FL; ++i) { 
    68                         if (zp==fl_tbl[i-1].zp) 
    69                                 return fl_tbl[i-1].fl; 
    70                         else if (zp==fl_tbl[i].zp) 
    71                                 return fl_tbl[i].fl; 
    72                         else if (zp<fl_tbl[i].zp) 
    73                                 return fl_tbl[i-1].fl+(zp-fl_tbl[i-1].zp)*(fl_tbl[i].fl-fl_tbl[i-1].fl)/(fl_tbl[i].zp-fl_tbl[i-1].zp); 
    74                 } 
    75         } 
    76         return fl_tbl[NUM_FL-1].fl; 
     48    if (zp < 0) zp = 0; 
     49    else if (zp >= NUM_FL) zp = NUM_FL-1; 
     50    return focus_len_table[zp*NUM_DATA]; 
    7751} 
    7852 
    7953int get_zoom_x(int zp) { 
    80         return get_focal_length(zp)*10/fl_tbl[0].fl; 
     54    return get_focal_length(zp)*10/focus_len_table[0]; 
    8155} 
    82  
    8356 
    8457long get_vbatt_min() 

  • branches/release-1_0/platform/sx100is/main.c

    r847 r1770  
    2929} 
    3030 
     31// Focus length table in firmware @0xfffe31ac 
     32#define NUM_FL      23  // 0 - 22, entries in firmware 
     33#define NUM_DATA    3   // 3 words each entry, first is FL 
     34extern int focus_len_table[NUM_FL*NUM_DATA]; 
    3135 
    32 static const int fl_tbl[] = {6000, 6700, 7300, 8200, 9100, 10300, 11500, 12800, 14400, 16100, 18100, 20100, 22400, 25200, 28100, 31500, 34900, 38900, 42500, 46600, 51100, 55900, 60000}; 
    33 #define NUM_FL (sizeof(fl_tbl)/sizeof(fl_tbl[0])) 
    34 #define CF_EFL 6000 
     36// Conversion factor lens FL --> 35mm equiv 
     37// lens      35mm     CF 
     38// ----      ----     -- 
     39// 6.0       36       ( 36/ 6.0) * 60 = 360  (min FL) 
     40// 60.0      360      (360/60.0) * 60 = 360  (max FL) 
     41#define CF_EFL      360 
     42#define CF_EFL_DIV  60 
    3543 
    3644const int zoom_points = NUM_FL; 
    3745 
    3846int get_effective_focal_length(int zp) { 
    39     return (CF_EFL*get_focal_length(zp))/1000; 
     47    return (CF_EFL*get_focal_length(zp))/CF_EFL_DIV; 
    4048} 
    4149 
    4250int get_focal_length(int zp) { 
    43     if (zp<0) return fl_tbl[0]; 
    44     else if (zp>NUM_FL-1) return fl_tbl[NUM_FL-1]; 
    45     else return fl_tbl[zp]; 
     51    if (zp < 0) zp = 0; 
     52    else if (zp >= NUM_FL) zp = NUM_FL-1; 
     53    return focus_len_table[zp*NUM_DATA]; 
    4654} 
    4755 
    4856int get_zoom_x(int zp) { 
    49     if (zp<1) return 10; 
    50     else if (zp>NUM_FL-1) return fl_tbl[NUM_FL-1]*10/fl_tbl[0]; 
    51     else return fl_tbl[zp]*10/fl_tbl[0]; 
     57    return get_focal_length(zp)*10/focus_len_table[0]; 
    5258} 
    5359 

  • branches/release-1_0/platform/sx110is/main.c

    r847 r1770  
    2929} 
    3030 
     31// Focus length table in firmware @0xfffe31bc 
     32#define NUM_FL      23  // 0 - 22, entries in firmware 
     33#define NUM_DATA    3   // 3 words each entry, first is FL 
     34extern int focus_len_table[NUM_FL*NUM_DATA]; 
    3135 
    32 //fl_tbl still the same as sx100 
    33 static const int fl_tbl[] = {6000, 6700, 7300, 8200, 9100, 10300, 11500, 12800, 14400, 16100, 18100, 20100, 22400, 25200, 28100, 31500, 34900, 38900, 42500, 46600, 51100, 55900, 60000}; 
    34 #define NUM_FL (sizeof(fl_tbl)/sizeof(fl_tbl[0])) 
    35 //#define CF_EFL 6000 
    36 #define CF_EFL 5600             //      1/2.3" as sx10 
     36// Conversion factor lens FL --> 35mm equiv 
     37// lens      35mm     CF 
     38// ----      ----     -- 
     39// 6.0       36       ( 36/ 6.0) * 60 = 360  (min FL) 
     40// 60.0      360      (360/60.0) * 60 = 360  (max FL) 
     41#define CF_EFL      360 
     42#define CF_EFL_DIV  60 
    3743 
    3844const int zoom_points = NUM_FL; 
    3945 
    4046int get_effective_focal_length(int zp) { 
    41         return (CF_EFL*get_focal_length(zp))/1000; 
     47    return (CF_EFL*get_focal_length(zp))/CF_EFL_DIV; 
    4248} 
    4349 
    4450int get_focal_length(int zp) { 
    45     if (zp<0) return fl_tbl[0]; 
    46     else if (zp>NUM_FL-1) return fl_tbl[NUM_FL-1]; 
    47     else return fl_tbl[zp]; 
     51    if (zp < 0) zp = 0; 
     52    else if (zp >= NUM_FL) zp = NUM_FL-1; 
     53    return focus_len_table[zp*NUM_DATA]; 
    4854} 
    4955 
    5056int get_zoom_x(int zp) { 
    51     if (zp<1) return 10; 
    52     else if (zp>NUM_FL-1) return fl_tbl[NUM_FL-1]*10/fl_tbl[0]; 
    53     else return fl_tbl[zp]*10/fl_tbl[0]; 
     57    return get_focal_length(zp)*10/focus_len_table[0]; 
    5458} 
    5559 

  • branches/release-1_0/platform/sx120is/main.c

    • Property svn:eol-style set to native
    r1424 r1770  
    2929} 
    3030 
    31 // from sx100 
    32 //fl_tbl still the same as sx100 
    33 static const int fl_tbl[] = {6000, 6700, 7300, 8200, 9100, 10300, 11500, 12800, 14400, 16100, 18100, 20100, 22400, 25200, 28100, 31500, 34900, 38900, 42500, 46600, 51100, 55900, 60000}; 
    34 #define NUM_FL (sizeof(fl_tbl)/sizeof(fl_tbl[0])) 
    35 //#define CF_EFL 6000 
    36 #define CF_EFL 5600             //      1/2.3" as sx10 
     31// Focus length table in firmware @0xfffe328c 
     32#define NUM_FL      23  // 0 - 22, entries in firmware 
     33#define NUM_DATA    3   // 3 words each entry, first is FL 
     34extern int focus_len_table[NUM_FL*NUM_DATA]; 
     35 
     36// Conversion factor lens FL --> 35mm equiv 
     37// lens      35mm     CF 
     38// ----      ----     -- 
     39// 6.0       36       ( 36/ 6.0) * 60 = 360  (min FL) 
     40// 60.0      360      (360/60.0) * 60 = 360  (max FL) 
     41#define CF_EFL      360 
     42#define CF_EFL_DIV  60 
    3743 
    3844const int zoom_points = NUM_FL; 
    3945 
    4046int get_effective_focal_length(int zp) { 
    41         return (CF_EFL*get_focal_length(zp))/1000; 
     47    return (CF_EFL*get_focal_length(zp))/CF_EFL_DIV; 
    4248} 
    4349 
    4450int get_focal_length(int zp) { 
    45     if (zp<0) return fl_tbl[0]; 
    46     else if (zp>NUM_FL-1) return fl_tbl[NUM_FL-1]; 
    47     else return fl_tbl[zp]; 
     51    if (zp < 0) zp = 0; 
     52    else if (zp >= NUM_FL) zp = NUM_FL-1; 
     53    return focus_len_table[zp*NUM_DATA]; 
    4854} 
    4955 
    5056int get_zoom_x(int zp) { 
    51     if (zp<1) return 10; 
    52     else if (zp>NUM_FL-1) return fl_tbl[NUM_FL-1]*10/fl_tbl[0]; 
    53     else return fl_tbl[zp]*10/fl_tbl[0]; 
     57    return get_focal_length(zp)*10/focus_len_table[0]; 
    5458} 
    55  
    56 //end sx100 
    57  
    58  
    5959 
    6060long get_vbatt_min() 

  • branches/release-1_0/platform/sx130is/main.c

    r1161 r1770  
    2626} 
    2727 
     28// Focus length table in firmware @0xfffe94ec 
     29#define NUM_FL      128 // 0 - 127, entries in firmware 
     30#define NUM_DATA    3   // 3 words each entry, first is FL 
     31extern int focus_len_table[NUM_FL*NUM_DATA]; 
    2832 
    29 //zoom position is get_parameter_data(87) 
    30 static const struct { 
    31         int zp, fl; 
    32 } fl_tbl[] = { 
    33   {   0,    5000}, 
    34   {   16,   8225}, 
    35   {   32,   13080}, 
    36   {   48,   20270}, 
    37   {   64,   29150}, 
    38   {   80,   38125}, 
    39   {   96,   45750}, 
    40   {   112,  51650}, 
    41   {   127,  60000} 
    42 }; 
     33// Conversion factor lens FL --> 35mm equiv 
     34// lens      35mm     CF 
     35// ----      ----     -- 
     36// 5.0       28       ( 28/ 5.0) * 50 = 280  (min FL) 
     37// 60.0      336      (336/60.0) * 50 = 280  (max FL) 
     38#define CF_EFL      280 
     39#define CF_EFL_DIV  50 
    4340 
    44  
    45 #define NUM_FL (sizeof(fl_tbl)/sizeof(fl_tbl[0])) 
    46  
    47 // SX130 focal lenght range 5.0 - 60 mm (35 mm equivalent: 28 - 336 mm)(1/2.3" Type CCD, Scale Factor To 35 mm Equivalent: 5.6) 
    48 // 28/5.0*100=560 
    49 // 336/60*100=560 
    50 #define CF_EFL 560 
    51  
    52 const int zoom_points = 128; 
     41const int zoom_points = NUM_FL; 
    5342 
    5443int get_effective_focal_length(int zp) { 
    55     return (CF_EFL*get_focal_length(zp))/100; 
     44    return (CF_EFL*get_focal_length(zp))/CF_EFL_DIV; 
    5645} 
    5746 
    5847int get_focal_length(int zp) { 
    59         int i; 
    60  
    61         if (zp<fl_tbl[0].zp) 
    62                 return fl_tbl[0].fl; 
    63         else if (zp>fl_tbl[NUM_FL-1].zp) 
    64                 return fl_tbl[NUM_FL-1].fl; 
    65         else { 
    66                 for (i=1; i<NUM_FL; ++i) { 
    67                         if (zp==fl_tbl[i-1].zp) 
    68                                 return fl_tbl[i-1].fl; 
    69                         else if (zp==fl_tbl[i].zp) 
    70                                 return fl_tbl[i].fl; 
    71                         else if (zp<fl_tbl[i].zp) 
    72                                 return fl_tbl[i-1].fl+(zp-fl_tbl[i-1].zp)*(fl_tbl[i].fl-fl_tbl[i-1].fl)/(fl_tbl[i].zp-fl_tbl[i-1].zp); 
    73                 } 
    74         } 
    75         return fl_tbl[NUM_FL-1].fl; 
     48    if (zp < 0) zp = 0; 
     49    else if (zp >= NUM_FL) zp = NUM_FL-1; 
     50    return focus_len_table[zp*NUM_DATA]; 
    7651} 
    7752 
    7853int get_zoom_x(int zp) { 
    79         return get_focal_length(zp)*10/fl_tbl[0].fl; 
     54    return get_focal_length(zp)*10/focus_len_table[0]; 
    8055} 
    81  
    8256 
    8357long get_vbatt_min() 

  • branches/release-1_0/platform/sx150is/main.c

    r1415 r1770  
    2626} 
    2727 
     28// Focus length table in firmware @0xfffeabd8 
     29#define NUM_FL      128 // 0 - 127, entries in firmware 
     30#define NUM_DATA    2   // 2 words each entry, first is FL 
     31extern int focus_len_table[NUM_FL*NUM_DATA]; 
    2832 
    29 //zoom position is get_parameter_data(87) 
    30 static const struct { 
    31         int zp, fl; 
    32 } fl_tbl[] = { 
    33   {   0,    5000}, 
    34   {   16,   8225}, 
    35   {   32,   13080}, 
    36   {   48,   20270}, 
    37   {   64,   29150}, 
    38   {   80,   38125}, 
    39   {   96,   45750}, 
    40   {   112,  51650}, 
    41   {   127,  60000} 
    42 }; 
     33// Conversion factor lens FL --> 35mm equiv 
     34// lens      35mm     CF 
     35// ----      ----     -- 
     36// 5.0       28       ( 28/ 5.0) * 50 = 280  (min FL) 
     37// 60.0      336      (336/60.0) * 50 = 280  (max FL) 
     38#define CF_EFL      280 
     39#define CF_EFL_DIV  50 
    4340 
    44  
    45 #define NUM_FL (sizeof(fl_tbl)/sizeof(fl_tbl[0])) 
    46  
    47 // SX150 focal lenght range 5.0 - 60 mm (35 mm equivalent: 28 - 336 mm)(1/2.3" Type CCD, Scale Factor To 35 mm Equivalent: 5.6) 
    48 // 28/5.0*100=560 
    49 // 336/60*100=560 
    50 #define CF_EFL 560 
    51  
    52 const int zoom_points = 128; 
     41const int zoom_points = NUM_FL; 
    5342 
    5443int get_effective_focal_length(int zp) { 
    55     return (CF_EFL*get_focal_length(zp))/100; 
     44    return (CF_EFL*get_focal_length(zp))/CF_EFL_DIV; 
    5645} 
    5746 
    5847int get_focal_length(int zp) { 
    59         int i; 
    60  
    61         if (zp<fl_tbl[0].zp) 
    62                 return fl_tbl[0].fl; 
    63         else if (zp>fl_tbl[NUM_FL-1].zp) 
    64                 return fl_tbl[NUM_FL-1].fl; 
    65         else { 
    66                 for (i=1; i<NUM_FL; ++i) { 
    67                         if (zp==fl_tbl[i-1].zp) 
    68                                 return fl_tbl[i-1].fl; 
    69                         else if (zp==fl_tbl[i].zp) 
    70                                 return fl_tbl[i].fl; 
    71                         else if (zp<fl_tbl[i].zp) 
    72                                 return fl_tbl[i-1].fl+(zp-fl_tbl[i-1].zp)*(fl_tbl[i].fl-fl_tbl[i-1].fl)/(fl_tbl[i].zp-fl_tbl[i-1].zp); 
    73                 } 
    74         } 
    75         return fl_tbl[NUM_FL-1].fl; 
     48    if (zp < 0) zp = 0; 
     49    else if (zp >= NUM_FL) zp = NUM_FL-1; 
     50    return focus_len_table[zp*NUM_DATA]; 
    7651} 
    7752 
    7853int get_zoom_x(int zp) { 
    79         return get_focal_length(zp)*10/fl_tbl[0].fl; 
     54    return get_focal_length(zp)*10/focus_len_table[0]; 
    8055} 
    81  
    8256 
    8357long get_vbatt_min() 

  • branches/release-1_0/platform/sx210is/main.c

    r1739 r1770  
    3535 
    3636// Focus length table in firmware @ 0xfffea1cc 
    37 #define NUM_FL 126              // 0 - 125, entries in firmware (3 words each entry, first is FL) 
    38 extern int focus_len_table[NUM_FL*3]; 
     37#define NUM_FL      126 // 0 - 125, entries in firmware 
     38#define NUM_DATA    3   // 3 words each entry, first is FL 
     39extern int focus_len_table[NUM_FL*NUM_DATA]; 
    3940 
    40 // Focal length range is 5.0 - 70,0 mm, 27.3 - 392 in 35-mm equivalent. 
    41 // So, CF_EFL = 27.3/5.0*10000=54600 or392/70*10000=56000 
    42 // diff = 54600 - 54566.6 = 1400, split it 1400 / 2 = 700 
    43 // add to base 56000 + 700 = 56700 
    44 // divide by 10 to avoid overflow in get_effective_focal_length() 
    45 #define CF_EFL  5670 
     41// Conversion factor lens FL --> 35mm equiv 
     42// lens      35mm     CF 
     43// ----      ----     -- 
     44// 5.0       28       ( 28/ 5.0) * 50 = 280  (min FL) 
     45// 70.0      392      (392/70.0) * 50 = 280  (max FL) 
     46#define CF_EFL      280 
     47#define CF_EFL_DIV  50 
     48 
    4649const int zoom_points = NUM_FL; 
    4750 
    4851int get_effective_focal_length(int zp) { 
    49         return (CF_EFL*get_focal_length(zp))/1000; 
     52    return (CF_EFL*get_focal_length(zp))/CF_EFL_DIV; 
    5053} 
    5154 
    5255int get_focal_length(int zp) { 
    53         if (zp < 0) zp = 0; 
    54         else if (zp >= NUM_FL) zp = NUM_FL-1; 
    55         return focus_len_table[zp*3]; 
     56    if (zp < 0) zp = 0; 
     57    else if (zp >= NUM_FL) zp = NUM_FL-1; 
     58    return focus_len_table[zp*NUM_DATA]; 
    5659} 
    5760 
    5861int get_zoom_x(int zp) { 
    59         return get_focal_length(zp)*10/focus_len_table[0]; 
     62    return get_focal_length(zp)*10/focus_len_table[0]; 
    6063} 
    61  
    6264 
    6365long get_vbatt_min() 

  • branches/release-1_0/platform/sx220hs/main.c

    r1230 r1770  
    2929} 
    3030 
    31 // Focus length table in firmware @FFF4A3DC  //sx220. like in g12 and sx30 
    32 #define NUM_FL 126              // 0 - 125, entries in firmware (3 words each entry, first is FL) 
    33 extern int focus_len_table[NUM_FL*3]; 
     31// Focus length table in firmware @FFF4A3DC 
     32#define NUM_FL      126 // 0 - 125, entries in firmware 
     33#define NUM_DATA    3   // 3 words each entry, first is FL 
     34extern int focus_len_table[NUM_FL*NUM_DATA]; 
    3435 
     36// Conversion factor lens FL --> 35mm equiv 
     37// lens      35mm     CF 
     38// ----      ----     -- 
     39// 5.0       28       ( 28/ 5.0) * 50 = 280  (min FL) 
     40// 70.0      392      (392/70.0) * 50 = 280  (max FL) 
     41#define CF_EFL      280 
     42#define CF_EFL_DIV  50 
    3543 
    36 // Focal length range is 5.0 - 70,0 mm, 28 - 392 in 35-mm equivalent. 
    37 // So, CF_EFL = 28/5.0*10000=56000 or392/70*10000=56000 
    38 // divide by 10 to avoid overflow in get_effective_focal_length() 
    39 #define CF_EFL  5600 
    40 const int zoom_points = 126; 
     44const int zoom_points = NUM_FL; 
    4145 
    4246int get_effective_focal_length(int zp) { 
    43         return (CF_EFL*get_focal_length(zp))/1000; 
     47    return (CF_EFL*get_focal_length(zp))/CF_EFL_DIV; 
    4448} 
    4549 
    4650int get_focal_length(int zp) { 
    47         if (zp < 0) zp = 0; 
    48         else if (zp >= NUM_FL) zp = NUM_FL-1; 
    49         return focus_len_table[zp*3]; 
    50          
     51    if (zp < 0) zp = 0; 
     52    else if (zp >= NUM_FL) zp = NUM_FL-1; 
     53    return focus_len_table[zp*NUM_DATA]; 
    5154} 
    5255 
    5356int get_zoom_x(int zp) { 
    54         return get_focal_length(zp)*10/focus_len_table[0]; 
     57    return get_focal_length(zp)*10/focus_len_table[0]; 
    5558} 
    56  
    5759 
    5860long get_vbatt_min() 

  • branches/release-1_0/platform/sx230hs/main.c

    r1331 r1770  
    2828} 
    2929 
    30 // Focus length table in firmware @FFF4A3DC  
    31 #define NUM_FL 126              // 0 - 125, entries in firmware (3 words each entry, first is FL) 
    32 extern int focus_len_table[NUM_FL*3]; 
     30// Focus length table in firmware @FFF4A3DC 
     31#define NUM_FL      126 // 0 - 125, entries in firmware 
     32#define NUM_DATA    3   // 3 words each entry, first is FL 
     33extern int focus_len_table[NUM_FL*NUM_DATA]; 
    3334 
    34 // Focal length range is 5.0 - 70,0 mm, 28 - 392 in 35-mm equivalent. 
    35 // So, CF_EFL = 28/5.0*10000=56000 or392/70*10000=56000 
    36 // divide by 10 to avoid overflow in get_effective_focal_length() 
    37 #define CF_EFL  5600 
    38 const int zoom_points = 126; 
     35// Conversion factor lens FL --> 35mm equiv 
     36// lens      35mm     CF 
     37// ----      ----     -- 
     38// 5.0       28       ( 28/ 5.0) * 50 = 280  (min FL) 
     39// 70.0      392      (392/70.0) * 50 = 280  (max FL) 
     40#define CF_EFL      280 
     41#define CF_EFL_DIV  50 
    3942 
    40 //TODO 
     43const int zoom_points = NUM_FL; 
     44 
    4145int get_effective_focal_length(int zp) { 
    42         return (CF_EFL*get_focal_length(zp))/1000; 
     46    return (CF_EFL*get_focal_length(zp))/CF_EFL_DIV; 
    4347} 
    4448 
    45 //TODO 
    4649int get_focal_length(int zp) { 
    47          
    48         if (zp < 0) zp = 0; 
    49         else if (zp >= NUM_FL) zp = NUM_FL-1; 
    50         return focus_len_table[zp*3]; 
    51 /*       
    52         int i; 
    53  
    54         if (zp<fl_tbl[0].zp) 
    55                 return fl_tbl[0].fl; 
    56         else if (zp>fl_tbl[NUM_FL-1].zp) 
    57                 return fl_tbl[NUM_FL-1].fl; 
    58         else 
    59                 for (i=1; i<NUM_FL; ++i) { 
    60                         if (zp==fl_tbl[i-1].zp) 
    61                                 return fl_tbl[i-1].fl; 
    62                         else if (zp==fl_tbl[i].zp) 
    63                                 return fl_tbl[i].fl; 
    64                         else if (zp<fl_tbl[i].zp) 
    65                                 return fl_tbl[i-1].fl+(zp-fl_tbl[i-1].zp)*(fl_tbl[i].fl-fl_tbl[i-1].fl)/(fl_tbl[i].zp-fl_tbl[i-1].zp); 
    66                 } 
    67         return fl_tbl[NUM_FL-1].fl; 
    68 */ 
     50    if (zp < 0) zp = 0; 
     51    else if (zp >= NUM_FL) zp = NUM_FL-1; 
     52    return focus_len_table[zp*NUM_DATA]; 
    6953} 
    7054 
    71 //TODO 
    7255int get_zoom_x(int zp) { 
    73         return get_focal_length(zp)*10/focus_len_table[0]; 
    74         //return get_focal_length(zp)*10/fl_tbl[0].fl; 
     56    return get_focal_length(zp)*10/focus_len_table[0]; 
    7557} 
    76  
    7758 
    7859//TODO 

  • branches/release-1_0/platform/sx30/main.c

    r1564 r1770  
    3737 
    3838// Focus length table in firmware @ FFFEA5CC 
    39 #define NUM_FL 201              // 0 - 200, entries in firmware 
    40 extern int focus_len_table[NUM_FL]; 
     39#define NUM_FL      201 // 0 - 200, entries in firmware 
     40#define NUM_DATA    1   // 1 int value each entry 
     41extern int focus_len_table[NUM_FL*NUM_DATA]; 
    4142 
    4243// Conversion factor lens FL --> 35mm equiv 
    4344// lens      35mm     CF 
    4445// ----      ----     -- 
    45 // 4.3       24       (24/4.3) * 43 = 240  (min FL) 
     46// 4.3       24       ( 24/  4.3) * 43 = 240  (min FL) 
    4647// 150.5     840      (840/150.5) * 43 = 240  (max FL) 
    47 #define CF_EFL 240 
    48 #define CF_EFL_DIV 43 
     48#define CF_EFL      240 
     49#define CF_EFL_DIV  43 
    4950 
    50 const int zoom_points = 201; 
     51const int zoom_points = NUM_FL; 
    5152 
    5253int get_effective_focal_length(int zp) { 
    53         return (CF_EFL*get_focal_length(zp))/CF_EFL_DIV; 
     54    return (CF_EFL*get_focal_length(zp))/CF_EFL_DIV; 
    5455} 
    5556 
    5657int get_focal_length(int zp) { 
    57         if (zp < 0) zp = 0; 
    58         else if (zp >= NUM_FL) zp = NUM_FL-1; 
    59         return focus_len_table[zp]; 
     58    if (zp < 0) zp = 0; 
     59    else if (zp >= NUM_FL) zp = NUM_FL-1; 
     60    return focus_len_table[zp*NUM_DATA]; 
    6061} 
    6162 
    6263int get_zoom_x(int zp) { 
    63         return get_focal_length(zp)*10/focus_len_table[0]; 
     64    return get_focal_length(zp)*10/focus_len_table[0]; 
    6465} 
    6566 

  • branches/release-1_0/platform/sx40hs/main.c

    r1564 r1770  
    3636} 
    3737 
    38 // Focus length table in firmware @ FFFEA5CC 
    39 #define NUM_FL 201              // 0 - 200, entries in firmware 
    40 extern int focus_len_table[NUM_FL]; 
     38// Focus length table in firmware @ 0xfff4a7b4 
     39#define NUM_FL      201 // 0 - 200, entries in firmware 
     40#define NUM_DATA    1   // 1 int value each entry 
     41extern int focus_len_table[NUM_FL*NUM_DATA]; 
    4142 
    4243// Conversion factor lens FL --> 35mm equiv 
    4344// lens      35mm     CF 
    4445// ----      ----     -- 
    45 // 4.3       24       (24/4.3) * 43 = 240  (min FL) 
     46// 4.3       24       ( 24/  4.3) * 43 = 240  (min FL) 
    4647// 150.5     840      (840/150.5) * 43 = 240  (max FL) 
    47 #define CF_EFL 240 
    48 #define CF_EFL_DIV 43 
     48#define CF_EFL      240 
     49#define CF_EFL_DIV  43 
    4950 
    50 const int zoom_points = 201; 
     51const int zoom_points = NUM_FL; 
    5152 
    5253int get_effective_focal_length(int zp) { 
    53         return (CF_EFL*get_focal_length(zp))/CF_EFL_DIV; 
     54    return (CF_EFL*get_focal_length(zp))/CF_EFL_DIV; 
    5455} 
    5556 
    5657int get_focal_length(int zp) { 
    57         if (zp < 0) zp = 0; 
    58         else if (zp >= NUM_FL) zp = NUM_FL-1; 
    59         return focus_len_table[zp]; 
     58    if (zp < 0) zp = 0; 
     59    else if (zp >= NUM_FL) zp = NUM_FL-1; 
     60    return focus_len_table[zp*NUM_DATA]; 
    6061} 
    6162 
    6263int get_zoom_x(int zp) { 
    63         return get_focal_length(zp)*10/focus_len_table[0]; 
     64    return get_focal_length(zp)*10/focus_len_table[0]; 
    6465} 
    6566 
Note: See TracChangeset for help on using the changeset viewer.