CHDK_DE Vorschauversion  Trunk Rev. 5279
 Alle Datenstrukturen Dateien Funktionen Variablen Typdefinitionen Aufzählungen Aufzählungswerte Makrodefinitionen
shooting.c-Dateireferenz
#include "platform.h"
#include "keyboard.h"
#include "math.h"
#include "stdlib.h"
#include "conf.h"
#include "histogram.h"
#include "usb_remote.h"
#include "autoiso.h"
#include "levent.h"
#include "script_api.h"
+ Include-Abhängigkeitsdiagramm für shooting.c:

gehe zum Quellcode dieser Datei

Datenstrukturen

struct  PHOTO_PARAM
 

Makrodefinitionen

#define PHOTO_PARAM_TV_NONE   32767
 
#define SV96_MARKET_OFFSET   69
 
#define ISO_MARKET_TO_REAL_MULT   9955
 
#define ISO_MARKET_TO_REAL_SHIFT   14
 
#define ISO_MARKET_TO_REAL_ROUND   8192
 
#define ISO_REAL_TO_MARKET_MULT   3371
 
#define ISO_REAL_TO_MARKET_SHIFT   11
 
#define ISO_REAL_TO_MARKET_ROUND   1024
 
#define ISO_MARKET_TO_REAL(x)   (((int)x * ISO_MARKET_TO_REAL_MULT + ISO_MARKET_TO_REAL_ROUND) >> ISO_MARKET_TO_REAL_SHIFT)
 
#define ISO_REAL_TO_MARKET(x)   (((int)x * ISO_REAL_TO_MARKET_MULT + ISO_REAL_TO_MARKET_ROUND) >> ISO_REAL_TO_MARKET_SHIFT)
 
#define tv_override_zero_shift   18
 
#define AV96_MIN   (aperture_sizes_table[0].prop_id)
 
#define AV96_MAX   (aperture_sizes_table[AS_SIZE-1].prop_id)
 

Funktionen

int rec_mode_active (void)
 
int shooting_get_prop (int id)
 
static int shooting_get_prop_int (int id)
 
void shooting_set_prop (int id, int v)
 
short shooting_get_is_mode ()
 
short shooting_get_bv96 ()
 
short shooting_get_canon_overexposure_value ()
 
short shooting_get_flash_mode ()
 
short shooting_get_focus_mode ()
 
short shooting_get_ev_correction1 ()
 
short shooting_get_ev_correction2 ()
 
short shooting_get_resolution ()
 
short shooting_get_display_mode ()
 
int shooting_get_exif_subject_dist ()
 
int shooting_is_flash ()
 
int shooting_in_progress ()
 
int shooting_get_canon_raw_enabled ()
 
int shooting_get_imager_active ()
 
int shooting_get_digital_zoom_state (void)
 
short shooting_get_real_focus_mode ()
 
short shooting_get_focus_state ()
 
short shooting_get_focus_ok ()
 
short shooting_get_drive_mode ()
 
int shooting_get_zoom ()
 
short shooting_get_canon_iso_mode ()
 
short shooting_get_sv96_market ()
 
short shooting_get_sv96_real ()
 
short shooting_get_sv96_delta ()
 
short shooting_get_sv96_from_iso (short iso)
 
short shooting_get_iso_from_sv96 (short sv96)
 
short shooting_iso_market_to_real (short isom)
 
short shooting_iso_real_to_market (short isor)
 
short shooting_sv96_market_to_real (short sv96)
 
short shooting_sv96_real_to_market (short sv96)
 
short shooting_get_iso_override_value ()
 
int shooting_get_iso_mode ()
 
short shooting_get_iso_real ()
 
short shooting_get_iso_market ()
 
static void set_iso_mode (int i)
 
void shooting_set_iso_mode (int v)
 
void shooting_set_sv96 (short sv96, short is_now)
 
void shooting_set_iso_real (short iso, short is_now)
 
static void iso_init ()
 
short shooting_get_tv96 ()
 
short shooting_get_tv96_from_shutter_speed (float t)
 
float shooting_get_shutter_speed_from_tv96 (short tv96)
 
static int shooting_get_tv96_override_value ()
 
static int find_nearest_shutter_speed_entry (short tv96)
 
static short find_canon_shutter_speed (short tv96)
 
void shooting_set_tv96_direct (short tv96, short is_now)
 
void shooting_set_tv96 (short tv96, short is_now)
 
short shooting_get_user_tv96 ()
 
int shooting_get_user_tv_id ()
 
void shooting_set_user_tv_by_id (int v)
 
void shooting_set_user_tv_by_id_rel (int v)
 
void shooting_set_user_tv96 (short tv96)
 
short shooting_get_av96 ()
 
short shooting_get_aperture_sizes_table_size ()
 
int shooting_get_aperture_from_av96 (short av96)
 
short shooting_get_av96_from_aperture (int aperture)
 
short shooting_get_av96_override_value ()
 
int shooting_get_real_aperture ()
 
static int shooting_get_min_real_aperture ()
 
void shooting_set_av96_direct (short av96, short is_now)
 
void shooting_set_av96 (short av96, short is_now)
 
short shooting_get_user_av96 ()
 
int shooting_get_user_av_id ()
 
void shooting_set_user_av_by_id (int v)
 
void shooting_set_user_av_by_id_rel (int v)
 
void shooting_set_user_av96 (short av96)
 
void shooting_set_nd_filter_state (short v, short is_now)
 
short shooting_get_min_av96 ()
 
short shooting_get_max_av96 ()
 
void shooting_init ()
 
long get_file_counter ()
 
long get_exposure_counter ()
 
void get_target_dir_name (char *dir)
 
int shooting_get_luminance ()
 
int shooting_get_subject_distance_override_value ()
 
int shooting_mode_canon2chdk (int canonmode)
 
int shooting_mode_chdk2canon (int hackmode)
 
int sd_over_modes ()
 
int shooting_get_lens_to_focal_plane_width ()
 
int shooting_get_hyperfocal_distance_1e3_f (int av, int fl)
 
int shooting_get_near_limit_f (int s, int av, int fl)
 
int shooting_get_far_limit_f (int s, int av, int fl)
 
short shooting_is_infinity_distance ()
 
int shooting_get_canon_subject_distance ()
 
int shooting_get_subject_distance_ ()
 
void shooting_update_dof_values ()
 
int shooting_get_subject_distance ()
 
int shooting_get_hyperfocal_distance ()
 
short shooting_can_focus ()
 
short shooting_get_common_focus_mode ()
 
int shooting_is_flash_ready ()
 
void shooting_set_zoom (int v)
 
void shooting_set_zoom_rel (int v)
 
void shooting_set_zoom_speed (int v)
 
void set_focus_bypass (int m)
 
void shooting_set_focus (int v, short is_now)
 
void shooting_video_bitrate_change (int v)
 
void unlock_optical_zoom (void)
 
int shooting_set_mode_canon (int canonmode)
 
int shooting_set_mode_chdk (int mode)
 
static void shooting_tv_bracketing (int when)
 
static void shooting_av_bracketing (int when)
 
static void shooting_iso_bracketing (int when)
 
static void shooting_subject_distance_bracketing (int when)
 
void bracketing_reset ()
 
void bracketing_step (int when)
 
void shooting_bracketing (void)
 
int captseq_hack_override_active ()
 
void set_movie_status (int status)
 
int get_movie_status ()
 
int is_video_recording ()
 
int mode_is_video (int m)
 
int __attribute__ ((weak))
 
