CHDK_DE Vorschauversion  Trunk Rev. 5456
 Alle Datenstrukturen Dateien Funktionen Variablen Typdefinitionen Aufzählungen Aufzählungswerte Makrodefinitionen
shooting.h-Dateireferenz
+ Dieser Graph zeigt, welche Datei direkt oder indirekt diese Datei enthält:

gehe zum Quellcode dieser Datei

Datenstrukturen

struct  ISOTable
 
struct  ShutterSpeed
 
struct  ApertureSize
 
struct  EXPO_BRACKETING_VALUES
 

Makrodefinitionen

#define SET_NOW   1
 
#define SET_LATER   0
 
#define SHOOTING_TV96_INVALID   -10000
 
#define INFINITY_DIST   0xFFFFFFFF
 
#define VIDEO_RECORD_NEVER_STARTED   0
 
#define VIDEO_RECORD_STOPPED   1
 
#define VIDEO_RECORD_IN_PROGRESS   4
 
#define VIDEO_RECORD_STOPPING   5
 
#define ZOOM_OPTICAL_MIN   1
 
#define ZOOM_OPTICAL_MAX   2
 
#define ZOOM_OPTICAL_MEDIUM   3
 

Funktionen

void shooting_init ()
 
int shooting_in_progress ()
 
int shooting_is_flash ()
 
int shooting_is_flash_ready ()
 
short shooting_get_flash_mode ()
 
int shooting_get_user_tv_id ()
 
short shooting_get_tv96 ()
 
short shooting_get_tv96_from_shutter_speed (float t)
 
void shooting_set_tv96 (short tv96, short is_now)
 
void shooting_set_tv96_direct (short tv96, short is_now)
 
short shooting_get_user_tv96 ()
 
void shooting_set_user_tv96 (short tv96)
 
float shooting_get_shutter_speed_from_tv96 (short tv96)
 
void shooting_set_user_tv_by_id (int v)
 
void shooting_set_user_tv_by_id_rel (int v)
 
short shooting_get_aperture_sizes_table_size ()
 
int shooting_get_aperture_from_av96 (short av96)
 
short shooting_get_av96_from_aperture (int aperture)
 
int shooting_get_user_av_id ()
 
void shooting_set_user_av_by_id (int v)
 
short shooting_get_av96 ()
 
short shooting_get_min_av96 ()
 
short shooting_get_max_av96 ()
 
void shooting_set_av96 (short av96, short is_now)
 
void shooting_set_av96_direct (short av96, short is_now)
 
short shooting_get_user_av96 ()
 
void shooting_set_user_av96 (short av96)
 
void shooting_set_user_av_by_id_rel (int v)
 
int shooting_get_real_aperture ()
 
short shooting_get_av96_override_value ()
 
void shooting_set_nd_filter_state (short v, short is_now)
 
short shooting_get_nd_value_ev96 (void)
 
short shooting_get_nd_current_ev96 (void)
 
short shooting_get_is_mode ()
 
short shooting_get_resolution ()
 
short shooting_get_display_mode ()
 
int shooting_get_canon_raw_enabled ()
 
int shooting_get_zoom ()
 
void shooting_set_zoom (int v)
 
void shooting_set_zoom_rel (int v)
 
void shooting_set_zoom_speed (int v)
 
int shooting_get_digital_zoom_mode (void)
 
int shooting_get_digital_zoom_state (void)
 
void shooting_set_focus (int v, short is_now)
 
short shooting_get_focus_mode ()
 
short shooting_get_real_focus_mode ()
 
short shooting_get_focus_state ()
 
short shooting_get_focus_ok ()
 
void shooting_update_dof_values ()
 
int shooting_get_hyperfocal_distance ()
 
int shooting_get_hyperfocal_distance_1e3_f (int av, int fl)
 
int shooting_get_exif_subject_dist ()
 
int shooting_get_subject_distance ()
 
int shooting_get_subject_distance_override_value ()
 
int shooting_get_lens_to_focal_plane_width ()
 
short shooting_get_drive_mode ()
 
short shooting_can_focus ()
 
short shooting_get_common_focus_mode ()
 
short shooting_is_infinity_distance ()
 
void set_focus_bypass (int)
 
int shooting_get_iso_mode ()
 
void shooting_set_iso_mode (int v)
 
short shooting_get_sv96_real ()
 
short shooting_get_sv96_market ()
 
short shooting_get_iso_market ()
 
short shooting_get_iso_real ()
 
void shooting_set_iso_real (short iso, short is_now)
 
void shooting_set_sv96 (short sv96, short is_now)
 
short shooting_get_iso_override_value ()
 
short shooting_iso_market_to_real (short isom)
 
short shooting_iso_real_to_market (short isor)
 
short shooting_sv96_market_to_real (short isom)
 
short shooting_sv96_real_to_market (short isor)
 
short shooting_get_sv96_from_iso (short iso)
 
short shooting_get_iso_from_sv96 (short sv96)
 
short shooting_get_canon_overexposure_value ()
 
short shooting_get_bv96 ()
 
int shooting_get_luminance ()
 
short shooting_get_ev_correction1 ()
 
short shooting_get_ev_correction2 ()
 
void shooting_expo_param_override ()
 
void shooting_bracketing (void)
 
void DoAELock (void)
 
void UnlockAE (void)
 
int EngDrvRead (int gpio_reg)
 
void PutInNdFilter ()
 
void PutOutNdFilter ()
 
long shooting_get_current_av96 ()
 