int mode_get (void)
 
static void shooting_set_flash_override ()
 
void shooting_expo_param_override_thumb (void)
 
void shooting_expo_iso_override_thumb (void)
 
void shooting_set_playrec_mode (int mode)
 

Variablen

volatile long focus_busy
 
long playrec_mode
 
const ShutterSpeed shutter_speeds_table []
 
const unsigned int SS_SIZE
 
const ApertureSize aperture_sizes_table []
 pt=require'extras/proptools' Mehr ...
 
const unsigned int AS_SIZE
 
const CapturemodeMap modemap []
 
const unsigned int MODESCNT
 
static short * min_av96_zoom_point_tbl = NULL
 
static PHOTO_PARAM photo_param_put_off
 
static const double inv_log_2 = 1.44269504088906
 
const ISOTable iso_table []
 
const unsigned int ISO_SIZE
 
static short canon_iso_base =0
 
static short canon_sv96_base =0
 
const unsigned int param_file_counter
 
static const double K = 12.5
 
static int focus_interlock_bypass = 0
 
EXPO_BRACKETING_VALUES bracketing
 
static int bracket_steps [4][2]
 
static int bracket_delta [4][2]
 
int movie_status
 

Makro-Dokumentation

#define AV96_MAX   (aperture_sizes_table[AS_SIZE-1].prop_id)

Definiert in Zeile 641 der Datei shooting.c.

#define AV96_MIN   (aperture_sizes_table[0].prop_id)

Definiert in Zeile 640 der Datei shooting.c.

#define ISO_MARKET_TO_REAL (   x)    (((int)x * ISO_MARKET_TO_REAL_MULT + ISO_MARKET_TO_REAL_ROUND) >> ISO_MARKET_TO_REAL_SHIFT)

Definiert in Zeile 274 der Datei shooting.c.

#define ISO_MARKET_TO_REAL_MULT   9955

Definiert in Zeile 266 der Datei shooting.c.

#define ISO_MARKET_TO_REAL_ROUND   8192

Definiert in Zeile 268 der Datei shooting.c.

#define ISO_MARKET_TO_REAL_SHIFT   14

Definiert in Zeile 267 der Datei shooting.c.

#define ISO_REAL_TO_MARKET (   x)    (((int)x * ISO_REAL_TO_MARKET_MULT + ISO_REAL_TO_MARKET_ROUND) >> ISO_REAL_TO_MARKET_SHIFT)

Definiert in Zeile 275 der Datei shooting.c.

#define ISO_REAL_TO_MARKET_MULT   3371

Definiert in Zeile 269 der Datei shooting.c.

#define ISO_REAL_TO_MARKET_ROUND   1024

Definiert in Zeile 271 der Datei shooting.c.

#define ISO_REAL_TO_MARKET_SHIFT   11

Definiert in Zeile 270 der Datei shooting.c.

#define PHOTO_PARAM_TV_NONE   32767

Definiert in Zeile 39 der Datei shooting.c.

#define SV96_MARKET_OFFSET   69

Definiert in Zeile 261 der Datei shooting.c.

#define tv_override_zero_shift   18

Definiert in Zeile 496 der Datei shooting.c.

Dokumentation der Funktionen

int __attribute__ ( (weak)  )

Definiert in Zeile 1602 der Datei shooting.c.

1603 {
1604  return (playrec_mode==2 || playrec_mode==4 || playrec_mode==5);
1605 }
void bracketing_reset ( )

Definiert in Zeile 1451 der Datei shooting.c.

void bracketing_step ( int  when)

Definiert in Zeile 1458 der Datei shooting.c.

int captseq_hack_override_active ( )

Definiert in Zeile 1486 der Datei shooting.c.

1487 {
1490  return 1;
1491 #if CAM_HAS_IRIS_DIAPHRAGM
1493  return 1;
1494 #endif
1495  }
1496  if(conf.override_disable==1)
1497  return 0;
1499  return 1;
1501  return 1;
1502 #if CAM_HAS_IRIS_DIAPHRAGM
1504  return 1;
1505 #endif
1506  return 0;
1507 }
static short find_canon_shutter_speed ( short  tv96)
static

Definiert in Zeile 535 der Datei shooting.c.

static int find_nearest_shutter_speed_entry ( short  tv96)
static

Definiert in Zeile 514 der Datei shooting.c.

515 {
516  if (tv96 <= shutter_speeds_table[0].prop_id)
517  return 0;
518 
519  int i;
520  for (i=0; i<SS_SIZE-1; i++)
521  {
522  if ((tv96 > shutter_speeds_table[i].prop_id) && (tv96 <= shutter_speeds_table[i+1].prop_id))
523  {
524  if ((tv96 - shutter_speeds_table[i].prop_id) < (shutter_speeds_table[i+1].prop_id - tv96))
525  return i;
526  else
527  return i+1;
528  }
529  }
530 
531  return SS_SIZE-1;
532 }
long get_exposure_counter ( )

Definiert in Zeile 916 der Datei shooting.c.

917 {
918  long v = 0;
920  v = ((v>>4)&0x3FFF);
921  return v;
922 }
long get_file_counter ( )

Definiert in Zeile 909 der Datei shooting.c.

910 {
911  long v = 0;
913  return v;
914 }
int get_movie_status ( )

Definiert in Zeile 1544 der Datei shooting.c.

1545 {
1546 #ifndef CAM_SIMPLE_MOVIE_STATUS
1547  return movie_status;
1548 #else
1549  // firmware movie_status interpreted as: zero - not recording, nonzero - recording
1550  return simple_movie_status?VIDEO_RECORD_IN_PROGRESS:VIDEO_RECORD_STOPPED;
1551 #endif
1552 }
void get_target_dir_name ( char *  dir)

Definiert in Zeile 926 der Datei shooting.c.

926  {
927  extern long get_target_dir_num();
928  sprintf(dir,"A/DCIM/%03dCANON",get_target_dir_num());
929 }
int is_video_recording ( )

Definiert in Zeile 1555 der Datei shooting.c.

1556 {
1557 #ifndef CAM_SIMPLE_MOVIE_STATUS
1558 #if defined(CAM_HAS_MOVIE_DIGEST_MODE)
1559  // If camera has movie digest mode then movie_status values are different than previous models
1560  // 'movie_status' values
1561  // 0 - after startup
1562  // 1 - movie recording stopped
1563  // 4 - movie recording in progress, or in 'movie digest' scene mode
1564  // 5 - movie recording stopping
1565  // 6 - in video mode, not recording
1567 #else
1568  // 'movie_status' values
1569  // 0 - after startup
1570  // 1 - movie recording stopped
1571  // 4 - movie recording in progress
1572  // 5 - movie recording stopping
1573  return (movie_status > 1);
1574 #endif
1575 #else // CAM_SIMPLE_MOVIE_STATUS
1576  return (simple_movie_status!=0);
1577 #endif
1578 }
static void iso_init ( )
static

Definiert in Zeile 451 der Datei shooting.c.

452 {
453  // Get the camera ISO base value, store in global variable 'canon_iso_base'
454  if (iso_table[1-iso_table[0].id].prop_id == 50)
455  canon_iso_base = 50;
456  else
458 
459  // Get the SV96 value corresponding to the base Canon ISO for the camera
460  // Store in global variable 'canon_sv96_base'
462 }
int mode_get ( void  )

Definiert in Zeile 1607 der Datei shooting.c.

1608 {
1609  int mode, t=0xFF;
1610 
1611  mode = (rec_mode_active())?MODE_REC:MODE_PLAY;
1612 
1613 #ifdef CAM_SWIVEL_SCREEN
1614  extern int screen_opened(void); // 0 not open, non-zero open
1615  extern int screen_rotated(void); // 0 not rotated, non-zero rotated
1616 
1617  mode |= (screen_opened())?MODE_SCREEN_OPENED:0;
1618  mode |= (screen_rotated())?MODE_SCREEN_ROTATED:0;
1619 #endif
1620 
1621 #ifdef CAM_SUPPORT_BITMAP_RES_CHANGE
1622  extern void update_screen_dimensions();
1624 #endif
1625 
1627 #ifdef CAM_MASK_VID_REC_ACTIVE
1629 #else
1630  mode |= shooting_mode_canon2chdk(t);
1631 #endif
1632 
1633  // Set camera state variables from mode info
1637  camera_info.state.mode_rec = ((mode & MODE_MASK) == MODE_REC);
1639  camera_info.state.mode_play = ((mode & MODE_MASK) == MODE_PLAY);
1641 
1642 #ifdef CAM_CLEAN_OVERLAY
1643  extern void handle_clean_overlay();
1644  handle_clean_overlay();
1645 #endif
1646 
1647  return (mode);
1648 }
int mode_is_video ( int  m)

Definiert in Zeile 1581 der Datei shooting.c.

1582 {
1583  m = m & MODE_SHOOTING_MASK;
1584  return (m==MODE_VIDEO_STD ||
1585  m==MODE_VIDEO_SPEED ||
1586  m==MODE_VIDEO_COMPACT ||
1593  m==MODE_VIDEO_M ||
1596  // not clear if this should be considered a video mode ?
1597  // m==MODE_VIDEO_MOVIE_DIGEST
1598  );
1599 }
int rec_mode_active ( void  )

Definiert in Zeile 221 der Datei main.c.

221  {
222 // return ((physw_status[0]&0x03)==0x01) ? 0 : 1;
223  return (playrec_mode==1); //(0 in play, 1 in record, 2 in record review)
224 }
int sd_over_modes ( void  )

Definiert in Zeile 982 der Datei shooting.c.

983 { return ( 0
984 #ifdef CAM_SD_OVER_IN_AF
985  + 1
986 #endif
987 #ifdef CAM_SD_OVER_IN_AFL
988  + 2
989 #endif
990 #ifdef CAM_SD_OVER_IN_MF
991  + 4
992 #endif
993 ); }
void set_focus_bypass ( int  m)

Definiert in Zeile 1237 der Datei shooting.c.

1238 {
1240 }
static void set_iso_mode ( int  i)
static

Definiert in Zeile 362 der Datei shooting.c.

363 {
364  short vv = iso_table[i].prop_id;
365  set_property_case(PROPCASE_ISO_MODE, &vv, sizeof(vv));
366 }
void set_movie_status ( int  status)

Definiert in Zeile 1515 der Datei shooting.c.

1516 {
1517 #ifndef CAM_SIMPLE_MOVIE_STATUS
1518  switch(status)
1519  {
1520  case 1:
1522  {
1524  }
1525  break;
1526  case 2:
1528  {
1530  }
1531  break;
1532  case 3:
1534  {
1536  }
1537  break;
1538  }
1539 #else // CAM_SIMPLE_MOVIE_STATUS
1540  // no known way to control the recording process
1541 #endif
1542 }
static void shooting_av_bracketing ( int  when)
static

Definiert in Zeile 1375 der Datei shooting.c.

1376 {
1377  // first shot? (actually this is called just after the first shot has been taken)
1378  if (bracketing.shoot_counter == 0)
1379  {
1382  else
1385  }
1386 
1387  // Adjust delta AV value for shot based on shot number
1389  // Calculate new AV (note, need to subtract delta because higher values are smaller apertures / darker images)
1391 
1392  // Inc for next shot
1394 
1395  // Apply value for next shot to be taken
1396  if (value != bracketing.av96)
1397  {
1398  shooting_set_av96_direct(value, when);
1399 #ifdef CAM_AV_OVERRIDE_IRIS_FIX
1400  extern int MoveIrisWithAv(short*);
1401  MoveIrisWithAv(&value);
1402 #endif
1403  }
1404 }
void shooting_bracketing ( void  )

Definiert in Zeile 1466 der Datei shooting.c.

short shooting_can_focus ( )

Definiert in Zeile 1148 der Datei shooting.c.

1149 {
1150  if(camera_info.state.mode_play) return 0 ; // don't focus in playback mode
1151 
1152  if(focus_interlock_bypass) return 1; // checks disabled, allow
1153 
1154  if( camera_info.state.mode_video == 1) return 1; // FIXME : default to MF enabled in video mode for now
1155 
1156 #ifdef CAM_SD_OVER_IN_AFL
1157  if (shooting_get_prop(PROPCASE_AF_LOCK)==1 ) return 1; // allow focus if AFL enabled and camera can focus that way?
1158 #endif
1159 #ifdef CAM_SD_OVER_IN_MF
1160  if (shooting_get_prop(PROPCASE_FOCUS_MODE)==1 ) return 1; // allow focus if MF enabled and camera can focus that way?
1161 #endif
1162 
1163 #ifdef CAM_SD_OVER_IN_AF
1164 #ifdef PROPCASE_CONTINUOUS_AF
1165  if (shooting_get_prop(PROPCASE_CONTINUOUS_AF)) return 0; // don't focus in continuous AF mode,
1166 #endif
1167 #ifdef PROPCASE_SERVO_AF
1168  if (shooting_get_prop(PROPCASE_SERVO_AF)) return 0; // don't focus in servo AF mode
1169 #endif
1170  if ( (shooting_get_prop(PROPCASE_AF_LOCK)==0) // allow focus when in AF mode (i.e AFL or MF not enabled)?
1171  && (shooting_get_prop(PROPCASE_FOCUS_MODE)==0 )) return 1;
1172 #endif
1173  return 0;
1174 }
void shooting_expo_iso_override_thumb ( void  )

Definiert in Zeile 1810 der Datei shooting.c.

1811 {
1813  {
1815  // photo_param_put_off.sv96 is not reset here, it will be reset in next call to shooting_expo_param_override
1816  }
1817  else if (is_iso_override_enabled)
1821 
1822 #if defined(CAM_HAS_ND_FILTER) && defined(CAM_HAS_NATIVE_ND_FILTER)
1824  {
1826  //photo_param_put_off.nd_filter=0;
1827  }
1828  else if (conf.nd_filter_state && !(conf.override_disable==1))
1830 #endif
1831 
1832  // Set flash mode & override
1834 }
void shooting_expo_param_override_thumb ( void  )

Definiert in Zeile 1744 der Datei shooting.c.

1745 {
1747  {
1750  }
1751  else if (is_tv_override_enabled)
1752  {
1754  }
1755 
1757  {
1760  }
1761  else if (is_iso_override_enabled)
1765 
1767  {
1770  }
1771  else if (is_av_override_enabled)
1773 
1775  {
1778  }
1779  else if (is_sd_override_enabled)
1781 
1782 #if CAM_HAS_ND_FILTER
1784  {
1787  }
1788  else if (conf.nd_filter_state && !(conf.override_disable==1))
1790 #endif
1791 
1792 #if CAM_REAR_CURTAIN
1793  shooting_set_flash_sync_curtain(conf.flash_sync_curtain);
1794 #endif
1795 
1796  // Set flash mode & override
1798 
1799 #if CAM_QUALITY_OVERRIDE
1800  // this doesn't really need to be set in the override hook.
1801  // should only need to be set once if the users doesn't change back, but doing it here ensures it is set
1802  shooting_set_image_quality(conf.fast_image_quality);
1803 #endif
1804 
1806 }
int shooting_get_aperture_from_av96 ( short  av96)