long shooting_get_current_tv96 ()
 
long IsStrobeChargeCompleted ()
 
void SetCurrentCaptureModeType ()
 
int shooting_get_imager_active ()
 
int get_ev_video_avail (void)
 
void set_ev_video_avail (int)
 
int get_ev_video (void)
 
void set_ev_video (int)
 
int shooting_mode_canon2chdk (int canonmode)
 
int shooting_mode_chdk2canon (int hackmode)
 
int shooting_set_mode_chdk (int mode)
 
int shooting_set_mode_canon (int mode)
 
void shooting_set_playrec_mode (int mode)
 
int get_focal_length (int zp)
 
int get_effective_focal_length (int zp)
 
int get_zoom_x (int zp)
 
int is_video_recording ()
 
void set_movie_status (int status)
 
int get_movie_status ()
 
void change_video_tables (int a, int b)
 
void shooting_video_bitrate_change (int v)
 
void shooting_video_minbitrate_change (int)
 
unsigned int shooting_get_video_recorded_size_kb ()
 
void change_video_minbitrate (int, int)
 
unsigned int get_video_recorded_size_kb ()
 

Variablen

int zoom_status
 
const int zoom_points
 
int recreview_hold
 

Makro-Dokumentation

#define INFINITY_DIST   0xFFFFFFFF

Definiert in Zeile 213 der Datei shooting.h.

#define SET_LATER   0

Definiert in Zeile 16 der Datei shooting.h.

#define SET_NOW   1

Definiert in Zeile 15 der Datei shooting.h.

#define SHOOTING_TV96_INVALID   -10000

Definiert in Zeile 70 der Datei shooting.h.

#define VIDEO_RECORD_IN_PROGRESS   4

Definiert in Zeile 225 der Datei shooting.h.

#define VIDEO_RECORD_NEVER_STARTED   0

Definiert in Zeile 223 der Datei shooting.h.

#define VIDEO_RECORD_STOPPED   1

Definiert in Zeile 224 der Datei shooting.h.

#define VIDEO_RECORD_STOPPING   5

Definiert in Zeile 226 der Datei shooting.h.

#define ZOOM_OPTICAL_MAX   2

Definiert in Zeile 230 der Datei shooting.h.

#define ZOOM_OPTICAL_MEDIUM   3

Definiert in Zeile 231 der Datei shooting.h.

#define ZOOM_OPTICAL_MIN   1

Definiert in Zeile 229 der Datei shooting.h.

Dokumentation der Funktionen

void change_video_minbitrate ( int  ,
int   
)
void change_video_tables ( int  a,
int  b 
)

Definiert in Zeile 14 der Datei movie_rec.c.

14  {
15  int i;
16  for (i=0;i<24;i++) table[i]=(def_table[i]*a)/b;
17 }
void DoAELock ( void  )

Definiert in Zeile 1207 der Datei wrappers.c.

1208 {
1210  {
1211  _DoAELock();
1212  }
1213 }
int EngDrvRead ( int  gpio_reg)

Definiert in Zeile 1243 der Datei wrappers.c.

1244 {
1245  return _EngDrvRead(gpio_reg);
1246 }
int get_effective_focal_length ( int  zp)

Definiert in Zeile 45 der Datei main.c.

45  {
47 }
int get_ev_video ( void  )
int get_ev_video_avail ( void  )
int get_focal_length ( int  zp)

Definiert in Zeile 49 der Datei main.c.

49  {
50  if (zp < 0) zp = 0;
51  else if (zp >= NUM_FL) zp = NUM_FL-1;
52  return focus_len_table[zp*NUM_DATA];
53 }
int get_movie_status ( )

Definiert in Zeile 1601 der Datei shooting.c.

1602 {
1603 #ifndef CAM_SIMPLE_MOVIE_STATUS
1604  return movie_status;
1605 #else
1606  // firmware movie_status interpreted as: zero - not recording, nonzero - recording
1607  return simple_movie_status?VIDEO_RECORD_IN_PROGRESS:VIDEO_RECORD_STOPPED;
1608 #endif
1609 }
unsigned int get_video_recorded_size_kb ( )
int get_zoom_x ( int  zp)

Definiert in Zeile 55 der Datei main.c.

55  {
56  return get_focal_length(zp)*10/focus_len_table[0];
57 }
int is_video_recording ( )

Definiert in Zeile 1612 der Datei shooting.c.

1613 {
1614 #ifndef CAM_SIMPLE_MOVIE_STATUS
1615 #if defined(CAM_HAS_MOVIE_DIGEST_MODE)
1616  // If camera has movie digest mode then movie_status values are different than previous models
1617  // 'movie_status' values
1618  // 0 - after startup
1619  // 1 - movie recording stopped
1620  // 4 - movie recording in progress, or in 'movie digest' scene mode
1621  // 5 - movie recording stopping
1622  // 6 - in video mode, not recording
1624 #else
1625  // 'movie_status' values
1626  // 0 - after startup
1627  // 1 - movie recording stopped
1628  // 4 - movie recording in progress
1629  // 5 - movie recording stopping
1630  return (movie_status > 1);
1631 #endif
1632 #else // CAM_SIMPLE_MOVIE_STATUS
1633  return (simple_movie_status!=0);
1634 #endif
1635 }
long IsStrobeChargeCompleted ( )

Definiert in Zeile 389 der Datei wrappers.c.

389 { return _IsStrobeChargeCompleted(); }
void PutInNdFilter ( )
void PutOutNdFilter ( )
void set_ev_video ( int  )
void set_ev_video_avail ( int  )

Definiert in Zeile 143 der Datei kbd.c.

144 {
145  if (video_ael == x) return;
146  video_ael = x;
147  if (x)
148  {
149  av_video = tv_video = 0;
150 
152 
156 
158  else tv_min_video=441; //480; //1/30
159  }
160  else
162 }
void set_focus_bypass ( int  )

Definiert in Zeile 1294 der Datei shooting.c.

1295 {
1297 }
void set_movie_status ( int  status)

Definiert in Zeile 1572 der Datei shooting.c.

1573 {
1574 #ifndef CAM_SIMPLE_MOVIE_STATUS
1575  switch(status)
1576  {
1577  case 1:
1579  {
1581  }
1582  break;
1583  case 2:
1585  {
1587  }
1588  break;
1589  case 3:
1591  {
1593  }
1594  break;
1595  }
1596 #else // CAM_SIMPLE_MOVIE_STATUS
1597  // no known way to control the recording process
1598 #endif
1599 }
void SetCurrentCaptureModeType ( )

Definiert in Zeile 390 der Datei wrappers.c.

void shooting_bracketing ( void  )

Definiert in Zeile 1523 der Datei shooting.c.

short shooting_can_focus ( )

Definiert in Zeile 1202 der Datei shooting.c.

1203 {
1204  if(camera_info.state.mode_play) return 0 ; // don't focus in playback mode
1205 
1206  if(focus_interlock_bypass) return 1; // checks disabled, allow
1207 
1208  if( camera_info.state.mode_video == 1) return 1; // FIXME : default to MF enabled in video mode for now
1209 
1210 #ifdef CAM_SD_OVER_IN_AFL
1211  if (shooting_get_prop(PROPCASE_AF_LOCK)==1 ) return 1; // allow focus if AFL enabled and camera can focus that way?
1212 #endif
1213 #ifdef CAM_SD_OVER_IN_MF
1214  if (shooting_get_prop(PROPCASE_FOCUS_MODE)==1 ) return 1; // allow focus if MF enabled and camera can focus that way?
1215 #endif
1216 
1217 #ifdef CAM_SD_OVER_IN_AF
1218 #ifdef PROPCASE_CONTINUOUS_AF
1219  if (shooting_get_prop(PROPCASE_CONTINUOUS_AF)) return 0; // don't focus in continuous AF mode,
1220 #endif
1221 #ifdef PROPCASE_SERVO_AF
1222  if (shooting_get_prop(PROPCASE_SERVO_AF)) return 0; // don't focus in servo AF mode
1223 #endif
1224  if ( (shooting_get_prop(PROPCASE_AF_LOCK)==0) // allow focus when in AF mode (i.e AFL or MF not enabled)?
1225  && (shooting_get_prop(PROPCASE_FOCUS_MODE)==0 )) return 1;
1226 #endif
1227  return 0;
1228 }
void shooting_expo_param_override ( )
int shooting_get_aperture_from_av96 ( short  av96)

Definiert in Zeile 695 der Datei shooting.c.

696 {
697  if (av96)
698  return (short)((pow(2, ((double)av96)/192.0))*1000.0 + 0.5);
699  return -1;
700 }
short shooting_get_aperture_sizes_table_size ( )

Definiert in Zeile 691 der Datei shooting.c.

691 { return AS_SIZE; }
short shooting_get_av96 ( )

Definiert in Zeile 690 der Datei shooting.c.

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

Definiert in Zeile 702 der Datei shooting.c.

703 {
704  return (int)((log((double)aperture/1000.0) * 192 * inv_log_2) + 0.5);
705 }
short shooting_get_av96_override_value ( )

Definiert in Zeile 708 der Datei shooting.c.

709 {
712  return (short) (AV96_MAX+32*(conf.av_override_value-AS_SIZE+1));
713 }
short shooting_get_bv96 ( )

Definiert in Zeile 125 der Datei shooting.c.

125 { return shooting_get_prop(PROPCASE_BV); }
short shooting_get_canon_overexposure_value ( )

Definiert in Zeile 126 der Datei shooting.c.

int shooting_get_canon_raw_enabled ( )

Definiert in Zeile 139 der Datei shooting.c.

139  {
140 #ifdef CAM_HAS_CANON_RAW
141 #ifdef PROPCASE_IMAGE_FORMAT
142  return (shooting_get_prop(PROPCASE_IMAGE_FORMAT) != 1); // 0 = raw, 2 = raw+jpeg
143 #else
144  return (shooting_get_prop(PROPCASE_RESOLUTION) == 5); // resolution 5 = raw, jpeg controlled with another prop
145 #endif
146 #else
147  return 0;
148 #endif
149 }
short shooting_get_common_focus_mode ( )

Definiert in Zeile 1230 der Datei shooting.c.

1231 {
1232 #if !CAM_HAS_MANUAL_FOCUS
1233  return conf.subj_dist_override_koef; // SD override state 0=OFF, 1=ON, 2=Infinity if camera has no native MF mode
1234 #else
1235  return shooting_get_focus_mode(); // 0=Auto, 1=manual
1236 #endif
1237 }
long shooting_get_current_av96 ( )

Definiert in Zeile 387 der Datei wrappers.c.

387 { return _GetCurrentAvValue(); }
long shooting_get_current_tv96 ( )

Definiert in Zeile 379 der Datei wrappers.c.