Definiert in Zeile 648 der Datei shooting.c.

649 {
650  if (av96)
651  return (short)((pow(2, ((double)av96)/192.0))*1000.0 + 0.5);
652  return -1;
653 }
short shooting_get_aperture_sizes_table_size ( )

Definiert in Zeile 644 der Datei shooting.c.

644 { return AS_SIZE; }
short shooting_get_av96 ( )

Definiert in Zeile 643 der Datei shooting.c.

643 { return shooting_get_prop(PROPCASE_AV); }
short shooting_get_av96_from_aperture ( int  aperture)

Definiert in Zeile 655 der Datei shooting.c.

656 {
657  return (int)((log((double)aperture/1000.0) * 192 * inv_log_2) + 0.5);
658 }
short shooting_get_av96_override_value ( )

Definiert in Zeile 661 der Datei shooting.c.

662 {
665  return (short) (AV96_MAX+32*(conf.av_override_value-AS_SIZE+1));
666 }
short shooting_get_bv96 ( )

Definiert in Zeile 82 der Datei shooting.c.

82 { return shooting_get_prop(PROPCASE_BV); }
short shooting_get_canon_iso_mode ( )

Definiert in Zeile 250 der Datei shooting.c.

short shooting_get_canon_overexposure_value ( )

Definiert in Zeile 83 der Datei shooting.c.

int shooting_get_canon_raw_enabled ( )

Definiert in Zeile 96 der Datei shooting.c.

96  {
97 #ifdef CAM_HAS_CANON_RAW
98 #ifdef PROPCASE_IMAGE_FORMAT
99  return (shooting_get_prop(PROPCASE_IMAGE_FORMAT) != 1); // 0 = raw, 2 = raw+jpeg
100 #else
101  return (shooting_get_prop(PROPCASE_RESOLUTION) == 5); // resolution 5 = raw, jpeg controlled with another prop
102 #endif
103 #else
104  return 0;
105 #endif
106 }
int shooting_get_canon_subject_distance ( )

Definiert in Zeile 1032 der Datei shooting.c.

1033 {
1036  else
1037  return (lens_get_focus_pos_from_lens());
1038 }
short shooting_get_common_focus_mode ( )

Definiert in Zeile 1176 der Datei shooting.c.

1177 {
1178 #if !CAM_HAS_MANUAL_FOCUS
1179  return conf.subj_dist_override_koef; // SD override state 0=OFF, 1=ON, 2=Infinity if camera has no native MF mode
1180 #else
1181  return shooting_get_focus_mode(); // 0=Auto, 1=manual
1182 #endif
1183 }
int shooting_get_digital_zoom_state ( void  )

Definiert in Zeile 129 der Datei shooting.c.

130 {
131 #if CAM_PROPSET == 7 || CAM_PROPSET == 9 || CAM_PROPSET == 10 || CAM_PROPSET == 11
132  // PS7 doesn't have _STATE, combines values
134  if(x==1) {
135  return 1;
136  }
137  return 0;
138 #else
140 #endif
141 }
short shooting_get_display_mode ( )

Definiert in Zeile 89 der Datei shooting.c.

short shooting_get_drive_mode ( )

Definiert in Zeile 170 der Datei shooting.c.

171 {
172  // these cameras do not set PROPCASE_DRIVE_MODE when in custom timer mode
173  // SX 200 IS 0,1,2,3,4=Off, 2 Second, Custom, Face Detection
174 #if defined (CAM_DRIVE_MODE_FROM_TIMER_MODE)
176  // note we return this only in custom mode.
177  // Other cameras would return 3 if any timer mode is set (?) even if it doesn't do multiple exposures
178  // note that face detect does multiple exposure
179  if (m == 3)
180  return m;
181 #endif
182 
184 }
short shooting_get_ev_correction1 ( )

Definiert in Zeile 86 der Datei shooting.c.

short shooting_get_ev_correction2 ( )

Definiert in Zeile 87 der Datei shooting.c.

int shooting_get_exif_subject_dist ( )

Definiert in Zeile 91 der Datei shooting.c.

int shooting_get_far_limit_f ( int  s,
int  av,
int  fl 
)

Definiert in Zeile 1017 der Datei shooting.c.

1018 {
1019  if (shooting_is_infinity_distance()) return (-1);
1020  int h_1e3 = shooting_get_hyperfocal_distance_1e3_f(av, fl);
1021  double m = ((double)(h_1e3 - fl)+500)/1000*s;
1022  int v = ((h_1e3 - 1000*s)+500)/1000;
1023  if ((m>0) && (v>0)) return (int)((2*m/v+1)/2);
1024  else return (-1);
1025 }
short shooting_get_flash_mode ( )

Definiert in Zeile 84 der Datei shooting.c.

short shooting_get_focus_mode ( )

Definiert in Zeile 85 der Datei shooting.c.

short shooting_get_focus_ok ( )

Definiert in Zeile 165 der Datei shooting.c.

166 {
167  return ((shooting_get_focus_state()!=0) && shooting_in_progress());
168 }
short shooting_get_focus_state ( )

Definiert in Zeile 158 der Datei shooting.c.

159 {
160  if (shooting_get_focus_mode()==1) return -1;
162  return (short) m;
163 }
int shooting_get_hyperfocal_distance ( )

Definiert in Zeile 1140 der Datei shooting.c.

1141 {
1144 }
int shooting_get_hyperfocal_distance_1e3_f ( int  av,
int  fl 
)

Definiert in Zeile 1000 der Datei shooting.c.

1001 {
1002  if ((av>0) && (fl>0) && (camera_info.circle_of_confusion>0))
1003  return (int)(((((double)fl*fl)/(av*camera_info.circle_of_confusion)*1000)+fl)+0.5);
1004  else return (-1);
1005 }
int shooting_get_imager_active ( )

Definiert in Zeile 108 der Datei shooting.c.

108  {
109  extern int imager_active;
110  return imager_active;
111 }
short shooting_get_is_mode ( )

Definiert in Zeile 81 der Datei shooting.c.

short shooting_get_iso_from_sv96 ( short  sv96)

Definiert in Zeile 285 der Datei shooting.c.

286 {
287  // APEX equation --> (int)(POWER(2,(iso/96)) * 3.125) + 0.5)
288  return (short)( (double)pow(2, (((double)sv96)/96.0))*100.0/32.0 + 0.5 );
289 }
short shooting_get_iso_market ( )

Definiert in Zeile 354 der Datei shooting.c.

355 {
357  if (sv == 0)
358  return 0;
359  return shooting_get_iso_from_sv96(sv);
360 }
int shooting_get_iso_mode ( )

Definiert in Zeile 333 der Datei shooting.c.

334 {
335  short isov = shooting_get_canon_iso_mode();
336  long i;
337  for (i=0;i<ISO_SIZE;i++)
338  {
339  if (iso_table[i].prop_id == isov)
340  return iso_table[i].id;
341  }
342  return 0;
343 }
short shooting_get_iso_override_value ( )

Definiert in Zeile 311 der Datei shooting.c.