380 {
381  // old cameras crash if _GetCurrentShutterSpeed called when inactive
383  return SHOOTING_TV96_INVALID;
384  }
385  return _GetCurrentShutterSpeed();
386 }
int shooting_get_digital_zoom_mode ( void  )
int shooting_get_digital_zoom_state ( void  )

Definiert in Zeile 172 der Datei shooting.c.

173 {
174 #if CAM_PROPSET == 7 || CAM_PROPSET == 9 || CAM_PROPSET == 10 || CAM_PROPSET == 11 || CAM_PROPSET == 12
175  // PS7 doesn't have _STATE, combines values
177  if(x==1) {
178  return 1;
179  }
180  return 0;
181 #else
183 #endif
184 }
short shooting_get_display_mode ( )

Definiert in Zeile 132 der Datei shooting.c.

short shooting_get_drive_mode ( )

Definiert in Zeile 213 der Datei shooting.c.

214 {
215  // these cameras do not set PROPCASE_DRIVE_MODE when in custom timer mode
216  // SX 200 IS 0,1,2,3,4=Off, 2 Second, Custom, Face Detection
217 #if defined (CAM_DRIVE_MODE_FROM_TIMER_MODE)
219  // note we return this only in custom mode.
220  // Other cameras would return 3 if any timer mode is set (?) even if it doesn't do multiple exposures
221  // note that face detect does multiple exposure
222  if (m == 3)
223  return m;
224 #endif
225 
227 }
short shooting_get_ev_correction1 ( )

Definiert in Zeile 129 der Datei shooting.c.

short shooting_get_ev_correction2 ( )

Definiert in Zeile 130 der Datei shooting.c.

int shooting_get_exif_subject_dist ( )

Definiert in Zeile 134 der Datei shooting.c.

short shooting_get_flash_mode ( )

Definiert in Zeile 127 der Datei shooting.c.

short shooting_get_focus_mode ( )

Definiert in Zeile 128 der Datei shooting.c.

short shooting_get_focus_ok ( )

Definiert in Zeile 208 der Datei shooting.c.

209 {
210  return ((shooting_get_focus_state()!=0) && shooting_in_progress());
211 }
short shooting_get_focus_state ( )

Definiert in Zeile 201 der Datei shooting.c.

202 {
203  if (shooting_get_focus_mode()==1) return -1;
205  return (short) m;
206 }
int shooting_get_hyperfocal_distance ( )

Definiert in Zeile 1194 der Datei shooting.c.

1195 {
1198 }
int shooting_get_hyperfocal_distance_1e3_f ( int  av,
int  fl 
)

Definiert in Zeile 1047 der Datei shooting.c.

1048 {
1049  if ((av>0) && (fl>0) && (camera_info.circle_of_confusion>0))
1050  return (int)(((((double)fl*fl)/(av*camera_info.circle_of_confusion)*1000)+fl)+0.5);
1051  else return (-1);
1052 }
int shooting_get_imager_active ( )

Definiert in Zeile 151 der Datei shooting.c.

151  {
152  extern int imager_active;
153  return imager_active;
154 }
short shooting_get_is_mode ( )

Definiert in Zeile 124 der Datei shooting.c.

short shooting_get_iso_from_sv96 ( short  sv96)

Definiert in Zeile 328 der Datei shooting.c.

329 {
330  // APEX equation --> (int)(POWER(2,(iso/96)) * 3.125) + 0.5)
331  return (short)( (double)pow(2, (((double)sv96)/96.0))*100.0/32.0 + 0.5 );
332 }
short shooting_get_iso_market ( )

Definiert in Zeile 397 der Datei shooting.c.

398 {
400  if (sv == 0)
401  return 0;
402  return shooting_get_iso_from_sv96(sv);
403 }
int shooting_get_iso_mode ( )

Definiert in Zeile 376 der Datei shooting.c.

377 {
378  short isov = shooting_get_canon_iso_mode();
379  long i;
380  for (i=0;i<ISO_SIZE;i++)
381  {
382  if (iso_table[i].prop_id == isov)
383  return iso_table[i].id;
384  }
385  return 0;
386 }
short shooting_get_iso_override_value ( )

Definiert in Zeile 354 der Datei shooting.c.

355 {
356  short iso = conf.iso_override_value; // Start with market value
357  // Apply limits if needed
358 #ifdef CAM_ISO_LIMIT_IN_HQ_BURST
359  // Limit max ISO in HQ burst mode (also done in shooting_set_iso_real; but done here so OSD display value is correct)
362 #endif
363 #ifdef CAM_MIN_ISO_OVERRIDE
364  // Limit min (non-zero) ISO
365  // Some cameras will crash if flash used and ISO set lower than this value (most easily tested in AUTO mode)
366  if ((iso > 0) && (iso < CAM_MIN_ISO_OVERRIDE)) iso = CAM_MIN_ISO_OVERRIDE;
367 #endif
368 #ifdef CAM_MAX_ISO_OVERRIDE
369  // Limit max ISO
370  // Some cameras will crash if ISO set higher than this value (dependence on flash is unclear)
372 #endif
373  return shooting_iso_market_to_real(iso); // return real value (after limits applied)
374 }
short shooting_get_iso_real ( )

Definiert in Zeile 388 der Datei shooting.c.

389 {
390  short sv = shooting_get_sv96_real();
391  if (sv == 0)
392  return 0;
393  return shooting_get_iso_from_sv96(sv);
394 }
int shooting_get_lens_to_focal_plane_width ( )

Definiert in Zeile 1042 der Datei shooting.c.

1043 {
1045 }
int shooting_get_luminance ( )

Definiert in Zeile 984 der Datei shooting.c.

985 {
986  short bv = shooting_get_bv96();
987  int b = (int)(100 * K * pow(2.0,((double)(bv-168)/96.0)));
988  return b;
989 }
short shooting_get_max_av96 ( )

Definiert in Zeile 911 der Datei shooting.c.

912 {
913 #if CAM_HAS_IRIS_DIAPHRAGM
914  extern short GetUsableMinAv(void);
916  {
917  return -1;
918  }
919  return GetUsableMinAv();
920 #else
921  return -1;
922 #endif
923 }
short shooting_get_min_av96 ( )

Definiert in Zeile 897 der Datei shooting.c.

898 {
899 #if CAM_HAS_IRIS_DIAPHRAGM
900  extern short GetUsableMaxAv(void);
902  {
903  return -1;
904  }
905  return GetUsableMaxAv();
906 #else
907  return -1;
908 #endif
909 }
short shooting_get_nd_current_ev96 ( void  )

Definiert in Zeile 370 der Datei wrappers.c.

371 {
372 #if CAM_HAS_ND_FILTER
373  return _get_current_nd_value();
374 #else
375  return 0;
376 #endif
377 }
short shooting_get_nd_value_ev96 ( void  )

Definiert in Zeile 361 der Datei wrappers.c.

362 {
363 #if CAM_HAS_ND_FILTER
364  return _get_nd_value();
365 #else
366  return 0;
367 #endif
368 }
int shooting_get_real_aperture ( )

Definiert in Zeile 715 der Datei shooting.c.

short shooting_get_real_focus_mode ( )

Definiert in Zeile 193 der Datei shooting.c.

194 {
195  short f = shooting_get_focus_mode();
197  if (f==0 && m!=0) f=(m==1)?4:m;
198  return f;
199 }
short shooting_get_resolution ( )

Definiert in Zeile 131 der Datei shooting.c.

float shooting_get_shutter_speed_from_tv96 ( short  tv96)

Definiert in Zeile 534 der Datei shooting.c.

535 {
536  return pow(2,((float)(-tv96))/96.0);
537 }
int shooting_get_subject_distance ( )

Definiert in Zeile 1188 der Datei shooting.c.

1189 {
1192 }
int shooting_get_subject_distance_override_value ( )
short shooting_get_sv96_from_iso ( short  iso)

Definiert in Zeile 320 der Datei shooting.c.

321 {
322  // Equivalent to (short)(log2(iso/3.125)*96+0.5) [APEX equation]
323  if (iso > 0)
324  return (short)( log((double)(iso)*32.0/100.0)*96.0*(inv_log_2)+0.5 );
325  return 0;
326 }
short shooting_get_sv96_market ( )

Definiert in Zeile 294 der Datei shooting.c.

short shooting_get_sv96_real ( )

Definiert in Zeile 295 der Datei shooting.c.

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

Definiert in Zeile 518 der Datei shooting.c.

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

Definiert in Zeile 522 der Datei shooting.c.

523 {
524  if (t > 0)
525  {
526  t = ((96.0 * -log(t)) * inv_log_2);
527  if (t < 0)
528  return (short)(t - 0.5);
529  return (short)(t + 0.5);
530  }
531  return SHOOTING_TV96_INVALID;
532 }
short shooting_get_user_av96 ( )

Definiert in Zeile 790 der Datei shooting.c.

791 {
792 #if CAM_HAS_IRIS_DIAPHRAGM
794 #else
795  return 0;
796 #endif
797 }
int shooting_get_user_av_id ( )

Definiert in Zeile 799 der Datei shooting.c.

800 {
801 #if CAM_HAS_IRIS_DIAPHRAGM
802  return aperture_sizes_table[find_nearest_aperture_entry(shooting_get_user_av96())].prop_id;
803 #else
804  return 0;
805 #endif
806 }
short shooting_get_user_tv96 ( )

Definiert in Zeile 611 der Datei shooting.c.

612 {
613 #if CAM_HAS_USER_TV_MODES
615 #else
616  return 0;
617 #endif
618 }
int shooting_get_user_tv_id ( )

Definiert in Zeile 620 der Datei shooting.c.

621 {
622 #if CAM_HAS_USER_TV_MODES
624 #else
625  return 0;
626 #endif
627 }
unsigned int shooting_get_video_recorded_size_kb ( )
int shooting_get_zoom ( )

Definiert in Zeile 229 der Datei shooting.c.

230 {
231  return lens_get_zoom_point();
232 }
int shooting_in_progress ( )

Definiert in Zeile 136 der Datei shooting.c.

void shooting_init ( )

Definiert in Zeile 932 der Datei shooting.c.

933 {
935  iso_init();
936 }
int shooting_is_flash ( )

Definiert in Zeile 135 der Datei shooting.c.

int shooting_is_flash_ready ( )

Definiert in Zeile 1239 der Datei shooting.c.

1240 {
1241  int t = shooting_get_flash_mode();
1242  if ((t != 2) && (shooting_in_progress()))
1243  if (shooting_is_flash())
1244  return IsStrobeChargeCompleted();
1245  return 1;
1246 }
short shooting_is_infinity_distance ( )

Definiert in Zeile 1074 der Datei shooting.c.

1075 {
1076  return (shooting_get_lens_to_focal_plane_width() == 0)?1:0;
1077 }
short shooting_iso_market_to_real ( short  isom)

Definiert in Zeile 334 der Datei shooting.c.