312 {
313  short iso = conf.iso_override_value; // Start with market value
314  // Apply limits if needed
315 #ifdef CAM_ISO_LIMIT_IN_HQ_BURST
316  // Limit max ISO in HQ burst mode (also done in shooting_set_iso_real; but done here so OSD display value is correct)
319 #endif
320 #ifdef CAM_MIN_ISO_OVERRIDE
321  // Limit min (non-zero) ISO
322  // Some cameras will crash if flash used and ISO set lower than this value (most easily tested in AUTO mode)
323  if ((iso > 0) && (iso < CAM_MIN_ISO_OVERRIDE)) iso = CAM_MIN_ISO_OVERRIDE;
324 #endif
325 #ifdef CAM_MAX_ISO_OVERRIDE
326  // Limit max ISO
327  // Some cameras will crash if ISO set higher than this value (dependence on flash is unclear)
329 #endif
330  return shooting_iso_market_to_real(iso); // return real value (after limits applied)
331 }
short shooting_get_iso_real ( )

Definiert in Zeile 345 der Datei shooting.c.

346 {
347  short sv = shooting_get_sv96_real();
348  if (sv == 0)
349  return 0;
350  return shooting_get_iso_from_sv96(sv);
351 }
int shooting_get_lens_to_focal_plane_width ( )

Definiert in Zeile 995 der Datei shooting.c.

996 {
998 }
int shooting_get_luminance ( )

Definiert in Zeile 937 der Datei shooting.c.

938 {
939  short bv = shooting_get_bv96();
940  int b = (int)(100 * K * pow(2.0,((double)(bv-168)/96.0)));
941  return b;
942 }
short shooting_get_max_av96 ( )

Definiert in Zeile 864 der Datei shooting.c.

865 {
866 #if CAM_HAS_IRIS_DIAPHRAGM
867  extern short GetUsableMinAv(void);
869  {
870  return -1;
871  }
872  return GetUsableMinAv();
873 #else
874  return -1;
875 #endif
876 }
short shooting_get_min_av96 ( )

Definiert in Zeile 850 der Datei shooting.c.

851 {
852 #if CAM_HAS_IRIS_DIAPHRAGM
853  extern short GetUsableMaxAv(void);
855  {
856  return -1;
857  }
858  return GetUsableMaxAv();
859 #else
860  return -1;
861 #endif
862 }
static int shooting_get_min_real_aperture ( )
static

Definiert in Zeile 673 der Datei shooting.c.

674 {
675  short av96;
676  get_property_case(PROPCASE_MIN_AV, &av96, sizeof(av96));
677  if (av96)
678  return shooting_get_aperture_from_av96(av96);
680 }
int shooting_get_near_limit_f ( int  s,
int  av,
int  fl 
)

Definiert in Zeile 1007 der Datei shooting.c.

1008 {
1009  if (shooting_is_infinity_distance()) return (-1);
1010  int h_1e3 = shooting_get_hyperfocal_distance_1e3_f(av, fl);
1011  double m = ((double)(h_1e3 - fl)+500)/1000*s;
1012  int v = ((h_1e3 - 2*fl + 1000*s)+500)/1000;
1013  if ((m>0) && (v>0)) return (int)((2*m/v+1)/2);
1014  else return (-1);
1015 }
int shooting_get_prop ( int  id)

Definiert in Zeile 60 der Datei shooting.c.

61 {
62  short vv;
63  get_property_case(id, &vv, sizeof(vv));
64  return vv;
65 }
static int shooting_get_prop_int ( int  id)
static

Definiert in Zeile 67 der Datei shooting.c.

68 {
69  int vv;
70  get_property_case(id, &vv, sizeof(vv));
71  return vv;
72 }
int shooting_get_real_aperture ( )

Definiert in Zeile 668 der Datei shooting.c.

short shooting_get_real_focus_mode ( )

Definiert in Zeile 150 der Datei shooting.c.

151 {
152  short f = shooting_get_focus_mode();
154  if (f==0 && m!=0) f=(m==1)?4:m;
155  return f;
156 }
short shooting_get_resolution ( )

Definiert in Zeile 88 der Datei shooting.c.

float shooting_get_shutter_speed_from_tv96 ( short  tv96)

Definiert in Zeile 487 der Datei shooting.c.

488 {
489  return pow(2,((float)(-tv96))/96.0);
490 }
int shooting_get_subject_distance ( )

Definiert in Zeile 1134 der Datei shooting.c.

1135 {
1138 }
int shooting_get_subject_distance_ ( )
int shooting_get_subject_distance_override_value ( )
short shooting_get_sv96_delta ( )

Definiert in Zeile 253 der Datei shooting.c.

short shooting_get_sv96_from_iso ( short  iso)

Definiert in Zeile 277 der Datei shooting.c.

278 {
279  // Equivalent to (short)(log2(iso/3.125)*96+0.5) [APEX equation]
280  if (iso > 0)
281  return (short)( log((double)(iso)*32.0/100.0)*96.0*(inv_log_2)+0.5 );
282  return 0;
283 }
short shooting_get_sv96_market ( )

Definiert in Zeile 251 der Datei shooting.c.

short shooting_get_sv96_real ( )

Definiert in Zeile 252 der Datei shooting.c.

252 { return shooting_get_prop(PROPCASE_SV); }
short shooting_get_tv96 ( )

Definiert in Zeile 471 der Datei shooting.c.

471 { return shooting_get_prop(PROPCASE_TV); }
short shooting_get_tv96_from_shutter_speed ( float  t)

Definiert in Zeile 475 der Datei shooting.c.

476 {
477  if (t > 0)
478  {
479  t = ((96.0 * -log(t)) * inv_log_2);
480  if (t < 0)
481  return (short)(t - 0.5);
482  return (short)(t + 0.5);
483  }
484  return SHOOTING_TV96_INVALID;
485 }
static int shooting_get_tv96_override_value ( )
static

Definiert in Zeile 500 der Datei shooting.c.

501 {
502  // Calculate the tv96 value for the tv override
507  else
509 }
short shooting_get_user_av96 ( )

Definiert in Zeile 743 der Datei shooting.c.

744 {
745 #if CAM_HAS_IRIS_DIAPHRAGM
747 #else
748  return 0;
749 #endif
750 }
int shooting_get_user_av_id ( )

Definiert in Zeile 752 der Datei shooting.c.

753 {
754 #if CAM_HAS_IRIS_DIAPHRAGM
755  return aperture_sizes_table[find_nearest_aperture_entry(shooting_get_user_av96())].prop_id;
756 #else
757  return 0;
758 #endif
759 }
short shooting_get_user_tv96 ( )

Definiert in Zeile 564 der Datei shooting.c.

565 {
566 #if CAM_HAS_USER_TV_MODES
568 #else
569  return 0;
570 #endif
571 }
int shooting_get_user_tv_id ( )

Definiert in Zeile 573 der Datei shooting.c.

574 {
575 #if CAM_HAS_USER_TV_MODES
577 #else
578  return 0;
579 #endif
580 }
int shooting_get_zoom ( )

Definiert in Zeile 186 der Datei shooting.c.

187 {
188  return lens_get_zoom_point();
189 }
int shooting_in_progress ( )

Definiert in Zeile 93 der Datei shooting.c.

void shooting_init ( )

Definiert in Zeile 885 der Datei shooting.c.

886 {
888  iso_init();
889 }
int shooting_is_flash ( )

Definiert in Zeile 92 der Datei shooting.c.

int shooting_is_flash_ready ( )

Definiert in Zeile 1185 der Datei shooting.c.