335 {
336  return ISO_MARKET_TO_REAL(isom);
337 }
short shooting_iso_real_to_market ( short  isor)

Definiert in Zeile 339 der Datei shooting.c.

340 {
341  return ISO_REAL_TO_MARKET(isor);
342 }
int shooting_mode_canon2chdk ( int  canonmode)

Definiert in Zeile 1005 der Datei shooting.c.

1006 {
1007  int i;
1008  for (i=0; i < MODESCNT; i++)
1009  {
1010  if (modemap[i].canonmode == canonmode)
1011  return modemap[i].hackmode;
1012  }
1013  return 0;
1014 }
int shooting_mode_chdk2canon ( int  hackmode)

Definiert in Zeile 1016 der Datei shooting.c.

1017 {
1018  int i;
1019  for (i=0; i < MODESCNT; i++)
1020  {
1021  if (modemap[i].hackmode == hackmode)
1022  return modemap[i].canonmode;
1023  }
1024  return -1; // 0 is a valid mode on old cameras!
1025 }
void shooting_set_av96 ( short  av96,
short  is_now 
)

Definiert in Zeile 780 der Datei shooting.c.

781 {
782 #if CAM_HAS_IRIS_DIAPHRAGM
784  shooting_set_av96_direct(find_canon_aperture(av96), is_now);
785 #endif
786 }
void shooting_set_av96_direct ( short  av96,
short  is_now 
)

Definiert in Zeile 762 der Datei shooting.c.

763 {
764 #if CAM_HAS_IRIS_DIAPHRAGM
766  {
767  if(is_now)
768  {
769  set_property_case(PROPCASE_AV, &av96, sizeof(av96));
770 #ifdef PROPCASE_AV2
771  set_property_case(PROPCASE_AV2, &av96, sizeof(av96)); // Save override to property that will update JPEG header & Canon OSD
772 #endif
773  }
774  else
775  photo_param_put_off.av96 = av96;
776  }
777 #endif
778 }
void shooting_set_focus ( int  v,
short  is_now 
)

Definiert in Zeile 1299 der Datei shooting.c.

1300 {
1301  int s=v;
1303  {
1304  if (is_now && shooting_can_focus())
1305  {
1307  {
1309  }
1310  if (!conf.dof_use_exif_subj_dist && (s != INFINITY_DIST))
1312  lens_set_focus_pos(s);
1313  }
1314  else
1316  }
1317 }
void shooting_set_iso_mode ( int  v)

Definiert in Zeile 411 der Datei shooting.c.

412 {
413  int i;
414  if (v < 50) // CHDK ID
415  {
416  for (i=0; i<ISO_SIZE; i++)
417  {
418  if (iso_table[i].id == v)
419  {
420  set_iso_mode(i);
421  return;
422  }
423  }
424  }
425  else // ISO value - find nearest entry in iso_table and set iso mode to that value
426  {
427  if (v <= iso_table[0].prop_id) // In case no AUTO (0) entry
428  {
429  set_iso_mode(0);
430  return;
431  }
432  for (i=0; i<ISO_SIZE-1; i++)
433  {
434  if ((v > iso_table[i].prop_id) && (v <= iso_table[i+1].prop_id))
435  {
436  if ((v - iso_table[i].prop_id) < (iso_table[i+1].prop_id - v))
437  set_iso_mode(i);
438  else
439  set_iso_mode(i+1);
440  return;
441  }
442  }
443  set_iso_mode(ISO_SIZE-1);
444  }
445 }
void shooting_set_iso_real ( short  iso,
short  is_now 
)

Definiert in Zeile 474 der Datei shooting.c.

475 {
477  {
478  if (iso > 0)
479  {
480 #ifdef CAM_ISO_LIMIT_IN_HQ_BURST
481  // Limit max ISO in HQ burst mode
484 #endif
485 #ifdef CAM_MIN_ISO_OVERRIDE
486  // Limit min (non-zero) ISO
488 #endif
489 #ifdef CAM_MAX_ISO_OVERRIDE
490  // Limit max ISO
492 #endif
494  }
495  }
496 }
int shooting_set_mode_canon ( int  mode)

Definiert in Zeile 1364 der Datei shooting.c.

1365 {
1366  if (canonmode == -1 || !rec_mode_active())
1367  return 0;
1368  SetCurrentCaptureModeType(canonmode);
1369  // updated cached mode information immediately
1370  mode_get();
1371  return 1;
1372 }
int shooting_set_mode_chdk ( int  mode)

Definiert in Zeile 1374 der Datei shooting.c.

1375 {
1377 }
void shooting_set_nd_filter_state ( short  v,
short  is_now 
)

Definiert in Zeile 858 der Datei shooting.c.

859 {
860 #if CAM_HAS_ND_FILTER
862  {
863  if (is_now)
864  {
865 #if defined(CAM_ND_SET_AV_VALUE)
866  short av;
867  get_property_case(PROPCASE_MIN_AV,&av,sizeof(av));
868  if(v==1) {
870  }
871  set_property_case(PROPCASE_AV, &av, sizeof(av));
872 #if defined(PROPCASE_AV2)
873  set_property_case(PROPCASE_AV2, &av, sizeof(av));
874 #endif
875 #endif
876  if (v==1) {
877  PutInNdFilter();
878  }
879  else if (v==2)
880  PutOutNdFilter();
881 #if defined(CAM_HAS_NATIVE_ND_FILTER) && defined(PROPCASE_ND_FILTER_STATE)
882  int n = (v==1) ? 1 : 0;
884 #endif
885  }
886  else
888  }
889 #endif
890 }
void shooting_set_playrec_mode ( int  mode)