1186 {
1187  int t = shooting_get_flash_mode();
1188  if ((t != 2) && (shooting_in_progress()))
1189  if (shooting_is_flash())
1190  return IsStrobeChargeCompleted();
1191  return 1;
1192 }
short shooting_is_infinity_distance ( )

Definiert in Zeile 1027 der Datei shooting.c.

1028 {
1029  return (shooting_get_lens_to_focal_plane_width() == 0)?1:0;
1030 }
static void shooting_iso_bracketing ( int  when)
static

Definiert in Zeile 1406 der Datei shooting.c.

1407 {
1408  // first shot? (actually this is called just after the first shot has been taken)
1409  if (bracketing.shoot_counter == 0)
1410  {
1413  }
1414 
1415  // Adjust delta ISO value for shot based on shot number
1417  // Calculate new ISO (higher ISO = brighter image)
1419  if (value <= 0) value = 50;
1420 
1421  // Inc for next shot
1423 
1424  // Apply value for next shot to be taken
1425  shooting_set_iso_real(value, when);
1426 }
short shooting_iso_market_to_real ( short  isom)

Definiert in Zeile 291 der Datei shooting.c.

292 {
293  return ISO_MARKET_TO_REAL(isom);
294 }
short shooting_iso_real_to_market ( short  isor)

Definiert in Zeile 296 der Datei shooting.c.

297 {
298  return ISO_REAL_TO_MARKET(isor);
299 }
int shooting_mode_canon2chdk ( int  canonmode)

Definiert in Zeile 958 der Datei shooting.c.

959 {
960  int i;
961  for (i=0; i < MODESCNT; i++)
962  {
963  if (modemap[i].canonmode == canonmode)
964  return modemap[i].hackmode;
965  }
966  return 0;
967 }
int shooting_mode_chdk2canon ( int  hackmode)

Definiert in Zeile 969 der Datei shooting.c.

970 {
971  int i;
972  for (i=0; i < MODESCNT; i++)
973  {
974  if (modemap[i].hackmode == hackmode)
975  return modemap[i].canonmode;
976  }
977  return -1; // 0 is a valid mode on old cameras!
978 }
void shooting_set_av96 ( short  av96,
short  is_now 
)

Definiert in Zeile 733 der Datei shooting.c.

734 {
735 #if CAM_HAS_IRIS_DIAPHRAGM
737  shooting_set_av96_direct(find_canon_aperture(av96), is_now);
738 #endif
739 }
void shooting_set_av96_direct ( short  av96,
short  is_now 
)

Definiert in Zeile 715 der Datei shooting.c.

716 {
717 #if CAM_HAS_IRIS_DIAPHRAGM
719  {
720  if(is_now)
721  {
722  set_property_case(PROPCASE_AV, &av96, sizeof(av96));
723 #ifdef PROPCASE_AV2
724  set_property_case(PROPCASE_AV2, &av96, sizeof(av96)); // Save override to property that will update JPEG header & Canon OSD
725 #endif
726  }
727  else
728  photo_param_put_off.av96 = av96;
729  }
730 #endif
731 }
static void shooting_set_flash_override ( )
static

Definiert in Zeile 1712 der Datei shooting.c.

1713 {
1714  int mode, flash, power;
1715  flash = 1;
1716 
1717  // Set flash mode & override
1719  {
1721  {
1722  mode = 1; // Manual flash
1724  set_property_case(PROPCASE_FLASH_ADJUST_MODE, &mode, sizeof(mode));
1725  set_property_case(PROPCASE_FLASH_FIRE, &flash, sizeof(flash));
1726  set_property_case(PROPCASE_FLASH_MANUAL_OUTPUT, &power, sizeof(power));
1727  }
1728  else if (conf.flash_enable_exp_comp)
1729  {
1730  mode = 0; // Auto flash
1731  power = (conf.flash_exp_comp - 9) * 32;
1732  set_property_case(PROPCASE_FLASH_ADJUST_MODE, &mode, sizeof(mode));
1733  set_property_case(PROPCASE_FLASH_FIRE, &flash, sizeof(flash));
1734 #if defined(PROPCASE_FLASH_EXP_COMP)
1735  set_property_case(PROPCASE_FLASH_EXP_COMP, &power, sizeof(power));
1736 #endif
1737 #if defined(PROPCASE_EXT_FLASH_EXP_COMP)
1738  set_property_case(PROPCASE_EXT_FLASH_EXP_COMP, &power, sizeof(power));
1739 #endif
1740  }
1741  }
1742 }
void shooting_set_focus ( int  v,
short  is_now 
)

Definiert in Zeile 1242 der Datei shooting.c.

1243 {
1244  int s=v;
1246  {
1247  if (is_now && shooting_can_focus())
1248  {
1250  {
1252  }
1253  if (!conf.dof_use_exif_subj_dist && (s != INFINITY_DIST))
1255  lens_set_focus_pos(s);
1256  }
1257  else
1259  }
1260 }
void shooting_set_iso_mode ( int  v)

Definiert in Zeile 368 der Datei shooting.c.

369 {
370  int i;
371  if (v < 50) // CHDK ID
372  {
373  for (i=0; i<ISO_SIZE; i++)
374  {
375  if (iso_table[i].id == v)
376  {
377  set_iso_mode(i);
378  return;
379  }
380  }
381  }
382  else // ISO value - find nearest entry in iso_table and set iso mode to that value
383  {
384  if (v <= iso_table[0].prop_id) // In case no AUTO (0) entry
385  {
386  set_iso_mode(0);
387  return;
388  }
389  for (i=0; i<ISO_SIZE-1; i++)
390  {
391  if ((v > iso_table[i].prop_id) && (v <= iso_table[i+1].prop_id))
392  {
393  if ((v - iso_table[i].prop_id) < (iso_table[i+1].prop_id - v))
394  set_iso_mode(i);
395  else
396  set_iso_mode(i+1);
397  return;
398  }
399  }
400  set_iso_mode(ISO_SIZE-1);
401  }
402 }
void shooting_set_iso_real ( short  iso,
short  is_now 
)

Definiert in Zeile 427 der Datei shooting.c.

428 {
430  {
431  if (iso > 0)
432  {
433 #ifdef CAM_ISO_LIMIT_IN_HQ_BURST
434  // Limit max ISO in HQ burst mode
437 #endif
438 #ifdef CAM_MIN_ISO_OVERRIDE
439  // Limit min (non-zero) ISO
441 #endif
442 #ifdef CAM_MAX_ISO_OVERRIDE
443  // Limit max ISO
445 #endif
447  }
448  }
449 }
int shooting_set_mode_canon ( int  canonmode)

Definiert in Zeile 1307 der Datei shooting.c.

1308 {
1309  if (canonmode == -1 || !rec_mode_active())
1310  return 0;
1311  SetCurrentCaptureModeType(canonmode);
1312  // updated cached mode information immediately
1313  mode_get();
1314  return 1;
1315 }
int shooting_set_mode_chdk ( int  mode)

Definiert in Zeile 1317 der Datei shooting.c.

1318 {
1320 }
void shooting_set_nd_filter_state ( short  v,
short  is_now 
)

Definiert in Zeile 811 der Datei shooting.c.