Definiert in Zeile 1892 der Datei shooting.c.

1893 {
1894  // use PTP compatible switch if usb bit power detected, and USB remote not configured to use USB
1895  // TODO should just check the USB bit seen by canon firmware (after masking)
1897  {
1899  return;
1900  }
1901  if(mode)
1903  else
1904  levent_set_play();
1905 }
void shooting_set_sv96 ( short  sv96,
short  is_now 
)

Definiert in Zeile 447 der Datei shooting.c.

448 {
450  {
451  if (is_now)
452  {
453  while ((shooting_is_flash_ready()!=1) || (focus_busy)) msleep(10);
454 
455  short iso_mode = shooting_get_canon_iso_mode();
456  if (iso_mode >= 50) {
457  // save current ISO mode, to avoid leaving in auto after override done
458  // only needed for non-auto
459  iso_override_mode_save = iso_mode;
460  shooting_set_iso_mode(0); // Force AUTO mode on camera
461  }
462 
463  short dsv96 = sv96 + SV96_MARKET_OFFSET - canon_sv96_base;
464 
465  set_property_case(PROPCASE_SV_MARKET, &canon_sv96_base, sizeof(canon_sv96_base));
466  set_property_case(PROPCASE_SV, &sv96, sizeof(sv96));
467  set_property_case(PROPCASE_DELTA_SV, &dsv96, sizeof(dsv96));
468  }
469  else
470  photo_param_put_off.sv96 = sv96;
471  }
472 }
void shooting_set_tv96 ( short  tv96,
short  is_now 
)

Definiert in Zeile 603 der Datei shooting.c.

604 {
607 }
void shooting_set_tv96_direct ( short  tv96,
short  is_now 
)

Definiert in Zeile 587 der Datei shooting.c.

588 {
590  {
591  if(is_now)
592  {
593  set_property_case(PROPCASE_TV, &tv96, sizeof(tv96));
594 #ifdef PROPCASE_TV2
595  set_property_case(PROPCASE_TV2, &tv96, sizeof(tv96)); // Save override to property that will update JPEG header & Canon OSD
596 #endif
597  }
598  else
599  photo_param_put_off.tv96 = tv96;
600  }
601 }
void shooting_set_user_av96 ( short  av96)

Definiert in Zeile 838 der Datei shooting.c.

839 {
840 #if CAM_HAS_IRIS_DIAPHRAGM
842  {
843  av96 = find_canon_aperture(av96);
844  set_property_case(PROPCASE_USER_AV, &av96, sizeof(av96));
845  }
846 #endif
847 }
void shooting_set_user_av_by_id ( int  v)

Definiert in Zeile 808 der Datei shooting.c.

809 {
810 #if CAM_HAS_IRIS_DIAPHRAGM
811  long i;
813  {
814  for (i=0;i<AS_SIZE;i++)
815  {
816  if (aperture_sizes_table[i].id == v)
817  {
818  short vv = aperture_sizes_table[i].prop_id;
819  set_property_case(PROPCASE_USER_AV, &vv, sizeof(vv));
820  return;
821  }
822  }
823  }
824 #endif
825 }
void shooting_set_user_av_by_id_rel ( int  v)

Definiert in Zeile 827 der Datei shooting.c.

828 {
829 #if CAM_HAS_IRIS_DIAPHRAGM
831  {
832  int cv = shooting_get_user_av_id();
834  }
835 #endif
836 }
void shooting_set_user_tv96 ( short  tv96)

Definiert in Zeile 659 der Datei shooting.c.

660 {
661 #if CAM_HAS_USER_TV_MODES
663  {
664  tv96 = find_canon_shutter_speed(tv96);
665  set_property_case(PROPCASE_USER_TV, &tv96, sizeof(tv96));
666  }
667 #endif
668 }
void shooting_set_user_tv_by_id ( int  v)

Definiert in Zeile 629 der Datei shooting.c.

630 {
631 #if CAM_HAS_USER_TV_MODES
633  {
634  long i;
635  for (i=0;i<SS_SIZE;i++)
636  {
637  if (shutter_speeds_table[i].id == v)
638  {
639  short vv = shutter_speeds_table[i].prop_id;
640  set_property_case(PROPCASE_USER_TV, &vv, sizeof(vv));
641  return;
642  }
643  }
644  }
645 #endif
646 }
void shooting_set_user_tv_by_id_rel ( int  v)

Definiert in Zeile 648 der Datei shooting.c.

649 {
650 #if CAM_HAS_USER_TV_MODES
652  {
653  int cv = shooting_get_user_tv_id();
655  }
656 #endif
657 }
void shooting_set_zoom ( int  v)

Definiert in Zeile 1261 der Datei shooting.c.

1262 {
1264  {
1265 #if CAM_REFOCUS_AFTER_ZOOM
1266  int dist = shooting_get_subject_distance();
1268 #if defined(CAM_NEED_SET_ZOOM_DELAY)
1270 #endif
1271  shooting_set_focus(dist, SET_NOW);
1272 #else // CAM_REFOCUS_AFTER_ZOOM
1274 #endif // CAM_REFOCUS_AFTER_ZOOM
1275  }
1276 }
void shooting_set_zoom_rel ( int  v)

Definiert in Zeile 1278 der Datei shooting.c.