812 {
813 #if CAM_HAS_ND_FILTER
815  {
816  if (is_now)
817  {
818 #if defined(CAM_ND_SET_AV_VALUE)
819  short av;
820  get_property_case(PROPCASE_MIN_AV,&av,sizeof(av));
821  if(v==1) {
823  }
824  set_property_case(PROPCASE_AV, &av, sizeof(av));
825 #if defined(PROPCASE_AV2)
826  set_property_case(PROPCASE_AV2, &av, sizeof(av));
827 #endif
828 #endif
829  if (v==1) {
830  PutInNdFilter();
831  }
832  else if (v==2)
833  PutOutNdFilter();
834 #if defined(CAM_HAS_NATIVE_ND_FILTER) && defined(PROPCASE_ND_FILTER_STATE)
835  int n = (v==1) ? 1 : 0;
837 #endif
838  }
839  else
841  }
842 #endif
843 }
void shooting_set_playrec_mode ( int  mode)

Definiert in Zeile 1840 der Datei shooting.c.

1841 {
1842  // use PTP compatible switch if usb bit power detected, and USB remote not configured to use USB
1843  // TODO should just check the USB bit seen by canon firmware (after masking)
1845  {
1847  return;
1848  }
1849  if(mode)
1851  else
1852  levent_set_play();
1853 }
void shooting_set_prop ( int  id,
int  v 
)

Definiert in Zeile 74 der Datei shooting.c.

75 {
76  short vv = v;
77  set_property_case(id, &vv, sizeof(vv));
78  return;
79 }
void shooting_set_sv96 ( short  sv96,
short  is_now 
)

Definiert in Zeile 404 der Datei shooting.c.

405 {
407  {
408  if (is_now)
409  {
410  while ((shooting_is_flash_ready()!=1) || (focus_busy)) msleep(10);
411 
412  short iso_mode = shooting_get_canon_iso_mode();
413  if (iso_mode >= 50)
414  shooting_set_iso_mode(0); // Force AUTO mode on camera
415 
416  short dsv96 = sv96 + SV96_MARKET_OFFSET - canon_sv96_base;
417 
418  set_property_case(PROPCASE_SV_MARKET, &canon_sv96_base, sizeof(canon_sv96_base));
419  set_property_case(PROPCASE_SV, &sv96, sizeof(sv96));
420  set_property_case(PROPCASE_DELTA_SV, &dsv96, sizeof(dsv96));
421  }
422  else
423  photo_param_put_off.sv96 = sv96;
424  }
425 }
void shooting_set_tv96 ( short  tv96,
short  is_now 
)

Definiert in Zeile 556 der Datei shooting.c.

557 {
560 }
void shooting_set_tv96_direct ( short  tv96,
short  is_now 
)

Definiert in Zeile 540 der Datei shooting.c.

541 {
543  {
544  if(is_now)
545  {
546  set_property_case(PROPCASE_TV, &tv96, sizeof(tv96));
547 #ifdef PROPCASE_TV2
548  set_property_case(PROPCASE_TV2, &tv96, sizeof(tv96)); // Save override to property that will update JPEG header & Canon OSD
549 #endif
550  }
551  else
552  photo_param_put_off.tv96 = tv96;
553  }
554 }
void shooting_set_user_av96 ( short  av96)

Definiert in Zeile 791 der Datei shooting.c.

792 {
793 #if CAM_HAS_IRIS_DIAPHRAGM
795  {
796  av96 = find_canon_aperture(av96);
797  set_property_case(PROPCASE_USER_AV, &av96, sizeof(av96));
798  }
799 #endif
800 }
void shooting_set_user_av_by_id ( int  v)

Definiert in Zeile 761 der Datei shooting.c.

762 {
763 #if CAM_HAS_IRIS_DIAPHRAGM
764  long i;
766  {
767  for (i=0;i<AS_SIZE;i++)
768  {
769  if (aperture_sizes_table[i].id == v)
770  {
771  short vv = aperture_sizes_table[i].prop_id;
772  set_property_case(PROPCASE_USER_AV, &vv, sizeof(vv));
773  return;
774  }
775  }
776  }
777 #endif
778 }
void shooting_set_user_av_by_id_rel ( int  v)

Definiert in Zeile 780 der Datei shooting.c.

781 {
782 #if CAM_HAS_IRIS_DIAPHRAGM
784  {
785  int cv = shooting_get_user_av_id();
787  }
788 #endif
789 }
void shooting_set_user_tv96 ( short  tv96)

Definiert in Zeile 612 der Datei shooting.c.

613 {
614 #if CAM_HAS_USER_TV_MODES
616  {
617  tv96 = find_canon_shutter_speed(tv96);
618  set_property_case(PROPCASE_USER_TV, &tv96, sizeof(tv96));
619  }
620 #endif
621 }
void shooting_set_user_tv_by_id ( int  v)

Definiert in Zeile 582 der Datei shooting.c.

583 {
584 #if CAM_HAS_USER_TV_MODES
586  {
587  long i;
588  for (i=0;i<SS_SIZE;i++)
589  {
590  if (shutter_speeds_table[i].id == v)
591  {
592  short vv = shutter_speeds_table[i].prop_id;
593  set_property_case(PROPCASE_USER_TV, &vv, sizeof(vv));
594  return;
595  }
596  }
597  }
598 #endif
599 }
void shooting_set_user_tv_by_id_rel ( int  v)

Definiert in Zeile 601 der Datei shooting.c.

602 {
603 #if CAM_HAS_USER_TV_MODES
605  {
606  int cv = shooting_get_user_tv_id();
608  }
609 #endif
610 }
void shooting_set_zoom ( int  v)

Definiert in Zeile 1207 der Datei shooting.c.

1208 {
1209  int dist;
1211  {
1214 #if defined(CAM_NEED_SET_ZOOM_DELAY)
1216 #endif
1217  shooting_set_focus(dist, SET_NOW);
1218  }
1219 }
void shooting_set_zoom_rel ( int  v)

Definiert in Zeile 1221 der Datei shooting.c.

1222 {
1223  int cv = shooting_get_zoom();
1225  {
1226  shooting_set_zoom(cv+v);
1227  }
1228 }
void shooting_set_zoom_speed ( int  v)

Definiert in Zeile 1230 der Datei shooting.c.

1230  {
1232  {
1234  }
1235 }
static void shooting_subject_distance_bracketing ( int  when)
static

Definiert in Zeile 1428 der Datei shooting.c.

1429 {
1430  // first shot? (actually this is called just after the first shot has been taken)
1431  if (bracketing.shoot_counter == 0)
1432  {
1435  }
1436 
1437  // Adjust delta SD value for shot based on shot number
1439  // Calculate new SD
1441  if (value < CAMERA_MIN_DIST) value = CAMERA_MIN_DIST;
1442  else if (value > CAMERA_MAX_DIST) value = CAMERA_MAX_DIST;
1443 
1444  // Inc for next shot
1446 
1447  // Apply value for next shot to be taken
1448  shooting_set_focus(value, when);
1449 }
short shooting_sv96_market_to_real ( short  sv96)

Definiert in Zeile 301 der Datei shooting.c.

302 {
303  return sv96 - SV96_MARKET_OFFSET;
304 }
short shooting_sv96_real_to_market ( short  sv96)

Definiert in Zeile 306 der Datei shooting.c.

307 {
308  return sv96 + SV96_MARKET_OFFSET;
309 }
static void shooting_tv_bracketing ( int  when)
static

Definiert in Zeile 1341 der Datei shooting.c.

1342 {
1343  // first shot? (actually this is called just after the first shot has been taken)
1344  if (bracketing.shoot_counter == 0)
1345  {
1346  // if Tv override is enabled... (this was adapted from function shooting_expo_param_override() )
1348  {
1349  // ...use Tv override value as seed for bracketing:
1351  }
1352  // Tv override is disabled, use camera's opinion of Tv for bracketing seed value.
1353  else
1354  {
1357  else
1359  }
1361  }
1362 
1363  // Adjust delta TV value for shot based on shot number
1365  // Calculate new TV (note, need to subtract delta because higher values are shorter shutter speeds / darker images)
1367 
1368  // Inc for next shot
1370 
1371  // Apply value for next shot to be taken
1372  shooting_set_tv96_direct(value, when);
1373 }
void shooting_update_dof_values ( )

Definiert in Zeile 1048 der Datei shooting.c.

1049 {
1050  int hyp, hyp_1e3, av_1e3, v;
1051  int dist = shooting_get_subject_distance_();
1052  int zoom_point = lens_get_zoom_point();
1053  int fl = get_focal_length(zoom_point);
1054  short f_focus_ok = shooting_get_focus_ok();
1055  short f_hyp_calc = 0, f_dist_calc = 0;
1056  short min_av96_zoom_point = min_av96_zoom_point_tbl[zoom_point];
1057  short av96 = shooting_get_user_av96();
1058  short curr_av96 = shooting_get_current_av96();
1059  short prop_av96 = shooting_get_av96();
1060  short min_av96;
1061 
1062  if (!min_av96_zoom_point_tbl) {
1063  min_av96_zoom_point_tbl = (short *) malloc(zoom_points * sizeof(short));
1065  memset(min_av96_zoom_point_tbl, 0, zoom_points * sizeof(short));
1066  min_av96_zoom_point = 0;
1067  }
1068  } else min_av96_zoom_point = min_av96_zoom_point_tbl[zoom_point];
1069 
1070  if (min_av96_zoom_point==0 && shooting_in_progress()) {
1071  get_property_case(PROPCASE_MIN_AV, &min_av96, sizeof(min_av96));
1072  min_av96_zoom_point_tbl[zoom_point] = min_av96;
1073  }
1074 
1075  if ((camera_info.state.mode_shooting==MODE_M || camera_info.state.mode_shooting==MODE_AV) && (av96>0) && !f_focus_ok) {
1076  if (av96 < min_av96_zoom_point) av96 = min_av96_zoom_point;
1077  }
1078  else av96 = (abs(curr_av96-prop_av96)<2)?prop_av96:curr_av96;
1079 
1080  av_1e3 = shooting_get_aperture_from_av96(av96);
1083 
1084  if (camera_info.dof_values.aperture_value!=av_1e3 || camera_info.dof_values.focal_length!=fl || (hyp_1e3<0)) {
1085  //calc new hyperfocal distance and min stack distance
1086  f_hyp_calc = 1;
1087  hyp_1e3 = -1;
1088  hyp = -1;
1091  hyp_1e3 = shooting_get_hyperfocal_distance_1e3_f(av_1e3, fl);
1092  if (hyp_1e3>0) {
1093  hyp = (hyp_1e3+500)/1000;
1095  v = ((hyp_1e3 - fl)/250 + 2 + 1)/2;
1096  if (v>0) {
1097  int m = ((fl*((fl - hyp_1e3)/1000 - 1)/500)/v + 1)/2;
1098  int m2 = (int)((((double)hyp*(2*fl - hyp_1e3)/1000))/v + 0.5);
1100  }
1101  }
1102  }
1103 
1104  if ((camera_info.dof_values.subject_distance!=dist || (camera_info.dof_values.hyperfocal_distance_1e3!=hyp_1e3)) && (hyp_1e3>0)) {
1105  //calc new NEAR, FAR, DOF values
1106  f_dist_calc = 1;
1111  if ((av_1e3>0) && (fl>0) && (dist>0) && (shooting_is_infinity_distance()==0) && (hyp_1e3>0)) {
1112  double m = ((double)(hyp_1e3 - fl)/1000 * dist) + 0.5;
1115  } else {
1116  int v = ((((hyp_1e3 - 2*fl + 1000*dist)/500) + 1)/2);
1117  if (v>0) camera_info.dof_values.near_limit = (int)(m/v);
1118  }
1119  int v = ((((hyp_1e3 - 1000*dist)/500) + 1)/2);
1120  if (v>0) camera_info.dof_values.far_limit = (int)(m/v);
1123  }
1124  }
1125  }
1128  f_focus_ok = (f_focus_ok && shooting_get_focus_ok());
1131  return;
1132 }
void shooting_video_bitrate_change ( int  v)

Definiert in Zeile 1262 der Datei shooting.c.

1263 {
1264 #if CAM_CHDK_HAS_EXT_VIDEO_MENU
1265  int m[]={1,2,3,4,5,6,7,8,10,12}; // m[v]/4 = bitrate*1x
1266  if (v>=(sizeof(m)/sizeof(m[0])))
1267  v=(sizeof(m)/sizeof(m[0]))-1;
1268  change_video_tables(m[v],4);
1269 #endif
1270 }
void unlock_optical_zoom ( void  )

Definiert in Zeile 1294 der Datei shooting.c.

1295 {
1296 #if CAM_CAN_UNLOCK_OPTICAL_ZOOM_IN_VIDEO
1297  extern void UnsetZoomForMovie();
1299  UnsetZoomForMovie();
1300 #endif
1301 
1302 #if CAM_EV_IN_VIDEO
1303  set_ev_video_avail(0);
1304 #endif
1305 }

Variablen-Dokumentation

const ApertureSize aperture_sizes_table[]

pt=require'extras/proptools'

Definiert in Zeile 9 der Datei shooting.c.

const unsigned int AS_SIZE

Definiert in Zeile 18 der Datei shooting.c.

int bracket_delta[4][2]
static
Initialisierung:
= {
{ 1, 0 },
{ 1, 1 },
{ 1, 1 },
{ 1, 0 },
}

Definiert in Zeile 1334 der Datei shooting.c.

int bracket_steps[4][2]
static
Initialisierung:
= {
{ 1, -1 },
{ -1, -1 },
{ 1, 1 },
{ -1, 1 },
}

Definiert in Zeile 1328 der Datei shooting.c.

Definiert in Zeile 1325 der Datei shooting.c.

short canon_iso_base =0
static

Definiert in Zeile 256 der Datei shooting.c.

short canon_sv96_base =0
static

Definiert in Zeile 257 der Datei shooting.c.

volatile long focus_busy
int focus_interlock_bypass = 0
static

Definiert in Zeile 1146 der Datei shooting.c.

const double inv_log_2 = 1.44269504088906
static

Definiert in Zeile 55 der Datei shooting.c.

const unsigned int ISO_SIZE

Definiert in Zeile 19 der Datei shooting.c.

const ISOTable iso_table[]

Definiert in Zeile 71 der Datei shooting.c.

const double K = 12.5
static

Definiert in Zeile 935 der Datei shooting.c.

short* min_av96_zoom_point_tbl = NULL
static

Definiert in Zeile 36 der Datei shooting.c.

const CapturemodeMap modemap[]

Definiert in Zeile 82 der Datei shooting.c.

const unsigned int MODESCNT

Definiert in Zeile 20 der Datei shooting.c.

int movie_status

Definiert in Zeile 72 der Datei lib.c.

const unsigned int param_file_counter

Definiert in Zeile 23 der Datei shooting.c.

PHOTO_PARAM photo_param_put_off
static

Definiert in Zeile 49 der Datei shooting.c.

long playrec_mode
const ShutterSpeed shutter_speeds_table[]

Definiert in Zeile 22 der Datei shooting.c.

const unsigned int SS_SIZE

Definiert in Zeile 17 der Datei shooting.c.