1279 {
1280  int cv = shooting_get_zoom();
1282  {
1283  shooting_set_zoom(cv+v);
1284  }
1285 }
void shooting_set_zoom_speed ( int  v)

Definiert in Zeile 1287 der Datei shooting.c.

1287  {
1289  {
1291  }
1292 }
short shooting_sv96_market_to_real ( short  isom)

Definiert in Zeile 344 der Datei shooting.c.

345 {
346  return sv96 - SV96_MARKET_OFFSET;
347 }
short shooting_sv96_real_to_market ( short  isor)

Definiert in Zeile 349 der Datei shooting.c.

350 {
351  return sv96 + SV96_MARKET_OFFSET;
352 }
void shooting_update_dof_values ( )

Definiert in Zeile 1095 der Datei shooting.c.

1096 {
1097  int hyp, hyp_1e3, av_1e3, v;
1098  int dist = shooting_get_subject_distance_();
1099  int zoom_point = lens_get_zoom_point();
1100  int fl = get_focal_length(zoom_point);
1101  short f_focus_ok = shooting_get_focus_ok();
1102  short f_hyp_calc = 0, f_dist_calc = 0;
1103  short min_av96_zoom_point = 0;
1104  short av96 = shooting_get_user_av96();
1105  short curr_av96 = shooting_get_current_av96();
1106  short prop_av96 = shooting_get_av96();
1107  short min_av96;
1108 
1109  if (!min_av96_zoom_point_tbl) {
1110  min_av96_zoom_point_tbl = (short *) malloc(zoom_points * sizeof(short));
1112  memset(min_av96_zoom_point_tbl, 0, zoom_points * sizeof(short));
1113  }
1114  else {
1115  return;
1116  }
1117  } else min_av96_zoom_point = min_av96_zoom_point_tbl[zoom_point];
1118 
1119  if (min_av96_zoom_point==0 && shooting_in_progress()) {
1120  get_property_case(PROPCASE_MIN_AV, &min_av96, sizeof(min_av96));
1121  min_av96_zoom_point_tbl[zoom_point] = min_av96;
1122  }
1123 
1124  if ((camera_info.state.mode_shooting==MODE_M || camera_info.state.mode_shooting==MODE_AV) && (av96>0) && !f_focus_ok) {
1125  if (av96 < min_av96_zoom_point) av96 = min_av96_zoom_point;
1126  }
1127  else av96 = (abs(curr_av96-prop_av96)<2)?prop_av96:curr_av96;
1128 
1129  av_1e3 = shooting_get_aperture_from_av96(av96);
1132 
1133  if (camera_info.dof_values.aperture_value!=av_1e3 || camera_info.dof_values.focal_length!=fl || (hyp_1e3<0)) {
1134  //calc new hyperfocal distance and min stack distance
1135  f_hyp_calc = 1;
1136  hyp_1e3 = -1;
1137  hyp = -1;
1140  hyp_1e3 = shooting_get_hyperfocal_distance_1e3_f(av_1e3, fl);
1141  if (hyp_1e3>0) {
1142  hyp = (hyp_1e3+500)/1000;
1144  v = ((hyp_1e3 - fl)/250 + 2 + 1)/2;
1145  if (v>0) {
1146  int m = ((fl*((fl - hyp_1e3)/1000 - 1)/500)/v + 1)/2;
1147  int m2 = (int)((((double)hyp*(2*fl - hyp_1e3)/1000))/v + 0.5);
1149  }
1150  }
1151  }
1152 
1153  if ((camera_info.dof_values.subject_distance!=dist || (camera_info.dof_values.hyperfocal_distance_1e3!=hyp_1e3)) && (hyp_1e3>0)) {
1154  //calc new NEAR, FAR, DOF values
1155  f_dist_calc = 1;
1160  if ((av_1e3>0) && (fl>0) && (dist>0) && (shooting_is_infinity_distance()==0) && (hyp_1e3>0)) {
1161  double m = ((double)(hyp_1e3 - fl)/1000 * dist) + 0.5;
1164  } else {
1165  int v = ((((hyp_1e3 - 2*fl + 1000*dist)/500) + 1)/2);
1166  if (v>0) camera_info.dof_values.near_limit = (int)(m/v);
1167  }
1168  int v = ((((hyp_1e3 - 1000*dist)/500) + 1)/2);
1169  if (v>0) camera_info.dof_values.far_limit = (int)(m/v);
1172  }
1173  }
1174  // if at infinity then set near to hyperfocal value
1175  // note focus beyond infinity is not distinguished from infinity
1178  }
1179  }
1182  f_focus_ok = (f_focus_ok && shooting_get_focus_ok());
1185  return;
1186 }
void shooting_video_bitrate_change ( int  v)

Definiert in Zeile 1319 der Datei shooting.c.

1320 {
1321 #if CAM_CHDK_HAS_EXT_VIDEO_MENU
1322  int m[]={1,2,3,4,5,6,7,8,10,12}; // m[v]/4 = bitrate*1x
1323  if (v>=(sizeof(m)/sizeof(m[0])))
1324  v=(sizeof(m)/sizeof(m[0]))-1;
1325  change_video_tables(m[v],4);
1326 #endif
1327 }
void shooting_video_minbitrate_change ( int  )
void UnlockAE ( void  )

Definiert in Zeile 1215 der Datei wrappers.c.

1216 {
1218  {
1219  _UnlockAE();
1220  }
1221 }

Variablen-Dokumentation

int recreview_hold
const int zoom_points

Definiert in Zeile 43 der Datei main.c.

int zoom_status