root/modules/luascript.c

DEFINITIONS

1. chdk_luai_numdiv
2. chdk_luai_nummod
3. lua_script_disable_yield_hook
4. lua_script_enable_yield_hook
5. lua_create_usb_msg
6. lua_script_reset
7. lua_script_error_ptp
8. lua_count_hook
9. lua_script_error
10. lua_script_finish
11. lua_script_start
12. lua_script_start_file
13. lua_script_run
14. lua_run_restore
15. lua_get_key_arg
16. on_off_value_from_lua_arg
17. luaCB_set_curve_state
18. luaCB_get_curve_state
19. luaCB_set_curve_file
20. luaCB_get_curve_file
21. luaCB_set_aelock
22. luaCB_set_aflock
23. luaCB_set_mf
24. luaCB_get_sd_over_modes
25. luaCB_shoot
26. action_stack_AS_LUA_SLEEP
27. sleep_delay
28. luaCB_sleep
29. luaCB_keyfunc
30. luaCB_cls
31. luaCB_set_console_layout
32. luaCB_set_console_autoredraw
33. luaCB_console_redraw
34. luaCB_get_partitionInfo
35. luaCB_swap_partitions
36. luaCB_get_av96
37. luaCB_get_bv96
38. luaCB_get_day_seconds
39. luaCB_get_disk_size
40. luaCB_get_dofinfo
41. luaCB_get_free_disk_space
42. luaCB_get_focus
43. luaCB_get_iso_market
44. luaCB_get_iso_mode
45. luaCB_get_iso_real
46. luaCB_get_jpg_count
47. luaCB_get_prop
48. luaCB_get_prop_str
49. luaCB_get_raw_support
50. luaCB_get_raw_count
51. luaCB_get_sv96
52. luaCB_get_tick_count
53. luaCB_get_exp_count
54. luaCB_get_image_dir
55. luaCB_get_tv96
56. luaCB_get_user_av_id
57. luaCB_get_user_av96
58. luaCB_get_min_av96
59. luaCB_get_max_av96
60. luaCB_get_current_av96
61. luaCB_get_current_tv96
62. luaCB_get_nd_value_ev96
63. luaCB_get_nd_current_ev96
64. luaCB_get_imager_active
65. luaCB_get_canon_image_format
66. luaCB_get_canon_raw_support
67. luaCB_get_user_tv_id
68. luaCB_get_user_tv96
69. luaCB_get_vbatt
70. luaCB_get_zoom
71. luaCB_get_parameter_data
72. luaCB_get_flash_params_count
73. luaCB_set_av96_direct
74. luaCB_set_av96
75. luaCB_set_canon_image_format
76. luaCB_set_focus_interlock_bypass
77. luaCB_set_focus
78. luaCB_set_iso_mode
79. luaCB_set_iso_real
80. luaCB_set_led
81. luaCB_set_nd_filter
82. luaCB_set_prop
83. luaCB_set_prop_str
84. luaCB_set_raw_nr
85. luaCB_get_raw_nr
86. luaCB_set_raw
87. luaCB_get_raw
88. luaCB_set_sv96
89. luaCB_set_tv96_direct
90. luaCB_set_tv96
91. luaCB_set_user_av_by_id_rel
92. luaCB_set_user_av_by_id
93. luaCB_set_user_av96
94. luaCB_set_user_tv_by_id_rel
95. luaCB_set_user_tv_by_id
96. luaCB_set_user_tv96
97. luaCB_set_zoom_speed
98. luaCB_set_zoom_rel
99. luaCB_set_zoom
100. action_stack_AS_LUA_WAIT_CLICK
101. luaCB_wait_click
102. luaCB_is_pressed
103. luaCB_is_key
104. luaCB_set_exit_key
105. luaCB_wheel_right
106. luaCB_wheel_left
107. luaCB_md_af_led_control
108. luaCB_md_get_cell_diff
109. luaCB_md_get_cell_val
110. luaCB_md_detect_motion
111. return_string_selected
112. action_stack_AS_WAIT_MODULE
113. luaCB_file_browser
114. luaCB_textbox
115. luaCB_draw_pixel
116. luaCB_draw_line
117. luaCB_draw_rect
118. luaCB_draw_rect_filled
119. luaCB_draw_ellipse
120. luaCB_draw_ellipse_filled
121. luaCB_draw_string
122. luaCB_draw_clear
123. luaCB_get_gui_screen_width
124. luaCB_get_gui_screen_height
125. luaCB_autostarted
126. luaCB_get_autostart
127. luaCB_set_autostart
128. luaCB_get_usb_power
129. luaCB_set_remote_timing
130. luaCB_usb_force_active
131. luaCB_usb_sync_wait
132. luaCB_enter_alt
133. luaCB_exit_alt
134. luaCB_get_alt_mode
135. luaCB_shut_down
136. luaCB_print_screen
137. luaCB_get_movie_status
138. luaCB_set_movie_status
139. luaCB_get_video_button
140. luaCB_get_video_recording
141. luaCB_get_drive_mode
142. luaCB_get_focus_mode
143. luaCB_get_focus_state
144. luaCB_get_focus_ok
145. luaCB_get_flash_mode
146. luaCB_get_shooting
147. luaCB_get_flash_ready
148. luaCB_get_IS_mode
149. luaCB_get_orientation_sensor
150. luaCB_get_zoom_steps
151. luaCB_get_nd_present
152. luaCB_get_propset
153. luaCB_get_ev
154. luaCB_set_ev
155. luaCB_get_histo_range
156. luaCB_shot_histo_enable
157. luaCB_shot_histo_write_to_file
158. luaCB_get_live_histo
159. luaCB_play_sound
160. luaCB_get_temperature
161. luaCB_get_time
162. luaCB_set_clock
163. luaCB_peek
164. luaCB_poke
165. luaCB_bitand
166. luaCB_bitor
167. luaCB_bitxor
168. luaCB_bitshl
169. luaCB_bitshri
170. luaCB_bitshru
171. luaCB_bitnot
172. set_string_field
173. set_number_field
174. luaCB_get_buildinfo
175. luaCB_get_mode
176. luaCB_set_raw_develop
177. luaCB_raw_merge_start
178. luaCB_raw_merge_add_file
179. luaCB_raw_merge_end
180. luaCB_set_backlight
181. luaCB_set_lcd_display
182. luaCB_set_draw_title_line
183. luaCB_get_draw_title_line
184. levent_id_from_lua_arg
185. levent_index_from_id_lua_arg
186. luaCB_get_levent_def
187. luaCB_get_levent_index
188. luaCB_get_levent_def_by_index
189. luaCB_post_levent_to_ui
190. luaCB_post_levent_for_npt
191. luaCB_set_levent_active
192. luaCB_set_levent_script_mode
193. luaCB_set_capture_mode_canon
194. luaCB_set_capture_mode
195. luaCB_is_capture_mode_valid
196. luaCB_set_record
197. luaCB_switch_mode_usb
198. luaCB_force_analog_av
199. pack_native_args
200. luaCB_call_func_ptr
201. luaCB_call_event_proc
202. luaCB_reboot
203. luaCB_get_config_value
204. luaCB_set_config_value
205. luaCB_set_config_autosave
206. luaCB_save_config_file
207. luaCB_load_config_file
208. luaCB_set_file_attributes
209. action_stack_AS_SCRIPT_READ_USB_MSG
210. action_stack_AS_SCRIPT_WRITE_USB_MSG
211. luaCB_read_usb_msg
212. luaCB_write_usb_msg
213. set_meminfo_num
214. luaCB_get_meminfo
215. luaCB_set_yield
216. luaCB_get_usb_capture_support
217. luaCB_init_usb_capture
218. luaCB_get_usb_capture_target
219. luaCB_set_usb_capture_timeout
220. luaCB_iso_to_sv96
221. luaCB_sv96_to_iso
222. luaCB_iso_real_to_market
223. luaCB_iso_market_to_real
224. luaCB_sv96_real_to_market
225. luaCB_sv96_market_to_real
226. luaCB_aperture_to_av96
227. luaCB_av96_to_aperture
228. luaCB_usec_to_tv96
229. luaCB_tv96_to_usec
230. luaCB_seconds_to_tv96
231. luaCB_shoot_hook_set
232. luaCB_shoot_hook_is_ready
233. luaCB_shoot_hook_continue
234. luaCB_shoot_hook_count
235. register_shoot_hook_fn
236. register_shoot_hooks
237. register_lua_funcs
238. lua_set_variable
239. lua_set_as_ret

   1 #include "camera_info.h"
   2 #include "gui.h"
   3 #include "gui_draw.h"
   4 #include "script.h"
   5 #include "script_key_funcs.h"
   6 #include "conf.h"
   7 #include "shot_histogram.h"
   8 #include "raw.h"
   9 #include "levent.h"
  10 #include "console.h"
  11 #include "action_stack.h"
  12 #include "ptp_chdk.h"
  13 #include "lang.h"
  14 #include "gui_lang.h"
  15 #include "histogram.h"
  16 #include "shooting.h"
  17 #include "autoiso.h"
  18 #include "remotecap.h"
  19 #include "battery.h"
  20 #include "temperature.h"
  21 #include "backlight.h"
  22 #include "keyboard.h"
  23 #include "shutdown.h"
  24 #include "sound.h"
  25 #include "modes.h"
  26 #include "sd_card.h"
  27 #include "clock.h"
  28 #include "lens.h"
  29 #include "properties.h"
  30 #include "file_counter.h"
  31 #include "debug_led.h"
  32 #include "meminfo.h"
  33 #include "callfunc.h"
  34 #include "usb_remote.h"
  35 #include "time.h"
  37 #include "script_api.h"
  38 #include "curves.h"
  39 #include "motion_detector.h"
  40 #include "raw_merge.h"
  41 #include "gui_fselect.h"
  42 #include "gui_tbox.h"
  43 #include "module_def.h"
  44 #include "luascript.h"
  45 #include "script_shoot_hook.h"
  46 #include "rawhookops.h"
  48 #include "lualib.h"
  49 #include "lauxlib.h"
  50 #include "lstate.h"  // for L->nCcalls, baseCcalls
  52 #ifdef THUMB_FW
  53 // provide div and mod behavior similar to preivous CPUs for digic 6, instead of triggering exception handler
  54 // used in lua core, see luaconf.h
  55 int chdk_luai_numdiv(int a, int b) {
  56     if(!a) {
  57        return 0;
  58     }
  59     if(b) {
  60         return a/b;
  61     }
  62     if(a>0) {
  63         return 0x7FFFFFFF;
  64     } else {
  65         return 0x80000000;
  66     }
  67 }
  68 int chdk_luai_nummod(int a, int b) {
  69     if(!b) {
  70        return 0;
  71     }
  72     return a%b;
  73 }
  74 #endif
lua_State* L;
lua_State* Lt;
  79 extern void register_lua_funcs( lua_State* L );
  81 static int lua_script_is_ptp;
  82 static int ptp_saved_alt_state;
  83 static int run_first_resume; // 1 first 'resume', 0 = resuming from yield
  84 static int run_start_tick; // tick count at start of this kbd_task iteration
  85 static unsigned run_hook_count; // number of calls to the count hook this kbd_task iteration
  86 #define YIELD_CHECK_COUNT 100 // check for yield every N vm instructions
  87 #define YIELD_MAX_COUNT_DEFAULT 25 // 25 checks = 2500 vm instructions
  88 #define YIELD_MAX_MS_DEFAULT 10
  89 static unsigned yield_max_count;
  90 static unsigned yield_max_ms;
  91 static int yield_hook_enabled;
  93 static void lua_script_disable_yield_hook(void) {
yield_hook_enabled = 0;
  95 }
  96 static void lua_script_enable_yield_hook(void) {
yield_hook_enabled = 1;
  98 }
 100 // create a ptp message from the given stack index
 101 // incompatible types will return a TYPE_UNSUPPORTED message
 102 static ptp_script_msg *lua_create_usb_msg( lua_State* L, int index, unsigned msgtype) {
 103     // TODO maybe we should just pass the lua type constants
 104     unsigned datatype, datasize = 4;
 105     int ivalue = 0;
 106     void *data = &ivalue;
 107     int ltype = lua_type(L,index);
 108     switch(ltype) {
 109         case LUA_TNONE:
 110             return NULL; // nothing on the stack, no message generated
 111         break;
 112         case LUA_TNIL:
datatype = PTP_CHDK_TYPE_NIL;
 114         break;
 115         case LUA_TBOOLEAN:
datatype = PTP_CHDK_TYPE_BOOLEAN;
ivalue = lua_toboolean(L,index);
 118         break;
 119         case LUA_TNUMBER:
datatype = PTP_CHDK_TYPE_INTEGER;
ivalue = lua_tonumber(L,index);
 122         break;
 123         case LUA_TSTRING:
datatype = PTP_CHDK_TYPE_STRING;
data = (char *)lua_tolstring(L,index,&datasize);
 126         break;
 127         // TODO this uses usb_msg_table_to_string to serialize the table
 128         // the default format is described in
 129         // http://chdk.setepontos.com/index.php?topic=4338.msg62606#msg62606
 130         // other formats can be implemented by overriding this function in your lua code
 131         case LUA_TTABLE: {
 132             int result;
lua_script_disable_yield_hook(); // don't want to yield while converting
lua_getglobal(L, "usb_msg_table_to_string"); // push function
lua_pushvalue(L, index); // copy specified index to top of stack
result = lua_pcall(L,1,1,0); // this will leave an error message as a string on the stack if call fails
lua_script_enable_yield_hook();
 138             if( result ) {
 139                 // if called from lua, throw a normal error
 140                 if( msgtype == PTP_CHDK_S_MSGTYPE_USER ) {
luaL_error(L,lua_tostring(L,-1));
 142                     return NULL; // not reached
 143                 } else { // if it's a return, convert the message to an ERR
msgtype = PTP_CHDK_S_MSGTYPE_ERR;
datatype = PTP_CHDK_S_ERRTYPE_RUN;
data = (char *)lua_tolstring(L,-1,&datasize);
 147                     break;
 148                 }
 149             }
 150             // an empty table is returned as an empty string by default
 151             // a non-string should never show up here
 152             if ( !lua_isstring(L,-1) ) { 
 153                 return NULL;
 154             }
datatype = PTP_CHDK_TYPE_TABLE;
data = (char *)lua_tolstring(L,-1,&datasize);
lua_pop(L,1);
 158         }
 159         break;
 160         default:
datatype = PTP_CHDK_TYPE_UNSUPPORTED;
data = (char *)lua_typename(L,ltype); // return type name as message data
datasize = strlen(data);
 164     }
 165     return ptp_script_create_msg(msgtype,datatype,datasize,data);
 166 }
 168 void lua_script_reset()
 169 {
 170     // in PTP, clean up gui state to ensure not left in script handler
 171     if(lua_script_is_ptp) {
 172         if(ptp_saved_alt_state) {
enter_alt(0); // return to regular "alt" from script GUI mode
 174         } else {
exit_alt();
 176         }
 177     }
script_shoot_hooks_reset();
lua_close( L );
L = 0;
 182 }
 184 void lua_script_error_ptp(int runtime, const char *err) {
 185     if(runtime) {
ptp_script_write_error_msg(PTP_CHDK_S_ERRTYPE_RUN, err);
 187     } else {
ptp_script_write_error_msg(PTP_CHDK_S_ERRTYPE_COMPILE, err);
lua_script_reset();
 190     }
 191 }
 193 static void lua_count_hook(lua_State *L, __attribute__ ((unused))lua_Debug *ar)
 194 {
run_hook_count++;
 196     if( L->nCcalls > L->baseCcalls || !yield_hook_enabled )
 197         return;
 198     if(run_hook_count >= yield_max_count || (unsigned)(get_tick_count() - run_start_tick) >= yield_max_ms)
lua_yield( L, 0 );
 200 }
 202 int lua_script_error(lua_State *Lt,int runtime)
 203 {
 204     const char *err = lua_tostring( Lt, -1 );
 206     if(err)
 207     {
 208         if(!*err)
 209         {
script_console_add_error( (long)"ERROR: empty error message" );
 211         }
 212         else
 213         {
script_console_add_error( (long)err );
 215         }
 216     }
 217     else
 218     {
script_console_add_error( (long)"ERROR: NULL error message" );
 220     }
 222     if (lua_script_is_ptp)
 223     {
lua_script_error_ptp(runtime,err);
 225     }
 226     else
 227     {
 228         if (runtime)
 229         {
 230             if(conf.debug_lua_restart_on_error) {
script_end();
script_start_gui(0);
 233                 return SCRIPT_RUN_RUNNING;
 234             }
 235         }
 236         else // ensure lua_state is closed for compiletime errors
 237         {
lua_script_reset();
 239         }
 240     }
script_console_add_error(LANG_CONSOLE_TEXT_TERMINATED);
 243     return SCRIPT_RUN_ERROR;
 244 }
 247 // TODO more stuff from script.c should be moved here
 248 void lua_script_finish(lua_State *L) 
 249 {
 250     if(lua_script_is_ptp) {
 251         // send all return values as RET messages
 252         int i,end = lua_gettop(L);
 253         for(i=1;i<=end; i++) {
ptp_script_msg *msg = lua_create_usb_msg(L,i,PTP_CHDK_S_MSGTYPE_RET);
 255             // if the queue is full return values will be silently discarded
 256             // incompatible types will be returned as TYPE_UNSUPPORTED to preserve expected number and order of return values
 257             if(msg) {
ptp_script_write_msg(msg); 
 259                 // create_usb_msg may convert the message to an error
 260                 if(msg->type != PTP_CHDK_S_MSGTYPE_RET) {
 261                     break;
 262                 }
 263             } else {
ptp_script_write_error_msg(PTP_CHDK_S_ERRTYPE_RUN, "error creating return msg");
 265                 break;
 266             }
 267         }
 268     }
 269 }
 271 int lua_script_start( char const* script, int ptp )
 272 {
script_shoot_hooks_reset();
lua_script_is_ptp = ptp;
 275     if(ptp) {
ptp_saved_alt_state = camera_info.state.gui_mode_alt;
 277         // put ui in script alt state to allow key presses to be sent to script
enter_alt(1);
 279     }
L = lua_open();
luaL_openlibs( L );
register_lua_funcs( L );
Lt = lua_newthread( L );
lua_setfield( L, LUA_REGISTRYINDEX, "Lt" );
 286     if( luaL_loadstring( Lt, script ) != 0 )
 287     {
lua_script_error(Lt,0);
 289         return 0;
 290     }
lua_sethook(Lt, lua_count_hook, LUA_MASKCOUNT, YIELD_CHECK_COUNT );
lua_script_enable_yield_hook();
run_first_resume = 1;
yield_max_count = YIELD_MAX_COUNT_DEFAULT;
yield_max_ms = YIELD_MAX_MS_DEFAULT;
 296     return 1;
 297 }
 299 int lua_script_start_file(char const* filename)
 300 {
 301     static char loader[256];
 302     char *wrapper = "";
 303     if ((script_version.major == 1) && (script_version.minor == 3))
wrapper = "require'wrap13' ";
sprintf(loader, "%slocal s,e=loadfile'%s' collectgarbage() if not s then error(e) end s()", wrapper, filename);
 306     return lua_script_start(loader, 0);
 307 }
 309 // run a timeslice of lua script
 310 int lua_script_run(void)
 311 {
 312     int Lres;
 313     int top;
 314     if (run_first_resume) {
run_first_resume = 0;
top = 0;
 317     } else {
top = lua_gettop(Lt);
 319     }
run_start_tick = get_tick_count();
run_hook_count = 0;
Lres = lua_resume( Lt, top );
 324     if (Lres == LUA_YIELD)
 325     {
 326         // yielded
 327     }
 328     else if (Lres != 0)
 329     {
 330         return lua_script_error(Lt,1);
 331     }
 332     else 
 333     {
 334         // finished normally, add ptp result
lua_script_finish(Lt);
 336         // Display 'Finished message', unless running from PTP
 337         if (lua_script_is_ptp == 0)
script_console_add_error(LANG_CONSOLE_TEXT_FINISHED);
 339         return SCRIPT_RUN_ENDED;
 340     }
 342     return SCRIPT_RUN_RUNNING;
 343 }
 345 // run the "restore" function at the end of a script
 346 // Mimic uBasic logic, return 0 to trigger script interrupt immediately
 347 int lua_run_restore()
 348 {
lua_getglobal(Lt, "restore");
 350     if (lua_isfunction(Lt, -1)) {
 351         if (lua_pcall( Lt, 0, 0, 0 )) {
script_console_add_line( (long)lua_tostring( Lt, -1 ) );
 353         }
 354         if (lua_script_is_ptp == 0)
script_console_add_error(LANG_CONSOLE_TEXT_FINISHED);
 356     }
 357     return 0;
 358 }
 360 // get key ID of key name at arg, throw error if invalid
 361 static int lua_get_key_arg( lua_State * L, int narg )
 362 {
 363     int k = script_keyid_by_name( luaL_checkstring( L, narg ) );
 364     if(!k) 
luaL_error( L, "unknown key" );
 366     return k;
 367 }
 369 /*
 370   get a value where boolean or 0/!0 are accepted for on/off.
 371   normal lua toboolean will convert 0 to true, but ubasic and c users 
 372   will expect 0 to be off
 373   intentional HACK: numbers greater than 1 are returned as is
 374 */
 375 static unsigned on_off_value_from_lua_arg( lua_State* L, int index)
 376 {
 377   if( lua_isboolean(L,index) ) {
 378     return lua_toboolean(L,index);
 379   }
 380   else {
 381     return luaL_checknumber(L,index); 
 382   }
 383 }
 385 static int luaCB_set_curve_state( lua_State* L )
 386 {
libcurves->curve_set_mode(luaL_checknumber( L, 1 ));
 388     return 0;
 389 }
 391 static int luaCB_get_curve_state( lua_State* L )
 392 {
lua_pushnumber(L,conf.curve_enable);
 394     return 1;
 395 }
 397 static int luaCB_set_curve_file( lua_State* L )
 398 {
size_t l;
 400     const char *s = luaL_checklstring(L, 1, &l);
libcurves->curve_set_file(s);
 402     return 0;
 403 }
 405 static int luaCB_get_curve_file( lua_State* L )
 406 {
lua_pushstring(L,conf.curve_file);
 408     return 1;
 409 }
 411 static int luaCB_set_aelock(lua_State* L) 
 412 {
 413   int val = on_off_value_from_lua_arg(L, 1);
 414   if (val>0) DoAELock();  // 1: enable AELock
 415   else UnlockAE();       // 0: disable unlock AE
 416   return 0;
 417 }
 419 static int luaCB_set_aflock(lua_State* L) 
 420 {
 421   int val = on_off_value_from_lua_arg(L, 1);
 422   if (val>0) DoAFLock();  // 1: enable AFLock
 423   else UnlockAF();       // 0: disable unlock AF
 424   return 0;
 425 }
 427 static int luaCB_set_mf(lua_State* L) 
 428 {
 429   int val = on_off_value_from_lua_arg(L, 1);
 430   if (val>0) val=DoMFLock();  // 1: enable
 431   else val=UnlockMF();       // 0: disable
lua_pushnumber(L, val); 
 433   return 1; 
 434 }
 436 static int luaCB_get_sd_over_modes( lua_State* L )
 437 {
lua_pushnumber(L,sd_over_modes());
 439     return 1;
 440 }
 442 static int luaCB_shoot( lua_State* L )
 443 {
action_push_shoot(luaL_optnumber( L, 1, 1 ));
 445   return lua_yield( L, 0 );
 446 }
 448 // Process a sleep function from the stack
 449 static int action_stack_AS_LUA_SLEEP()
 450 {
 451     if (get_tick_count() >= action_top(2))
 452     {
action_pop_func(1);
 454         return 1;
 455     }
 456     return 0;
 457 }
 459 static int sleep_delay(int delay)
 460 {
 461     /* delay of -1 signals indefinite (actually 1 day) delay */
 462     if (delay == -1)
delay = 86400000;
 465     if (delay > 0)
 466         return delay + get_tick_count();
 468     return 0;
 469 }
 471 static int luaCB_sleep( lua_State* L )
 472 {
 473     int delay = sleep_delay(luaL_checknumber( L, 1 ));
 475     if (delay > 0)
 476     {
action_push(delay);
action_push_func(action_stack_AS_LUA_SLEEP);
 479     }
 481     return lua_yield( L, 0 );
 482 }
 484 // for press,release and click
 485 static int luaCB_keyfunc( lua_State* L )
 486 {
 487   void* func = lua_touserdata( L, lua_upvalueindex(1) );
 488   ((void(*)(long))func)( lua_get_key_arg( L, 1 ) );
 489   return lua_yield( L, 0 );
 490 }
 492 static int luaCB_cls( __attribute__ ((unused))lua_State* L )
 493 {
console_clear();
 495   return 0;
 496 }
 498 static int luaCB_set_console_layout( lua_State* L )
 499 {
console_set_layout(luaL_checknumber( L, 1 ),luaL_checknumber( L, 2 ),luaL_checknumber( L, 3 ),luaL_checknumber( L, 4 ));
 501   return 0;
 502 }
 504 static int luaCB_set_console_autoredraw( lua_State* L )
 505 {
console_set_autoredraw(luaL_checknumber( L, 1 ));
 507   return 0;
 508 }
 510 static int luaCB_console_redraw( __attribute__ ((unused))lua_State* L )
 511 {
console_redraw();
 513   return 0;
 514 }
 516 static int luaCB_get_partitionInfo( lua_State* L )
 517 {
 518     if (camera_info.cam_has_multipart)
 519     {
lua_createtable(L, 0, 4);
SET_INT_FIELD("count",  get_part_count());
SET_INT_FIELD("active", get_active_partition());
SET_INT_FIELD("type",   get_part_type());
SET_INT_FIELD("size",   GetTotalCardSpaceKb()>>10);
 525       return 1;
 526     }
 527     return 0;
 528 }
 530 static int luaCB_swap_partitions( lua_State* L )
 531 {
 532     if (camera_info.cam_has_multipart)
 533     {
 534       int partNr;
 536       if( lua_gettop(L)==1 )
 537       {
partNr = luaL_checknumber(L, 1);
 539       }
 540       else
 541       {
 542         int partCount = get_part_count();
partNr = get_active_partition()+1;
 544         if( partNr > partCount ) partNr = 1;
 545       }
lua_pushboolean(L, swap_partitions(partNr));
 547       return 1;
 548     }
 549     return 0;
 550 }
 552 static int luaCB_get_av96( lua_State* L )
 553 {
lua_pushnumber( L, shooting_get_av96() );
 555   return 1;
 556 }
 558 static int luaCB_get_bv96( lua_State* L )
 559 {
lua_pushnumber( L, shooting_get_bv96() );
 561   return 1;
 562 }
 564 static int luaCB_get_day_seconds( lua_State* L )
 565 {
 566     struct tm *ttm;
ttm = get_localtime();
lua_pushnumber( L, ttm->tm_hour * 3600 + ttm->tm_min * 60 + ttm->tm_sec );
 569     return 1;
 570 }
 572 static int luaCB_get_disk_size( lua_State* L )
 573 {
lua_pushnumber( L, GetTotalCardSpaceKb() );
 575   return 1;
 576 }
 578 static int luaCB_get_dofinfo( lua_State* L )
 579 {
shooting_update_dof_values();
lua_createtable(L, 0, 12);
SET_BOOL_FIELD("hyp_valid", (camera_info.dof_values.hyperfocal_valid!=0));
SET_BOOL_FIELD("focus_valid", (camera_info.dof_values.distance_valid!=0));
SET_INT_FIELD("aperture", camera_info.dof_values.aperture_value);
SET_INT_FIELD("coc", camera_info.circle_of_confusion);
SET_INT_FIELD("focal_length", camera_info.dof_values.focal_length);
SET_INT_FIELD("eff_focal_length", get_effective_focal_length(lens_get_zoom_point()));
SET_INT_FIELD("focus", camera_info.dof_values.subject_distance);
SET_INT_FIELD("near", camera_info.dof_values.near_limit);
SET_INT_FIELD("far", camera_info.dof_values.far_limit);
SET_INT_FIELD("hyp_dist", camera_info.dof_values.hyperfocal_distance);
SET_INT_FIELD("dof", camera_info.dof_values.depth_of_field);
SET_INT_FIELD("min_stack_dist", camera_info.dof_values.min_stack_distance);
 594   return 1;
 595 }
 597 static int luaCB_get_free_disk_space( lua_State* L )
 598 {
lua_pushnumber( L, GetFreeCardSpaceKb() );
 600   return 1;
 601 }
 603 static int luaCB_get_focus( lua_State* L )
 604 {
lua_pushnumber( L, shooting_get_subject_distance() );
 606   return 1;
 607 }
 609 static int luaCB_get_iso_market( lua_State* L )
 610 {
lua_pushnumber( L, shooting_get_iso_market() );
 612   return 1;
 613 }
 615 static int luaCB_get_iso_mode( lua_State* L )
 616 {
lua_pushnumber( L, shooting_get_iso_mode() );
 618   return 1;
 619 }
 621 static int luaCB_get_iso_real( lua_State* L )
 622 {
lua_pushnumber( L, shooting_get_iso_real() );
 624   return 1;
 625 }
 627 static int luaCB_get_jpg_count( lua_State* L )
 628 {
lua_pushnumber( L, GetJpgCount() );
 630   return 1;
 631 }
 633 /*
 634 val=get_prop(id)
 635 get propcase value identified by id
 636 the propcase is read as a short and sign extended to an int
 637 */
 638 static int luaCB_get_prop( lua_State* L )
 639 {
lua_pushnumber( L, shooting_get_prop( luaL_checknumber( L, 1 ) ) );
 641   return 1;
 642 }
 644 /*
 645 val=get_prop_str(prop_id,length)
 646 get the value of a propertycase as a string
 647 numeric values may be extracted using string.byte or or the binstr.lua module
 648 returns the value as a string, or false if the underlying propcase call returned non-zero
 649 */
 650 static int luaCB_get_prop_str( lua_State* L ) {
 651     void *buf;
 652     unsigned size;
 653     unsigned prop_id = luaL_checknumber( L, 1 );
size = luaL_checknumber( L, 2 );
buf = malloc(size);
 656     if(!buf) {
 657         return luaL_error( L, "malloc failed in luaCB_get_prop" );
 658     }
 659     if(get_property_case(prop_id,buf,size) == 0) {
lua_pushlstring( L, buf, size );
 661     } else {
lua_pushboolean( L, 0);
 663     }
free(buf);
 665     return 1;
 666 }
 668 /*
 669 b=get_raw_support()
 670 return true if in rec mode and raw data is available in the current capture mode
 671 NOTE
 672 currently returns true in dedicated video modes, even if still shooting is not possible
 673 */
 674 static int luaCB_get_raw_support( lua_State* L )
 675 {
lua_pushboolean( L, is_raw_possible() && !camera_info.state.mode_play );
 677   return 1;
 678 }
 680 static int luaCB_get_raw_count( lua_State* L )
 681 {
lua_pushnumber( L, GetRawCount() );
 683   return 1;
 684 }
 686 static int luaCB_get_sv96( lua_State* L )
 687 {
lua_pushnumber( L, shooting_get_sv96_real() );
 689   return 1;
 690 }
 692 static int luaCB_get_tick_count( lua_State* L )
 693 {
lua_pushnumber( L, get_tick_count() );
 695   return 1;
 696 }
 698 static int luaCB_get_exp_count( lua_State* L )
 699 {
lua_pushnumber( L, get_exposure_counter() );
 701   return 1;
 702 }
 704 static int luaCB_get_image_dir( lua_State* L )
 705 {
 706   char dir[32];
get_target_dir_name(dir);
lua_pushstring( L, dir );
 709   return 1;
 710 }
 712 static int luaCB_get_tv96( lua_State* L )
 713 {
lua_pushnumber( L, shooting_get_tv96() );
 715   return 1;
 716 }
 718 static int luaCB_get_user_av_id( lua_State* L )
 719 {
lua_pushnumber( L, shooting_get_user_av_id() );
 721   return 1;
 722 }
 724 static int luaCB_get_user_av96( lua_State* L )
 725 {
lua_pushnumber( L, shooting_get_user_av96() );
 727   return 1;
 728 }
 730 // get minimum valid av96 value (widest aperture), or nil if in playback or no iris
 731 static int luaCB_get_min_av96( lua_State* L )
 732 {
 733   short av=shooting_get_min_av96(); 
 734   if(av < 0) { // -1 = Av not available
lua_pushnil(L);
 736   } else {
lua_pushnumber( L, av );
 738   }
 739   return 1;
 740 }
 742 // get maximum valid av96 value (smallest aperture), or nil if in playback or no iris
 743 static int luaCB_get_max_av96( lua_State* L )
 744 {
 745   short av=shooting_get_max_av96(); 
 746   if(av < 0) { // -1 = Av not available
lua_pushnil(L);
 748   } else {
lua_pushnumber( L, av );
 750   }
 751   return 1;
 752 }
 754 // get current av96 value - actual current value, not from half press propcase
 755 static int luaCB_get_current_av96( lua_State* L )
 756 {
lua_pushnumber( L, shooting_get_current_av96() );
 758   return 1;
 759 }
 761 // get current tv96 value - actual current value, not from half press propcase
 762 // returns nil if image sensor not active (playback, sleep mode, etc)
 763 static int luaCB_get_current_tv96( lua_State* L )
 764 {
 765   long tv = shooting_get_current_tv96();
 766   if( tv == SHOOTING_TV96_INVALID) {
lua_pushnil(L);
 768   } else {
lua_pushnumber( L, tv);
 770   }
 771   return 1;
 772 }
 774 // get the exposure value of the ND filter, or 0 if not present
 775 static int luaCB_get_nd_value_ev96( lua_State* L )
 776 {
lua_pushnumber( L, shooting_get_nd_value_ev96() );
 778   return 1;
 779 }
 781 // get the current ND value: 0 if out or not present, or nd_value if in
 782 static int luaCB_get_nd_current_ev96( lua_State* L )
 783 {
lua_pushnumber( L, shooting_get_nd_current_ev96() );
 785   return 1;
 786 }
 788 // return true if sensor is enabled (live view on), false if not (playback, rec with display off, display off power save)
 789 static int luaCB_get_imager_active( lua_State* L )
 790 {
lua_pushboolean( L, shooting_get_imager_active() );
 792   return 1;
 793 }
 795 // return current canon image format as bitmask 1 = jpg, 2 = raw, 3 = raw+jpg
 796 static int luaCB_get_canon_image_format( lua_State* L )
 797 {
lua_pushnumber( L, shooting_get_canon_image_format() );
 799   return 1;
 800 }
 802 // does cam support canon raw?
 803 static int luaCB_get_canon_raw_support( lua_State* L )
 804 {
lua_pushboolean(L, camera_info.cam_canon_raw);
 806   return 1;
 807 }
 809 static int luaCB_get_user_tv_id( lua_State* L )
 810 {
lua_pushnumber( L, shooting_get_user_tv_id() );
 812   return 1;
 813 }
 815 static int luaCB_get_user_tv96( lua_State* L )
 816 {
lua_pushnumber( L, shooting_get_user_tv96() );
 818   return 1;
 819 }
 821 static int luaCB_get_vbatt( lua_State* L )
 822 {
lua_pushnumber( L, stat_get_vbatt() );
 824   return 1;
 825 }
 827 static int luaCB_get_zoom( lua_State* L )
 828 {
lua_pushnumber( L, shooting_get_zoom() );
 830   return 1;
 831 }
 833 static int luaCB_get_parameter_data( lua_State* L )
 834 {
 835   unsigned size;
 836   unsigned id = luaL_checknumber( L, 1 );
 837   unsigned val;
size = get_parameter_size(id);
 840   if (size == 0) {
 841     // return nil
 842     return 0;
 843   }
 844   if (size >= 1 && size <= 4) {
val = 0;
get_parameter_data( id, &val, size );
lua_pushlstring( L, (char *)&val, size );
 848     // for convenience, params that fit in a number are returned in one as a second result
lua_pushnumber( L, val );
 850     return 2;
 851   }
 852   else {
 853     char *buf = malloc(size);
 854     if(!buf) {
luaL_error( L, "malloc failed in luaCB_get_parameter_data" );
 856     }
get_parameter_data( id, buf, size );
lua_pushlstring( L, buf, size );
free(buf);
 860     return 1;
 861   }
 862 }
 864 static int luaCB_get_flash_params_count( lua_State* L )
 865 {
lua_pushnumber( L, get_flash_params_count() );
 867   return 1;
 868 }
 870 static int luaCB_set_av96_direct( lua_State* L )
 871 {
shooting_set_av96_direct( luaL_checknumber( L, 1 ), shooting_in_progress()?SET_NOW:SET_LATER );
 873   return 0;
 874 }
 876 static int luaCB_set_av96( lua_State* L )
 877 {
shooting_set_av96( luaL_checknumber( L, 1 ), shooting_in_progress()?SET_NOW:SET_LATER );
 879   return 0;
 880 }
 882 // set current canon image format as bitmask 1 = jpg, 2 = raw, 3 = raw+jpg
 883 // returns true if support format, false if not
 884 // NOTE: this setting is lost in shooting mode and play/rec switches
 885 static int luaCB_set_canon_image_format( lua_State* L )
 886 {
lua_pushboolean( L, shooting_set_canon_image_format(luaL_checknumber( L, 1 )) );
 888   return 1;
 889 }
 891 static int luaCB_set_focus_interlock_bypass( lua_State* L )
 892 {
set_focus_bypass(on_off_value_from_lua_arg( L, 1 ));
 894     return 0;
 895 }
 897 static int luaCB_set_focus( lua_State* L )
 898 {
 899     int sd = luaL_checknumber( L, 1 );
 900     // if sd override not available now, fail immediately without calling set_focus
 901     // to avoid unexpected results with SET_LATER
 902     if(!shooting_can_focus())
 903     {
lua_pushboolean(L, 0);
 905         return 1;
 906     }
 907     // NOTE duplicated in modules/luascript.c and lib/ubasic/ubasic.c
 908     // in AF lock or MF (canon or set by MF functions), set focus now
 909     if (shooting_get_prop(camera_info.props.af_lock) 
 910       || shooting_get_focus_mode()
 911       || camera_info.state.mode_video)  // TODO video needs to be investigated, carried over from old code
 912     {
shooting_set_focus(sd, SET_NOW);
 914     }
 915     else
 916     {
 917       // in an AF mode, set later
shooting_set_focus(sd, SET_LATER);
 919     }
lua_pushboolean(L, 1); 
 921     return 1; 
 922 }
 924 static int luaCB_set_iso_mode( lua_State* L )
 925 {
shooting_set_iso_mode( luaL_checknumber( L, 1 ) );
 927   return 0;
 928 }
 930 static int luaCB_set_iso_real( lua_State* L )
 931 {
shooting_set_iso_real( luaL_checknumber( L, 1 ),  shooting_in_progress()?SET_NOW:SET_LATER );
 933   return 0;
 934 }
 936 static int luaCB_set_led( lua_State* L )
 937 {
 938   int to, to1, to2;
to = luaL_checknumber( L, 1 );
to1 = luaL_checknumber( L, 2 );
to2 = 200;
 942   if( lua_isnumber( L, 3 ) )
to2 = lua_tonumber( L, 3 );
camera_set_led(to, to1, to2);
 945   return 0;
 946 }
 948 static int luaCB_set_nd_filter( lua_State* L )
 949 {
shooting_set_nd_filter_state( luaL_checknumber( L, 1 ), shooting_in_progress()?SET_NOW:SET_LATER );
 951   return 0;
 952 }
 954 /*
 955 set_prop(id,value)
 956 the value is treated as a short
 957 */
 958 static int luaCB_set_prop( lua_State* L )
 959 {
shooting_set_prop(luaL_checknumber( L, 1 ), luaL_checknumber( L, 2 ));
 961   return 0;
 962 }
 964 /*
 965 status=set_prop_str(prop_id,value)
 966 set propertycase value as a string. Length is taken from the string
 967 numeric propcase values may be assembled by setting byte values using string.char or the binstr module
 968 status: boolean - true if the underlying propcase call returns 0, otherwise false
 969 */
 970 static int luaCB_set_prop_str( lua_State *L ) {
 971     int prop_id;
 972     unsigned len;
 973     const char *str;
prop_id = luaL_checknumber( L, 1 );
str = luaL_checklstring( L, 2, &len );
 976     if(str && len > 0) {
lua_pushboolean( L, (set_property_case(prop_id,(void *)str,len) == 0));
 978     } else {
 979         return luaL_error( L, "invalid value");
 980     }
 981     return 1;
 982 }
 984 static int luaCB_set_raw_nr( lua_State* L )
 985 {
conf.raw_nr = luaL_checknumber( L, 1 );
 987   return 0;
 988 }
 990 static int luaCB_get_raw_nr( lua_State* L )
 991 {
lua_pushnumber( L, conf.raw_nr );
 993   return 1;
 994 }
 996 static int luaCB_set_raw( lua_State* L )
 997 {
conf.save_raw = on_off_value_from_lua_arg( L, 1 );
 999   return 0;
1000 }
1002 static int luaCB_get_raw( lua_State* L )
1003 {
lua_pushboolean( L, conf.save_raw );
1005     return 1;
1006 }
1008 static int luaCB_set_sv96( lua_State* L )
1009 {
shooting_set_sv96(luaL_checknumber( L, 1 ), shooting_in_progress()?SET_NOW:SET_LATER );
1011   return 0;
1012 }
1014 static int luaCB_set_tv96_direct( lua_State* L )
1015 {
shooting_set_tv96_direct(luaL_checknumber( L, 1 ), shooting_in_progress()?SET_NOW:SET_LATER );
1017   return 0;
1018 }
1020 static int luaCB_set_tv96( lua_State* L )
1021 {
shooting_set_tv96(luaL_checknumber( L, 1 ), shooting_in_progress()?SET_NOW:SET_LATER );
1023   return 0;
1024 }
1026 static int luaCB_set_user_av_by_id_rel( lua_State* L )
1027 {
shooting_set_user_av_by_id_rel(luaL_checknumber( L, 1 ));
1029   return 0;
1030 }
1032 static int luaCB_set_user_av_by_id( lua_State* L )
1033 {
shooting_set_user_av_by_id(luaL_checknumber( L, 1 ));
1035   return 0;
1036 }
1038 static int luaCB_set_user_av96( lua_State* L )
1039 {
shooting_set_user_av96(luaL_checknumber( L, 1 ));
1041   return 0;
1042 }
1044 static int luaCB_set_user_tv_by_id_rel( lua_State* L )
1045 {
shooting_set_user_tv_by_id_rel(luaL_checknumber( L, 1 ));
1047   return 0;
1048 }
1050 static int luaCB_set_user_tv_by_id( lua_State* L )
1051 {
shooting_set_user_tv_by_id(luaL_checknumber( L, 1 ));
1053   return 0;
1054 }
1056 static int luaCB_set_user_tv96( lua_State* L )
1057 {
shooting_set_user_tv96(luaL_checknumber( L, 1 ));
1059   return 0;
1060 }
1062 static int luaCB_set_zoom_speed( lua_State* L )
1063 {
shooting_set_zoom_speed(luaL_checknumber( L, 1 ));
1065   return 0;
1066 }
1068 static int luaCB_set_zoom_rel( lua_State* L )
1069 {
shooting_set_zoom_rel(luaL_checknumber( L, 1 ));
1071   return 0;
1072 }
1074 static int luaCB_set_zoom( lua_State* L )
1075 {
shooting_set_zoom(luaL_checknumber( L, 1 ));
1077   return 0;
1078 }
1080 // Wait for a button to be pressed and released (or the timeout to expire)
1081 static int action_stack_AS_LUA_WAIT_CLICK()
1082 {
1083     // Check key pressed or timeout
1084     if ((get_tick_count() >= action_top(2)) || camera_info.state.kbd_last_clicked)
1085     {
1086         // If timed out set key state to "no_key", otherwise key pressed so set last checked time
1087         if (!camera_info.state.kbd_last_clicked)
camera_info.state.kbd_last_clicked=0xFFFF;
1089         else
camera_info.state.kbd_last_checked_time = camera_info.state.kbd_last_clicked_time;
action_pop_func(1);
1093         return 1;
1094     }
1096     return 0;
1097 }
1099 static int luaCB_wait_click( lua_State* L )
1100 {
1101     int delay = luaL_optnumber( L, 1, 0 );
1102     if (delay == 0) delay = -1;
delay = sleep_delay(delay);
1105     // Reset 'clicked' key if it has not changed since last time
1106     if (camera_info.state.kbd_last_clicked_time <= camera_info.state.kbd_last_checked_time)
1107     {
camera_info.state.kbd_last_clicked = 0;
1109     }
1111     // Set up for wait or click testing
action_push(delay);
action_push_func(action_stack_AS_LUA_WAIT_CLICK);
1115     // Check for short delay or key already pressed by calling action stack routine once now
1116     if (action_stack_AS_LUA_WAIT_CLICK() == 0)
1117     {
1118         return lua_yield( L, 0 );
1119     }
1121     return 0;
1122 }
1124 static int luaCB_is_pressed( lua_State* L )
1125 {
lua_pushboolean( L, script_key_is_pressed(lua_get_key_arg( L, 1 )));
1127   return 1;
1128 }
1130 static int luaCB_is_key( lua_State* L )
1131 {
lua_pushboolean( L, script_key_is_clicked(lua_get_key_arg( L, 1 )));
1133   return 1;
1134 }
1136 static int luaCB_set_exit_key( lua_State* L )
1137 {
1138   // TODO can't check if valid for this camera
script_set_terminate_key(lua_get_key_arg( L, 1 ),luaL_checkstring( L, 1));
1140   return 0;
1141 }
1143 static int luaCB_wheel_right( __attribute__ ((unused))lua_State* L )
1144 {
JogDial_CW();
1146   return 0;
1147 }
1149 static int luaCB_wheel_left( __attribute__ ((unused))lua_State* L )
1150 {
JogDial_CCW();
1152   return 0;
1153 }
1155 static int luaCB_md_af_led_control( lua_State* L )
1156 {
camera_info.perf.md_af_on_delay = luaL_checknumber( L, 1 );
camera_info.perf.md_af_on_time = luaL_checknumber( L, 2 );
1159     if ((camera_info.perf.md_af_on_time > 0) && (camera_info.cam_af_led >= 0)) {
camera_info.perf.md_af_tuning = 1;        // Enable MD testing with AF LED
1161         // clear previous values
memset(&camera_info.perf.af_led,0,sizeof(camera_info.perf.af_led));
camera_info.perf.af_led.min = 0xFFFFFFFF;
1164     } else {
camera_info.perf.md_af_tuning = 0;        // Disable MD testing
1166     }
1167     return 0;
1168 }
1170 static int luaCB_md_get_cell_diff( lua_State* L )
1171 {
lua_pushnumber( L, libmotiondetect->md_get_cell_diff(luaL_checknumber(L,1), luaL_checknumber(L,2)));
1173     return 1;
1174 }
1177 static int luaCB_md_get_cell_val( lua_State* L )
1178 {
lua_pushnumber( L, libmotiondetect->md_get_cell_val(luaL_checknumber(L,1), luaL_checknumber(L,2)));
1180     return 1;
1181 }
1183 static int luaCB_md_detect_motion( lua_State* L )
1184 {
1185     int columns = (luaL_optnumber(L,1,6));
1186     int rows = (luaL_optnumber(L,2,4));
1187     int pixel_measure_mode = (luaL_optnumber(L,3,1));
1188     int detection_timeout = (luaL_optnumber(L,4,10000));
1189     int measure_interval = (luaL_optnumber(L,5,7));
1190     int threshold = (luaL_optnumber(L,6,10));
1191     int draw_grid = (luaL_optnumber(L,7,1));
1192     // arg 8 is the return value in ubasic. We
1193     // ignore it here. - AUJ
1194     int clipping_region_mode = (luaL_optnumber(L,9,0));
1195     int clipping_region_column1 = (luaL_optnumber(L,10,0));
1196     int clipping_region_row1 = (luaL_optnumber(L,11,0));
1197     int clipping_region_column2 = (luaL_optnumber(L,12,0));
1198     int clipping_region_row2 = (luaL_optnumber(L,13,0));
1199     int parameters = (luaL_optnumber(L,14,1));
1200     int pixels_step = (luaL_optnumber(L,15,6));
1201     int msecs_before_trigger = (luaL_optnumber(L,16,0));
1203     if (libmotiondetect->md_init_motion_detector(
columns, rows, pixel_measure_mode, detection_timeout, 
measure_interval, threshold, draw_grid,
clipping_region_mode,
clipping_region_column1, clipping_region_row1,
clipping_region_column2, clipping_region_row2,
parameters, pixels_step, msecs_before_trigger
1210         ))
1211         return lua_yield(L, 0);
1212     else
1213         return luaL_error( L, "md_init_motion_detector failed" );
1214 }
1216 static void return_string_selected(const char *str) {
1217     // Reconnect button input to script - will also signal action stack
1218     // that file browser / textbox is finished and return last selected file
1219     // to script caller
camera_info.state.state_kbd_script_run = SCRIPT_STATE_RAN;
1222     // Push selected file as script return value
lua_pushstring( Lt, (str && str[0])? str : NULL );
1224 }
1226 static int action_stack_AS_WAIT_MODULE()
1227 {
1228     // state_kbd_script_run is set to 0 when the file browser is started from a Lua script
1229     // it is reset back to 1 when the file browser exits and control is returned back to
1230     // the script
1231     if (camera_info.state.state_kbd_script_run)
1232     {
action_pop_func(0);
1234     }
1235     return 0;
1236 }
1238 static int luaCB_file_browser( lua_State* L ) {
1239     // Disconnect button input from script so buttons will work in file browser
camera_info.state.state_kbd_script_run = SCRIPT_STATE_INACTIVE;
1241     // Push file browser action onto stack - will loop doing nothing until file browser exits
action_push_func(action_stack_AS_WAIT_MODULE);
1243     // Switch to file browser gui mode. Path can be supplied in call or defaults to "A" (root directory).
libfselect->file_select(LANG_STR_FILE_BROWSER, luaL_optstring( L, 1, "A" ), "A", return_string_selected);
1245     // Yield the script so that the action stack will process the AS_FILE_BROWSER action
1246     return lua_yield(L, 0);
1247 }
1249 static int luaCB_textbox( lua_State* L ) {
1250     // Disconnect button input from script so buttons will work in the textbox
camera_info.state.state_kbd_script_run = SCRIPT_STATE_INACTIVE;
1252     // Switch to textbox gui mode. Text box prompt should be passed as param.
1253     int rv = libtextbox->textbox_init((int)luaL_optstring( L, 1, "Text box" ),   //title
1254         (int)luaL_optstring( L, 2, "Enter text" ), //message
luaL_optstring( L, 3, ""  ),               //default string
luaL_optnumber( L, 4, 30),                 //max size of a text
return_string_selected, 0);
1258     if (rv)
1259     {
1260         // Push textbox action onto stack - will loop doing nothing until textbox exits
action_push_func(action_stack_AS_WAIT_MODULE);
1262     }
1263     else
return_string_selected(0);
1266     // Yield the script so that the action stack will process the AS_TEXTBOX action
1267     return lua_yield(L, 0);
1268 }
1270 // begin lua draw fuctions
1271 static int luaCB_draw_pixel( lua_State* L ) {
coord x1=luaL_checknumber(L,1);
coord y1=luaL_checknumber(L,2);
color cl=get_script_color(luaL_checknumber(L,3));
draw_pixel(x1,y1,cl);
1276   return 0;
1277 }
1279 static int luaCB_draw_line( lua_State* L ) {
coord x1=luaL_checknumber(L,1);
coord y1=luaL_checknumber(L,2);
coord x2=luaL_checknumber(L,3);
coord y2=luaL_checknumber(L,4);
color cl=get_script_color(luaL_checknumber(L,5));
draw_line(x1,y1,x2,y2,cl);
1286   return 0;
1287 }
1289 static int luaCB_draw_rect( lua_State* L ) {
coord x1=luaL_checknumber(L,1);
coord y1=luaL_checknumber(L,2);
coord x2=luaL_checknumber(L,3);
coord y2=luaL_checknumber(L,4);
color cl=get_script_color(luaL_checknumber(L,5));
1295   int   th=luaL_optnumber(L,6,1) & RECT_BORDER_MASK;
draw_rectangle(x1,y1,x2,y2,MAKE_COLOR(cl,cl),th);
1297   return 0;
1298 }
1300 static int luaCB_draw_rect_filled( lua_State* L ) {
coord x1 =luaL_checknumber(L,1);
coord y1 =luaL_checknumber(L,2);
coord x2 =luaL_checknumber(L,3);
coord y2 =luaL_checknumber(L,4);
color clf=get_script_color(luaL_checknumber(L,5));
color clb=get_script_color(luaL_checknumber(L,6));
1307   int   th =luaL_optnumber(L,7,1) & RECT_BORDER_MASK;
draw_rectangle(x1,y1,x2,y2,MAKE_COLOR(clb,clf),th|DRAW_FILLED);
1309   return 0;
1310 }
1312 static int luaCB_draw_ellipse( lua_State* L ) {
coord x1=luaL_checknumber(L,1);
coord y1=luaL_checknumber(L,2);
coord a=luaL_checknumber(L,3);
coord b=luaL_checknumber(L,4);
color cl=get_script_color(luaL_checknumber(L,5));
draw_ellipse(x1,y1,a,b,cl,0);
1319   return 0;
1320 }
1322 static int luaCB_draw_ellipse_filled( lua_State* L ) {
coord x1=luaL_checknumber(L,1);
coord y1=luaL_checknumber(L,2);
coord a=luaL_checknumber(L,3);
coord b=luaL_checknumber(L,4);
color cl=get_script_color(luaL_checknumber(L,5));
draw_ellipse(x1,y1,a,b,cl,DRAW_FILLED);
1329   return 0;
1330 }
1332 static int luaCB_draw_string( lua_State* L )
1333 {
coord x1 = luaL_checknumber(L,1);
coord y1 = luaL_checknumber(L,2);
1336   const char *t = luaL_checkstring( L, 3 );
color clf = get_script_color(luaL_checknumber(L,4));
color clb = get_script_color(luaL_checknumber(L,5));
1339   int xsize = luaL_optnumber(L,6,1);
1340   int ysize = luaL_optnumber(L,7,xsize);
1342   if ((xsize <= 1) && (ysize <= 1))
draw_string(x1, y1, t, MAKE_COLOR(clb,clf));
1344   else
draw_string_scaled(x1, y1, t, MAKE_COLOR(clb,clf), xsize, ysize);
1347   return 0;
1348 }
1350 static int luaCB_draw_clear( __attribute__ ((unused))lua_State* L ) {
draw_restore();
1352   return 0;
1353 }
1354 // end lua draw functions
1356 // bitmap dimensions, size matches coordinates of draw functions
1357 static int luaCB_get_gui_screen_width( lua_State* L )
1358 {
lua_pushnumber( L, camera_screen.width );
1360     return 1;
1361 }
1363 static int luaCB_get_gui_screen_height( lua_State* L )
1364 {
lua_pushnumber( L, camera_screen.height );
1366     return 1;
1367 }
1369 static int luaCB_autostarted( lua_State* L )
1370 {
lua_pushboolean( L, camera_info.state.auto_started );
1372   return 1;
1373 }
1375 static int luaCB_get_autostart( lua_State* L )
1376 {
lua_pushnumber( L, conf.script_startup );
1378   return 1;
1379 }
1381 static int luaCB_set_autostart( lua_State* L )
1382 {
1383   int to;
to = luaL_checknumber( L, 1 );
1385   if ( to >= 0 && to <= 3 ) conf.script_startup = to;
conf_save();
1387   return 0;
1388 }
1390 static int luaCB_get_usb_power( lua_State* L )
1391 {
lua_pushnumber( L, get_usb_power(luaL_optnumber( L, 1, 0 )) );
1393   return 1;
1394 }
1396 // enable USB High Perfomance timer
1397 static int luaCB_set_remote_timing( lua_State* L )
1398 {
1399   int val= on_off_value_from_lua_arg(L,1);
1400   if (val > 0 )
lua_pushboolean(L,start_usb_HPtimer(val));
1402   else
lua_pushboolean(L,stop_usb_HPtimer());
1404   return 1;
1405 }
1407 // enable shared USB port between ptp and precision sync
1408 static int luaCB_usb_force_active( lua_State* L )
1409 {
lua_pushboolean(L,force_usb_state(on_off_value_from_lua_arg(L,1)));
1411   return 1;
1412 }
1414 // set next shot to wait for USB sync ( 5V - 0V transition )
1415 static int luaCB_usb_sync_wait( lua_State* L )
1416 {
usb_sync_wait_flag = on_off_value_from_lua_arg(L,1);
1418   return 0;
1419 }
1421 static int luaCB_enter_alt( __attribute__ ((unused))lua_State* L )
1422 {
enter_alt(1);
1424   // if alt explicitly changed by script, set as 'saved' state
1425   if(lua_script_is_ptp) {
ptp_saved_alt_state = 1;
1427   }
1428   return 0;
1429 }
1431 static int luaCB_exit_alt( __attribute__ ((unused))lua_State* L )
1432 {
exit_alt();
1434   // if alt explicitly changed by script, set as 'saved' state
1435   if(lua_script_is_ptp) {
ptp_saved_alt_state = 0;
1437   }
1438   return 0;
1439 }
1441 static int luaCB_get_alt_mode( lua_State* L )
1442 {
lua_pushboolean(L, (camera_info.state.gui_mode != 0));
1444     return 1 ;
1445 }
1447 // optional parameter is 0 for soft shutdown (default) or 1 for hard/immediate
1448 static int luaCB_shut_down( lua_State* L )
1449 {
1450   if ( luaL_optnumber(L,1,0) == 1 )
1451   {
shutdown();
1453   } else {
camera_shutdown_in_a_second();
1455   }
1456   return 0;
1457 }
1459 static int luaCB_print_screen( lua_State* L )
1460 {
script_print_screen_statement( on_off_value_from_lua_arg( L, 1 ) );
1462     return 0;
1463 }
1465 static int luaCB_get_movie_status( lua_State* L )
1466 {
lua_pushnumber( L, get_movie_status() );
1468   return 1;
1469 }
1471 static int luaCB_set_movie_status( lua_State* L )
1472 {
set_movie_status( luaL_checknumber( L, 1 ) );
1474   return 0;
1475 }
1477 static int luaCB_get_video_button( lua_State* L )
1478 {
lua_pushboolean( L, camera_info.cam_has_video_button );
1480   return 1;
1481 }
1483 static int luaCB_get_video_recording( lua_State* L )
1484 {
lua_pushboolean( L, is_video_recording() );
1486   return 1;
1487 }
1489 static int luaCB_get_drive_mode( lua_State* L )
1490 {
lua_pushnumber( L, shooting_get_drive_mode() );
1492   return 1;
1493 }
1495 static int luaCB_get_focus_mode( lua_State* L )
1496 {
lua_pushnumber( L, shooting_get_real_focus_mode() );
1498   return 1;
1499 }
1501 static int luaCB_get_focus_state( lua_State* L )
1502 {
lua_pushnumber( L, shooting_get_focus_state() );
1504   return 1;
1505 }
1507 static int luaCB_get_focus_ok( lua_State* L )
1508 {
lua_pushboolean( L, shooting_get_focus_ok() );
1510   return 1;
1511 }
1513 static int luaCB_get_flash_mode( lua_State* L )
1514 {
lua_pushnumber( L, shooting_get_flash_mode() );
1516   return 1;
1517 }
1519 static int luaCB_get_shooting( lua_State* L )
1520 {
lua_pushboolean( L, shooting_in_progress() );
1522   return 1;
1523 }
1525 static int luaCB_get_flash_ready( lua_State* L )
1526 {
lua_pushboolean( L, shooting_is_flash() );
1528   return 1;
1529 }
1531 static int luaCB_get_IS_mode( lua_State* L )
1532 {
lua_pushnumber( L, shooting_get_is_mode() );
1534   return 1;
1535 }
1537 static int luaCB_get_orientation_sensor( lua_State* L )
1538 {
lua_pushnumber( L, shooting_get_prop(camera_info.props.orientation_sensor) );
1540   return 1;
1541 }
1543 static int luaCB_get_zoom_steps( lua_State* L )
1544 {
lua_pushnumber( L, zoom_points );
1546   return 1;
1547 }
1549 static int luaCB_get_nd_present( lua_State* L )
1550 {
1551   int to;
1552   if (camera_info.cam_has_nd_filter == 0)
1553   {
to = 0;
1555   }
1556   else
1557   {
1558     if (camera_info.cam_has_iris_diaphragm == 0)
to = 1;
1560     else
to = 2;
1562   }
lua_pushnumber( L, to );
1564   return 1;
1565 }
1567 static int luaCB_get_propset( lua_State* L )
1568 {
lua_pushnumber( L, camera_info.props.propset );
1570   return 1;
1571 }
1573 static int luaCB_get_ev( lua_State* L )
1574 {
lua_pushnumber( L, shooting_get_ev_correction1() );
1576   return 1;
1577 }
1579 static int luaCB_set_ev( lua_State* L )
1580 {
1581   int to;
to = luaL_checknumber( L, 1 );
shooting_set_prop(camera_info.props.ev_correction_1, to);
shooting_set_prop(camera_info.props.ev_correction_2, to);
1585   return 0;
1586 }
1588 static int luaCB_get_histo_range( lua_State* L )
1589 {
1590   int from = (luaL_checknumber(L,1));
1591   int to = (luaL_checknumber(L,2));
lua_pushnumber( L, libshothisto->shot_histogram_get_range(from, to) );
1593   return 1;
1594 }
1596 static int luaCB_shot_histo_enable( lua_State* L )
1597 {
libshothisto->shot_histogram_set(on_off_value_from_lua_arg( L, 1 ));
1599   return 0;
1600 }
1602 static int luaCB_shot_histo_write_to_file( __attribute__ ((unused))lua_State* L )
1603 {
libshothisto->write_to_file();
1605     return 0;
1606 }
1608 /*
1609 histogram,total=get_live_histo()
1610 returns a histogram of Y values from the viewport buffer (downsampled by HISTO_STEP_SIZE)
1611 histogram[Y value] = count, so it is zero based unlike a normal lua array
1612 total is the total number of pixels, may vary depending on viewport size
1613 */
1614 static int luaCB_get_live_histo( lua_State* L )
1615 {
1616   unsigned short *h = malloc(256*sizeof(short));
1617   if(!h) {
1618       return luaL_error(L,"malloc fail");
1619   }
1620   int total=live_histogram_read_y(h);
lua_createtable(L, 0, 256);
1622   int i;
1623   for(i=0;i<256;i++) {
lua_pushnumber(L,h[i]);
lua_rawseti(L,-2,i);
1626   }
free(h);
lua_pushnumber(L,total);
1629   return 2;
1630 }
1632 static int luaCB_play_sound( lua_State* L )
1633 {
play_sound(luaL_checknumber( L, 1 ));
1635   return 0;
1636 }
1638 static int luaCB_get_temperature( lua_State* L )
1639 {
1640   int which = (luaL_checknumber( L, 1 ));
1641   int temp = -100; // do something insane if users passes bad value
1642   switch (which)
1643   {
1644     case 0:
temp = get_optical_temp(); 
1646       break;
1647     case 1:
temp = get_ccd_temp(); 
1649       break;
1650     case 2:
temp = get_battery_temp();
1652       break;
1653   }
lua_pushnumber( L, temp );
1655   return 1;
1656 }
1658 static int luaCB_get_time( lua_State* L )
1659 {
1660   int r = -1;
1661   static struct tm *ttm;
ttm = get_localtime();
1663   const char *t = luaL_checkstring( L, 1 );
1664   if (strncmp("s", t, 1)==0) r = ttm->tm_sec;
1665   else if (strncmp("m", t, 1)==0) r = ttm->tm_min;
1666   else if (strncmp("h", t, 1)==0) r = ttm->tm_hour;
1667   else if (strncmp("D", t, 1)==0) r = ttm->tm_mday;
1668   else if (strncmp("M", t, 1)==0) r = ttm->tm_mon+1;
1669   else if (strncmp("Y", t, 1)==0) r = 1900+ttm->tm_year;
lua_pushnumber( L, r );
1671   return 1;
1672 }
1674 /*
1675 set_clock(year, month, day, hour, minute, second)
1676 
1677 sets camera clock, including RTC
1678 values are as they appear in camera UI, full year, month and day start at 1
1679 does not change DST state, time set is time displayed
1680 also updates tick_count_offset
1681 no validation in CHDK
1682 */
1683 static int luaCB_set_clock( lua_State* L )
1684 {
set_clock(luaL_checknumber(L,1), // year, like 2020
luaL_checknumber(L,2), // month, 1-12
luaL_checknumber(L,3), // day, 1-31
luaL_checknumber(L,4), // hour
luaL_checknumber(L,5), // minute
luaL_checknumber(L,6)); // second
1691     return 0;
1692 }
1694 /*
1695   val=peek(address[,size])
1696   return the value found at address in memory, or nil if address or size is invalid
1697   size is optional 1=byte 2=halfword 4=word. defaults is 4
1698 */
1699 static int luaCB_peek( lua_State* L )
1700 {
1701   unsigned addr = luaL_checknumber(L,1);
1702   unsigned size = luaL_optnumber(L, 2, 4);
1703   switch(size) {
1704     case 1: 
lua_pushnumber( L, *(unsigned char *)(addr) );
1706     break;
1707     case 2:
1708       if (addr & 0x1) {
lua_pushnil(L);
1710       }
1711       else {
lua_pushnumber( L, *(unsigned short *)(addr) );
1713       }
1714     break;
1715     case 4:
1716       if (addr & 0x3) {
lua_pushnil(L);
1718       }
1719       else {
lua_pushnumber( L, *(unsigned *)(addr) );
1721       }
1722     break;
1723     default:
lua_pushnil(L);
1726   }
1727   return 1;
1728 }
1730 /*
1731   status=poke(address,value[,size])
1732   writes value to address in memory
1733   size is optional 1=byte 2=halfword 4=word. defaults is 4
1734   returns true, or nil if address or size is invalid
1735 */
1736 static int luaCB_poke( lua_State* L )
1737 {
1738   unsigned addr = luaL_checknumber(L,1);
1739   unsigned val = luaL_checknumber(L,2);
1740   unsigned size = luaL_optnumber(L, 3, 4);
1741   int status = 0;
1742   switch(size) {
1743     case 1: 
1744         *(unsigned char *)(addr) = (unsigned char)val;
status=1;
1746     break;
1747     case 2:
1748       if (!(addr & 0x1)) {
1749         *(unsigned short *)(addr) = (unsigned short)val;
status=1;
1751       }
1752     break;
1753     case 4:
1754       if (!(addr & 0x3)) {
1755         *(unsigned *)(addr) = val;
status=1;
1757       }
1758     break;
1759   }
1760   if(status) {
lua_pushboolean(L,1);
1762   }
1763   else {
lua_pushnil(L);
1765   }
1766   return 1;
1767 }
1769 static int luaCB_bitand( lua_State* L )
1770 {
1771   int v1 = (luaL_checknumber(L,1));
1772   int v2 = (luaL_checknumber(L,2));
lua_pushnumber( L, v1 & v2 );
1774   return 1;
1775 }
1777 static int luaCB_bitor( lua_State* L )
1778 {
1779   int v1 = (luaL_checknumber(L,1));
1780   int v2 = (luaL_checknumber(L,2));
lua_pushnumber( L, v1 | v2 );
1782   return 1;
1783 }
1785 static int luaCB_bitxor( lua_State* L )
1786 {
1787   int v1 = (luaL_checknumber(L,1));
1788   int v2 = (luaL_checknumber(L,2));
lua_pushnumber( L, v1 ^ v2 );
1790   return 1;
1791 }
1793 static int luaCB_bitshl( lua_State* L )
1794 {
1795   int val = (luaL_checknumber(L,1));
1796   unsigned shift = (luaL_checknumber(L,2));
lua_pushnumber( L, val << shift );
1798   return 1;
1799 }
1801 static int luaCB_bitshri( lua_State* L )
1802 {
1803   int val = (luaL_checknumber(L,1));
1804   unsigned shift = (luaL_checknumber(L,2));
lua_pushnumber( L, val >> shift );
1806   return 1;
1807 }
1809 static int luaCB_bitshru( lua_State* L )
1810 {
1811   unsigned val = (luaL_checknumber(L,1));
1812   unsigned shift = (luaL_checknumber(L,2));
lua_pushnumber( L, val >> shift );
1814   return 1;
1815 }
1817 static int luaCB_bitnot( lua_State* L )
1818 {
1819   unsigned val = (luaL_checknumber(L,1));
lua_pushnumber( L, ~val );
1821   return 1;
1822 }
1824 void set_string_field(lua_State* L, const char *key, const char *val)
1825 {
lua_pushstring(L, val);
lua_setfield(L, -2, key);
1828 }
1830 void set_number_field(lua_State* L, const char *key, int val)
1831 {
lua_pushnumber(L, val);
lua_setfield(L, -2, key);
1834 }
1836 static int luaCB_get_buildinfo( lua_State* L )
1837 {
lua_createtable(L, 0, 10);
set_string_field( L,"platform", camera_info.platform );
set_string_field( L,"platsub", camera_info.platformsub );
set_string_field( L,"version", camera_info.chdk_ver );
set_string_field( L,"build_number", camera_info.build_number );
set_string_field( L,"build_revision", camera_info.build_svnrev );
set_string_field( L,"build_date", camera_info.build_date );
set_string_field( L,"build_time", camera_info.build_time );
set_string_field( L,"os", camera_info.os );
set_number_field( L,"platformid", conf.platformid );
set_number_field( L,"digic", camera_info.cam_digic );
1849   return 1;
1850 }
1852 static int luaCB_get_mode( lua_State* L )
1853 {
lua_pushboolean( L, !camera_info.state.mode_play );
lua_pushboolean( L, camera_info.state.mode_video );
lua_pushnumber( L, camera_info.state.mode );
1857   return 3;
1858 }
1860 // TODO sanity check file ?
1861 static int luaCB_set_raw_develop( lua_State* L )
1862 {
raw_prepare_develop(luaL_optstring( L, 1, NULL ), 0);
1864   return 0;
1865 }
1867 static int luaCB_raw_merge_start( lua_State* L )
1868 {
1869     int op = luaL_checknumber(L,1);
1870     if ((op == RAW_OPERATION_SUM || op == RAW_OPERATION_AVERAGE))
1871     {
lua_pushboolean(L, librawop->raw_merge_start(op));   
1873         return 1;
1874     }
1875     else {
1876         return luaL_argerror(L,1,"invalid raw merge op");
1877     }
1878 }
1880 // TODO sanity check file ? Get it from C
1881 static int luaCB_raw_merge_add_file( lua_State* L )
1882 {
lua_pushboolean(L, librawop->raw_merge_add_file(luaL_checkstring( L, 1 )));
1884     return 1;
1885 }
1887 static int luaCB_raw_merge_end( __attribute__ ((unused))lua_State* L )
1888 {
librawop->raw_merge_end();
1890     return 0;
1891 }
1893 // Enable/disable LCD back light (input argument 1/0)
1894 static int luaCB_set_backlight( lua_State* L )
1895 {
1896   int val = on_off_value_from_lua_arg(L,1);
1898   if (val > 0) TurnOnBackLight();
1899   else TurnOffBackLight();
1900   return 0;
1901 }
1903 // Enable/disable LCD display (input argument 1/0)
1904 static int luaCB_set_lcd_display( lua_State* L )
1905 {
1906   int val = on_off_value_from_lua_arg(L,1);
1908   if (val > 0) TurnOnDisplay();
1909   else TurnOffDisplay();
1910   return 0;
1911 }
1913 // Enable/disable CHDK <ALT> & scriptname OSD items (input argument 1/0)
1914 static int luaCB_set_draw_title_line( lua_State* L )
1915 {
camera_info.state.osd_title_line= on_off_value_from_lua_arg(L,1);
1917   return 0;
1918 }
1920 // get CHDK <ALT> & scriptname OSD display state (input argument 1/0)
1921 static int luaCB_get_draw_title_line( lua_State* L )
1922 {
lua_pushboolean( L, camera_info.state.osd_title_line  );
1924    return 1;
1925 }
1927 // get the string or number passed in index and return it as an event id
1928 static unsigned levent_id_from_lua_arg( lua_State* L, int index)
1929 {
1930   unsigned event_id;
1931   if (lua_type(L, index) == LUA_TSTRING) {
1932     const char *ev_name = lua_tostring(L, index);
event_id = levent_id_for_name(ev_name);
1934     if (event_id == 0) {
1935         return luaL_error( L, "bad event name '%s'", ev_name );
1936     }
1937   }
1938   // could check here if it is in the table, but even valid ones can crash
1939   // so we avoid searching the table if given a number
1940   else if (lua_type(L,index) == LUA_TNUMBER){
event_id = lua_tonumber(L,index);
1942   }
1943   else {
1944     return luaL_error( L, "expected event name or id" );
1945   }
1946   return event_id;
1947 }
1950 /*
1951   return the index of an event, given it's name or event id
1952 */
1953 static unsigned levent_index_from_id_lua_arg( lua_State* L, int index )
1954 {
1955   if (lua_type(L, index) == LUA_TSTRING) {
1956     return levent_index_for_name(lua_tostring(L, index));
1957   }
1958   else if (lua_type(L,index) == LUA_TNUMBER){
1959     return levent_index_for_id(lua_tonumber(L,index));
1960   }
1961   else {
1962     return luaL_error( L, "expected string or number" );
1963   }
1964 }
1966 /*
1967   name,id,param = get_levent_def(event)
1968   event is an event id (number) or name (string)
1969   returns nil if event is not found
1970 */
1971 static int luaCB_get_levent_def( lua_State* L )
1972 {
1973   unsigned event_index = levent_index_from_id_lua_arg(L,1);
1974   if (event_index == LEVENT_INVALID_INDEX) {
lua_pushnil(L);
1976     return 1;
1977   }
lua_pushstring(L, levent_table[event_index].name);
lua_pushnumber(L, levent_table[event_index].id);
lua_pushnumber(L, levent_table[event_index].param);
1981   return 3;
1982 }
1984 /*
1985   index=get_levent_index(event)
1986   event is an event id (number) or name (string)
1987   returns index or nil if not found
1988 */
1989 static int luaCB_get_levent_index( lua_State* L )
1990 {
1991   unsigned event_index = levent_index_from_id_lua_arg(L,1);
1992   if (event_index == LEVENT_INVALID_INDEX) {
lua_pushnil(L);
1994   }
1995   else {
lua_pushnumber(L, event_index);
1997   }
1998   return 1;
1999 }
2001 /*
2002   name,id,param = get_levent_def_by_index(event_index)
2003   event_index is number index into the event table
2004   returns nil if event is not found
2005 */
2006 static int luaCB_get_levent_def_by_index( lua_State* L )
2007 {
2008   unsigned i = luaL_checknumber(L,1);
2009   if(i >= levent_count()) {
lua_pushnil(L);
2011     return 1;
2012   }
lua_pushstring(L, levent_table[i].name);
lua_pushnumber(L, levent_table[i].id);
lua_pushnumber(L, levent_table[i].param);
2016   return 3;
2017 }
2019 /*
2020   post_levent_*(event[,unk])
2021   post the event with PostLogicalEventToUI or PostLogicaEventForNotPowerType
2022   This sends the event. The difference between functions isn't clear.
2023   event is an event id (number) or name (string).
2024   unk is an optional number whose meaning is unknown, defaults to zero. 
2025     Based on code, other values would probably be a pointer.
2026     This is NOT the 3rd item in the event table.
2027 */
2028 static int luaCB_post_levent_to_ui( lua_State* L )
2029 {
2030   unsigned event_id,arg;
event_id = levent_id_from_lua_arg(L,1);
arg = luaL_optnumber(L, 2, 0);
PostLogicalEventToUI(event_id,arg);
2035   return 0;
2036 }
2038 static int luaCB_post_levent_for_npt( lua_State* L )
2039 {
2040   unsigned event_id,arg;
event_id = levent_id_from_lua_arg(L,1);
arg = luaL_optnumber(L, 2, 0);
PostLogicalEventForNotPowerType(event_id,arg);
2045   return 0;
2046 }
2048 /*
2049   set_levent_active(event,state)
2050   event is an event id (number) or name (string)
2051   state is a numeric or boolean state. true or non zero numbers turn on zero, false or nil turn off
2052   exact meaning is unknown, but it has something to do with the delivery of the specified event.
2053 */
2054 static int luaCB_set_levent_active( lua_State* L )
2055 {
2056   unsigned event_id;
2057   unsigned state;
event_id = levent_id_from_lua_arg(L,1);
state = on_off_value_from_lua_arg(L,2);
SetLogicalEventActive(event_id,state);
2062   return 0;
2063 }
2065 /*
2066   set_levent_script_mode(state)
2067   state is numeric or boolean state. true or non zero numbers turn on zero, false or nil turn off
2068   exact meaning is unknown, but it has something to do with the behavior of events and/or SetLogicalEventActive.
2069 */
2070 static int luaCB_set_levent_script_mode( lua_State* L )
2071 {
SetScriptMode(on_off_value_from_lua_arg(L,1));
2073   return 0;
2074 }
2076 /* 
2077   result=set_capture_mode_canon(value)
2078   where value is a valid PROPCASE_SHOOTING_MODE value for the current camera
2079   result is true if the camera is in rec mode
2080 */
2081 static int luaCB_set_capture_mode_canon( lua_State* L )
2082 {
2083   int modenum = luaL_checknumber(L,1);
2084   // if the value as negative, assume it is a mistakenly sign extended PROPCASE_SHOOTING_MODE value
2085   if(modenum < 0) 
modenum &= 0xFFFF;
lua_pushboolean( L, shooting_set_mode_canon(modenum) );
2088   return 1;
2089 }
2091 /*
2092  result=set_capture_mode(modenum)
2093  where modenum is a valid CHDK modemap value
2094  result is true if modenum is a valid modemap value, otherwise false
2095 */
2096 static int luaCB_set_capture_mode( lua_State* L )
2097 {
2098   int modenum = luaL_checknumber(L,1);
lua_pushboolean( L, shooting_set_mode_chdk(modenum) );
2100   return 1;
2101 }
2103 /*
2104  result=is_capture_mode_valid(modenum)
2105  where modenum is a valid CHDK modemap value
2106  result is true if modenum is a valid modemap value, otherwise false
2107 */
2108 static int luaCB_is_capture_mode_valid( lua_State* L )
2109 {
2110   int modenum = luaL_checknumber(L,1);
lua_pushboolean( L, shooting_mode_chdk2canon(modenum) != -1 );
2112   return 1;
2113 }
2115 /* 
2116   set_record(state)
2117   if state is 0 (or false) the camera is set to play mode. If 1 or true, the camera is set to record mode.
2118   NOTE: this only begins the mode change. Script should wait until get_mode() reflects the change,
2119   before doing anything that requires the new mode. e.g.
2120   set_record(true)
2121   while not get_mode() do
2122     sleep(10)
2123   end
2124   uses switch_mode_usb if required
2125 */
2126 static int luaCB_set_record( lua_State* L )
2127 {
shooting_set_playrec_mode(on_off_value_from_lua_arg(L,1));
2129   return 0;
2130 }
2132 // switch mode (0 = playback, 1 = record)
2133 // only for when USB is connected
2134 static int luaCB_switch_mode_usb( lua_State* L )
2135 {
switch_mode_usb(on_off_value_from_lua_arg(L,1));
2137   return 0;
2138 }
2140 /*
2141   result=force_analog_av(state)
2142   force state of analog video connector detect bit
2143   where 0 = don't force, 1 = on, 2 = off
2144   result true if implemented by port (ANALOG_AV_FLAG defined), false if not
2145   can be used to enable video out while using the AV bit as remote input
2146   NOTE: video out affects display resolution on some cameras, which 
2147   may not be accounted for in features like PTP live view, zebra, histrogram etc
2148   forcing video out while PTP is in use may cause problems on some cameras
2149 */
2150 static int luaCB_force_analog_av( lua_State* L )
2151 {
lua_pushboolean(L, kbd_force_analog_av(luaL_checknumber( L, 1 )));
2153   return 1;
2154 }
2156 /*
2157 pack the lua args into a buffer to pass to the native code calling functions 
2158 currently only handles strings/numbers
2159 start is the stack index of the first arg
2160 */
2161 static int pack_native_args( lua_State* L, unsigned start, unsigned *argbuf)
2162 {
2163   unsigned i;
2164   unsigned end = lua_gettop(L);
2166   for(i = start; i <= end; i++,argbuf++) {
2167     if (lua_type(L, i) == LUA_TSTRING) {
2168         *argbuf=(unsigned)lua_tostring( L, i);
2169     }
2170     else if (lua_type(L, i) == LUA_TNUMBER) {
2171         *argbuf=lua_tonumber( L, i);
2172     }
2173     else {
2174       return 0;
2175     }
2176   }
2177   return 1;
2178 }
2180 /*
2181 Native function call interface. Can be used to call canon eventprocs or arbitrary
2182 pointers.
2183 
2184 NOTE: this is preliminary, interface may change in later versions!
2185 All arguments must be strings or numbers.
2186 If the function expects to modify it's arguments via a pointer,
2187 then you must provide a number that is a valid pointer. 
2188 
2189 You can use the "AllocateMemory" eventproc to obtain buffers.
2190 
2191 If the function tries to write to a string passed from lua, Bad Things may happen.
2192 
2193 This is potentially dangerous, functions exist which can destroy the onboard firmware.
2194 */
2196 /*
2197 result=call_func_ptr(ptr,...)
2198 ptr: address of a valid ARM or Thumb function, which uses the normal C calling convention.
2199 result: R0 value after the call returns
2200 */
2201 static int luaCB_call_func_ptr( lua_State* L)
2202 {
2203     if (conf.script_allow_lua_native_calls)
2204     {
2205         unsigned *argbuf=NULL;
2206         unsigned n_args = lua_gettop(L)-1;
2207         void *fptr;
fptr=(void *)luaL_checknumber( L, 1 );
2211         if (n_args)
2212         {
argbuf=malloc(n_args * 4);
2214             if(!argbuf)
2215             {
2216                 return luaL_error( L, "malloc fail" );
2217             }
2218             if(!pack_native_args(L, 2, argbuf))
2219             {
free(argbuf);
2221                 return luaL_error( L, "expected string or number" );
2222             }
2223         }
lua_pushnumber( L, call_func_ptr(fptr, argbuf, n_args) );
free(argbuf);
2227         return 1;
2228     }
2229     return luaL_error( L, "native calls disabled" );
2230 }
2232 /* 
2233 Call an event procedure
2234 
2235 result=call_event_proc("EventprocName",...)
2236 result is the value returned by ExecuteEventProcedure, which is -1 if the eventproc is not found, 
2237 or the eventproc return value (which could also be -1)
2238 NOTE:
2239 Many eventprocs are not registered by default, but can be loaded by calling another event proc
2240 Some useful ones are
2241 SystemEventInit
2242     includes AllocateMemory, FreeMemory, sprintf, memcpy, Fut functions, log ...
2243 UI_RegistDebugEventProc
2244     includes capture mode functions, PTM_ functions and much more 
2245 RegisterProductTestEvent
2246     includes PT_ functions
2247 
2248 Others:
2249 RegisterShootSeqEvent
2250 RegisterNRTableEvent
2251 */
2253 // grab from lowlevel
2254 extern unsigned _ExecuteEventProcedure(const char *name,...);
2255 static int luaCB_call_event_proc( lua_State* L )
2256 {
2257     if (conf.script_allow_lua_native_calls)
2258     {
2259         const char *evpname;
2260         unsigned *argbuf;
2261         unsigned n_args = lua_gettop(L);
evpname=luaL_checkstring( L, 1 );
argbuf=malloc(n_args * 4);
2266         if (!argbuf)
2267         {
2268             return luaL_error( L, "malloc fail" );
2269         }
2271         // event proc name is first arg
2272         *argbuf = (unsigned)evpname;
2274         if(!pack_native_args(L,2,argbuf+1))
2275         {
free(argbuf);
2277             return luaL_error( L, "expected string or number" );
2278         }
lua_pushnumber( L, call_func_ptr(_ExecuteEventProcedure,argbuf,n_args) );
free(argbuf);
2282         return 1;
2283     }
2284     return luaL_error( L, "native calls disabled" );
2285 }
2287 /*
2288 result = reboot(["filename"])
2289 returns false on failure, does not return on success
2290 see lib/armutil/reboot.c for details
2291 */
2292 static int luaCB_reboot( lua_State* L )
2293 {
lua_pushboolean(L, reboot(luaL_optstring( L, 1, NULL )));
2295     return 1;
2296 }
2298 static int luaCB_get_config_value( lua_State* L ) {
2299     unsigned int argc = lua_gettop(L);
2300     unsigned int id, i;
2301     int ret = 1;
tConfigVal configVal;
2304     if( argc>=1 ) {
id = luaL_checknumber(L, 1);
2306         switch( conf_getValue(id, &configVal) ) {
2307             case CONF_VALUE:
lua_pushnumber(L, configVal.numb);
2309             break;
2310             case CONF_INT_PTR:
lua_createtable(L, 0, configVal.numb);
2312                 for( i=0; i<(unsigned)configVal.numb; i++ ) {
lua_pushinteger(L, configVal.pInt[i]);
lua_rawseti(L, -2, i+1);  //t[i+1]=configVal.pInt[i]
2315                 }
2316             break;
2317             case CONF_CHAR_PTR:
lua_pushstring(L, configVal.str);
2319             break;
2320             case CONF_OSD_POS:
lua_pushnumber(L, configVal.pos.x);
lua_pushnumber(L, configVal.pos.y); ret++;
2323             break;
2324             default:
2325                 if( argc>=2) { //Default
ret = argc-1;
2327                 } else {
lua_pushnil(L);
2329                 }
2330             break;
2331         }
2332     } else {
lua_pushnil(L);
2334     }
2335     return ret;
2336 }
2338 static int luaCB_set_config_value( lua_State* L ) {
2339     unsigned int argc = lua_gettop(L);
2340     unsigned int id, i, j;
tConfigVal configVal = {0};  //initialize isXXX
2343     if( argc>=2 ) {
id = luaL_checknumber(L, 1);
2345         for( i=2; i<=argc; i++) {
2346             switch( lua_type(L, i) ) {
2347                 case LUA_TNUMBER:
2348                     if( !configVal.isNumb ) {
configVal.numb = luaL_checknumber(L, i);
configVal.isNumb++;
2351                     }
2352                     switch( configVal.isPos ) {
2353                         case 0: configVal.pos.x = luaL_checknumber(L, i); configVal.isPos++; break;
2354                         case 1: configVal.pos.y = luaL_checknumber(L, i); configVal.isPos++; break;
2355                     }
2356                 break;
2357                 case LUA_TSTRING:
2358                     if( !configVal.isStr ) {
configVal.str = (char*)luaL_checkstring(L, i);
configVal.isStr++;
2361                     }
2362                 break;
2363                 case LUA_TTABLE:
2364                     if( !configVal.isPInt ) {
configVal.numb = lua_objlen(L, i);
2366                         if( configVal.pInt ) {
free(configVal.pInt);
configVal.pInt = NULL;
2369                         }
configVal.pInt = malloc(configVal.numb*sizeof(int));
2371                         if( configVal.pInt ) {
2372                             for( j=1; j<=(unsigned)configVal.numb; j++) {
lua_rawgeti(L, i, j);
configVal.pInt[j-1] = lua_tointeger(L, -1);
lua_pop(L, 1);
2376                             }
2377                         }
configVal.isPInt++;
2379                     }
2380                 break;
2381             }
2382         }
lua_pushboolean(L, conf_setValue(id, configVal));
2384         if( configVal.pInt ) {
free(configVal.pInt);
configVal.pInt = NULL;
2387         }
2388     } else lua_pushboolean(L, 0);
2389     return 1;
2390 }
2392 static int luaCB_set_config_autosave( lua_State* L ) {
conf_setAutosave(on_off_value_from_lua_arg(L, 1));
2394     return 0;
2395 }
2397 static int luaCB_save_config_file( lua_State* L ) {
lua_pushboolean(L, save_config_file(luaL_checknumber(L, 1), luaL_optstring(L, 2, NULL)));
2399     return 1;
2400 }
2402 static int luaCB_load_config_file( lua_State* L ) {
lua_pushboolean(L, load_config_file(luaL_checknumber(L, 1), luaL_optstring(L, 2, NULL)));
2404     return 1;
2405 }
2407 static int luaCB_set_file_attributes( lua_State* L ) {
lua_pushnumber(L, SetFileAttributes(luaL_checkstring(L, 1), luaL_checknumber(L, 2)));
2409     return 1;
2410 }
2412 static int action_stack_AS_SCRIPT_READ_USB_MSG()
2413 {
ptp_script_msg *msg = ptp_script_read_msg();
2416     if ((get_tick_count() >= action_top(2)) || msg)
2417     {
2418         if (msg && msg->data)
2419         {
lua_pushlstring(Lt,msg->data,msg->size);
2421         }
2422         else
2423         {
lua_pushnil(Lt);
2425         }
action_pop_func(1);
2427         return 1;
2428     }
2429     return 0;
2430 }
2432 static int action_stack_AS_SCRIPT_WRITE_USB_MSG()
2433 {
ptp_script_msg *msg = (ptp_script_msg *)action_top(2);
2436     int r = ptp_script_write_msg(msg);
2438     if ((get_tick_count() >= action_top(3)) || r)
2439     {
lua_pushboolean(Lt,r);
action_pop_func(2);
2442         return 1;
2443     }
2444     return 0;
2445 }
2447 /*
2448 msg = read_usb_msg([timeout])
2449 read a message from the CHDK ptp interface.
2450 Returns the next available message as a string, or nil if no messages are available
2451 If timeout is given and not zero, wait until a message is available or timeout expires
2452 */
2453 static int luaCB_read_usb_msg( lua_State* L )
2454 {
2455   int timeout = sleep_delay(luaL_optnumber(L,1,0));
2456   if (timeout > 0)
2457   {
action_push(timeout);
action_push_func(action_stack_AS_SCRIPT_READ_USB_MSG);
2460     return lua_yield( L, 0 );
2461   }
ptp_script_msg *msg = ptp_script_read_msg();
2463   if(msg)
2464   {
lua_pushlstring(L,msg->data,msg->size);
free(msg);
2467     return 1;
2468   }
lua_pushnil(L);
2470   return 1;
2471 }
2473 /*
2474 status = write_usb_msg(msg,[timeout])
2475 writes a message to the CHDK ptp interface
2476 msg may be nil, boolean, number, string or table (table has some restrictions, will be converted to string)
2477 returns true if the message was queued successfully, otherwise false
2478 if timeout is set and not zero, wait until message is written or timeout expires
2479 NOTE strings will not include a terminating NULL, must be handled by recipient
2480 */
2481 static int luaCB_write_usb_msg( lua_State* L )
2482 {
ptp_script_msg *msg;
2484   int timeout = sleep_delay(luaL_optnumber(L,2,0));
2485   // TODO would it be better to either ignore this or return nil ?
2486   // a write_usb_msg(function_which_returns_no_value()) is an error in this case
2487   // replacing with nil might be more luaish
2488   if (lua_gettop(L) < 1)
2489   {
2490     return luaL_error(L,"missing argument");
2491   }
msg=lua_create_usb_msg(L,1,PTP_CHDK_S_MSGTYPE_USER);
2493   // for user messages, trying to create a message from an incompatible type throws an error
2494   if (msg->subtype == PTP_CHDK_TYPE_UNSUPPORTED)
2495   {
free(msg);
2497     return luaL_error(L,"unsupported type");
2498   }
2499   if (!msg)
2500   {
2501     return luaL_error(L,"failed to create message");
2502   }
2503   if (timeout)
2504   {
action_push(timeout);
action_push((int)msg);
action_push_func(action_stack_AS_SCRIPT_WRITE_USB_MSG);
2508     return lua_yield( L, 0 );
2509   }
lua_pushboolean(L,ptp_script_write_msg(msg)); 
2511   return 1;
2512 }
2514 /* helper for meminfo to set table field only if valid */
2515 static void set_meminfo_num( lua_State* L,const char *name, int val) {
2516     if(val != -1) {
set_number_field( L, name, val );
2518     }
2519 }
2520 /*
2521 meminfo=get_meminfo([heapname])
2522 get camera memory information
2523 heapname="combined", "system", "aram" or "exmem" 
2524 if not given, combined is returned
2525 meminfo is false if the requested heapname isn't valid ("exmem" when exmem is not enabled, or unknown)
2526 otherwise, a table of the form
2527 meminfo = {
2528     name -- heapname, as above
2529     chdk_malloc -- bool, this is the heap used by CHDK for malloc
2530     chdk_start -- number, load address of CHDK
2531     chdk_size -- number, size of CHDK image
2532     -- all the following are numbers, will not be set if not available
2533     start_address
2534     end_address
2535     total_size
2536     allocated_size
2537     allocated_peak
2538     allocated_count
2539     free_size
2540     free_block_max_size
2541     free_block_count
2542 }
2543 NOTES
2544 * under vxworks and cameras without GetMemInfo only the only valid fields
2545   for the system heap will be those defined by chdk and free_block_max_size
2546 * the meaning of fields may not correspond exactly between exmem and system
2547 */
2548 static int luaCB_get_meminfo( lua_State* L ) {
2549     const char *heapname = luaL_optstring( L, 1, "combined" );
cam_meminfo meminfo;
2551     if (strcmp(heapname,"combined") == 0) {
GetCombinedMemInfo(&meminfo);
meminfo.start_address=meminfo.end_address=-1; // not meaningful
2554     }
2555     else if (strcmp(heapname,"system") == 0)
2556     {
GetMemInfo(&meminfo);
2558     }
2559     else if ((strcmp(heapname,"aram") == 0))
2560     {
2561         if(!GetARamInfo(&meminfo)) {
lua_pushboolean(L,0);
2563             return 1;
2564         }
2565     }
2566     else if (strcmp(heapname,"exmem") == 0)
2567     {
2568         if(!GetExMemInfo(&meminfo)) {;
lua_pushboolean(L,0);
2570             return 1;
2571         }
2572     }
2573     else
2574     {
lua_pushboolean(L,0);
2576         return 1;
2577     }
2578     // adjust start and size, if CHDK is loaded at heap start
2579     if(meminfo.start_address == camera_info.text_start) {
meminfo.start_address += camera_info.memisosize;
meminfo.total_size -= camera_info.memisosize;
2582     }
lua_createtable(L, 0, 13); // might not always use 13, but doesn't hurt
set_string_field( L,"name", heapname );
2585     // CHDK allocates from all available heaps now
lua_pushboolean( L, 1);
lua_setfield(L, -2, "chdk_malloc");
set_number_field( L, "chdk_start", camera_info.text_start);
set_number_field( L, "chdk_size", camera_info.memisosize );
set_meminfo_num( L, "start_address", meminfo.start_address );
set_meminfo_num( L, "end_address", meminfo.end_address);
set_meminfo_num( L, "total_size", meminfo.total_size);
set_meminfo_num( L, "allocated_size", meminfo.allocated_size);
set_meminfo_num( L, "allocated_peak", meminfo.allocated_peak);
set_meminfo_num( L, "allocated_count", meminfo.allocated_count);
set_meminfo_num( L, "free_size", meminfo.free_size);
set_meminfo_num( L, "free_block_max_size", meminfo.free_block_max_size);
set_meminfo_num( L, "free_block_count", meminfo.free_block_count);
2599     return 1;
2600 }
2602 /*
2603 set scheduling parameters
2604 old_max_count,old_max_ms=set_yield(max_count,max_ms)
2605 */
2606 static int luaCB_set_yield( lua_State* L )
2607 {
lua_pushnumber(L,yield_max_count);
lua_pushnumber(L,yield_max_ms);
yield_max_count = luaL_optnumber(L,1,YIELD_MAX_COUNT_DEFAULT);
yield_max_ms = luaL_optnumber(L,2,YIELD_MAX_MS_DEFAULT);
2612   return 2;
2613 }
2615 //static void register_func( lua_State* L, const char *name, void *func) {
2616 //  lua_pushcfunction( L, func );
2617 //  lua_setglobal( L, name );
2618 //}
2619 /*
2620 get remote capture supported types
2621 bitmask=get_usb_capture_support()
2622 */
2623 static int luaCB_get_usb_capture_support( lua_State* L )
2624 {
lua_pushnumber(L,remotecap_get_target_support());
2626     return 1;
2627 }
2629 /*
2630 status=init_usb_capture(bitmask[,startline, numlines])
2631 bitmask = 0 clear usb capture mode
2632 
2633 lines only applies to raw
2634 startline defaults to 0
2635 numlines defaults to full buffer
2636 */
2637 static int luaCB_init_usb_capture( lua_State* L )
2638 {
2639     int what=luaL_checknumber(L, 1);
2640     int startline=luaL_optnumber(L, 2, 0);
2641     int numlines=luaL_optnumber(L, 3, 0);
lua_pushboolean(L,remotecap_set_target(what,startline,numlines));
2643     return 1;
2644 }
2646 /*
2647 selected=get_usb_capture_target()
2648 selected = bitmask passed to init, or 0 if capture not configured or timed out/canceled
2649 */
2650 static int luaCB_get_usb_capture_target( lua_State* L )
2651 {
lua_pushnumber(L,remotecap_get_target());
2653     return 1;
2654 }
2656 /*
2657 set_remotecap_timeout([timeout])
2658 timeout:
2659 number of milliseconds remote capture waits for data of each type to be downloaded
2660 <=0 or no value resets to the default value
2661 If any data type is not downloaded before the timeout expires, remote capture is canceled
2662 and none of the subsequent data types will be returned
2663 following a timeout, RemoteCaptureIsReady and RemoteCaptureGetData will behave as if
2664 remote capture were not initialized
2665 If the timeout expires while a transfer is in progress, an error will be generated
2666 and the data may be incomplete or corrupt
2667 */
2668 static int luaCB_set_usb_capture_timeout( lua_State* L )
2669 {
remotecap_set_timeout(luaL_optnumber(L,1,0));
2671     return 0;
2672 }
2674 //------------------------------------------------------------------------------------------
2675 // APEX conversion functions
2677 static int luaCB_iso_to_sv96( lua_State* L )
2678 {
lua_pushnumber(L, shooting_get_sv96_from_iso(luaL_checknumber(L, 1)));
2680   return 1;
2681 }
2683 static int luaCB_sv96_to_iso( lua_State* L )
2684 {
lua_pushnumber(L, shooting_get_iso_from_sv96(luaL_checknumber(L, 1)));
2686   return 1;
2687 }
2689 static int luaCB_iso_real_to_market( lua_State* L )
2690 {
lua_pushnumber(L, shooting_iso_real_to_market(luaL_checknumber(L, 1)));
2692   return 1;
2693 }
2695 static int luaCB_iso_market_to_real( lua_State* L )
2696 {
lua_pushnumber(L, shooting_iso_market_to_real(luaL_checknumber(L, 1)));
2698   return 1;
2699 }
2701 static int luaCB_sv96_real_to_market( lua_State* L )
2702 {
lua_pushnumber(L, shooting_sv96_real_to_market(luaL_checknumber(L, 1)));
2704   return 1;
2705 }
2707 static int luaCB_sv96_market_to_real( lua_State* L )
2708 {
lua_pushnumber(L, shooting_sv96_market_to_real(luaL_checknumber(L, 1)));
2710   return 1;
2711 }
2713 static int luaCB_aperture_to_av96( lua_State* L )
2714 {
lua_pushnumber(L, shooting_get_av96_from_aperture(luaL_checknumber(L, 1)));
2716   return 1;
2717 }
2719 static int luaCB_av96_to_aperture( lua_State* L )
2720 {
lua_pushnumber(L, shooting_get_aperture_from_av96(luaL_checknumber(L, 1)));
2722   return 1;
2723 }
2725 static int luaCB_usec_to_tv96( lua_State* L )
2726 {
lua_pushnumber(L, shooting_get_tv96_from_shutter_speed((float)luaL_checknumber(L, 1)/1000000.0));
2728   return 1;
2729 }
2731 static int luaCB_tv96_to_usec( lua_State* L )
2732 {
lua_pushnumber(L, (int)(shooting_get_shutter_speed_from_tv96(luaL_checknumber(L, 1)) * 1000000.0 + 0.5));
2734   return 1;
2735 }
2737 static int luaCB_seconds_to_tv96( lua_State* L )
2738 {
lua_pushnumber(L, shooting_get_tv96_from_shutter_speed((float)luaL_checknumber(L, 1)/(float)luaL_checknumber(L, 2)));
2740   return 1;
2741 }
2743 //------------------------------------------------------------------------------------------
2744 // Shoot hooks
2746 /*
2747 hook.set(timeout)
2748 cause hook to block shooting process until timeout or script issues hook.continue
2749 0 clears
2750 */
2751 static int luaCB_shoot_hook_set( lua_State* L )
2752 {
2753     int hook = lua_tonumber( L, lua_upvalueindex(1) );
script_shoot_hook_set(hook,luaL_checknumber(L, 1));
2755     return 0;
2756 }
2758 /*
2759 hook.is_ready()
2760 returns true if the hooked task is in the hook
2761 */
2762 static int luaCB_shoot_hook_is_ready( lua_State* L )
2763 {
2764     int hook = lua_tonumber( L, lua_upvalueindex(1) );
lua_pushboolean(L,script_shoot_hook_ready(hook));
2766     return 1;
2767 }
2769 /*
2770 hook.continue()
2771 allow the hooked task to leave the hook
2772 */
2773 static int luaCB_shoot_hook_continue( lua_State* L )
2774 {
2775     int hook = lua_tonumber( L, lua_upvalueindex(1) );
script_shoot_hook_continue(hook);
2777     return 0;
2778 }
2780 /*
2781 n=hook.count()
2782 return the number of times the hook has been reached since script start
2783 note: counts regardless of whether hook is enabled
2784 */
2785 static int luaCB_shoot_hook_count( lua_State* L )
2786 {
2787     int hook = lua_tonumber( L, lua_upvalueindex(1) );
lua_pushnumber(L,script_shoot_hook_count(hook));
2789     return 1;
2790 }
2792 //------------------------------------------------------------------------------------------
2794 #define FUNC( X ) { #X, luaCB_##X },
2795 static const luaL_Reg chdk_funcs[] = {
FUNC(shoot)
FUNC(sleep)
FUNC(cls)
FUNC(set_console_layout)
FUNC(set_console_autoredraw)
FUNC(console_redraw)
FUNC(get_av96)
FUNC(get_bv96)
FUNC(get_day_seconds)
FUNC(get_disk_size)
FUNC(get_dofinfo)
FUNC(get_free_disk_space)
FUNC(get_focus)
FUNC(get_iso_market)
FUNC(get_iso_mode)
FUNC(get_iso_real)
FUNC(get_jpg_count)
FUNC(get_prop)
FUNC(get_prop_str)
FUNC(get_raw_support)
FUNC(get_raw_count)
FUNC(get_raw_nr)
FUNC(get_raw)
FUNC(get_sv96)
FUNC(get_tick_count)
FUNC(get_tv96)
FUNC(get_user_av_id)
FUNC(get_user_av96)
FUNC(get_user_tv_id)
FUNC(get_user_tv96)
FUNC(get_vbatt)
FUNC(get_zoom)
FUNC(get_exp_count)
FUNC(get_image_dir)
FUNC(get_flash_params_count)
FUNC(get_parameter_data)
FUNC(get_min_av96)
FUNC(get_max_av96)
FUNC(get_nd_value_ev96)
FUNC(get_nd_current_ev96)
FUNC(get_current_av96)
FUNC(get_current_tv96)
FUNC(get_imager_active)
FUNC(get_canon_image_format)
FUNC(get_canon_raw_support)
FUNC(set_av96_direct)
FUNC(set_av96)
FUNC(set_canon_image_format)
FUNC(set_focus)
FUNC(set_focus_interlock_bypass)
FUNC(set_iso_mode)
FUNC(set_iso_real)
FUNC(set_led)
FUNC(set_nd_filter)
FUNC(set_prop)
FUNC(set_prop_str)
FUNC(set_raw_nr)
FUNC(set_raw)
FUNC(set_sv96)
FUNC(set_tv96_direct)
FUNC(set_tv96)
FUNC(set_user_av_by_id_rel)
FUNC(set_user_av_by_id)
FUNC(set_user_av96)
FUNC(set_user_tv_by_id_rel)
FUNC(set_user_tv_by_id)
FUNC(set_user_tv96)
FUNC(set_zoom_speed)
FUNC(set_zoom_rel)
FUNC(set_zoom)
FUNC(wait_click)
FUNC(is_pressed)
FUNC(is_key)
FUNC(set_exit_key)
FUNC(wheel_right)
FUNC(wheel_left)
FUNC(md_get_cell_diff)
FUNC(md_get_cell_val)
FUNC(md_detect_motion)
FUNC(md_af_led_control)
FUNC(autostarted)
FUNC(get_autostart)
FUNC(set_autostart)
FUNC(get_usb_power)
FUNC(set_remote_timing)
FUNC(usb_force_active)
FUNC(usb_sync_wait)
FUNC(enter_alt)
FUNC(exit_alt)
FUNC(get_alt_mode)
FUNC(shut_down)
FUNC(print_screen)
FUNC(get_partitionInfo)
FUNC(swap_partitions)
FUNC(get_focus_mode)
FUNC(get_focus_state)
FUNC(get_focus_ok)
FUNC(get_propset)
FUNC(get_zoom_steps)
FUNC(get_drive_mode)
FUNC(get_flash_mode)
FUNC(get_shooting)
FUNC(get_flash_ready)
FUNC(get_IS_mode)
FUNC(set_ev)
FUNC(get_ev)
FUNC(get_orientation_sensor)
FUNC(get_nd_present)
FUNC(get_movie_status)
FUNC(set_movie_status)
FUNC(get_video_button)
FUNC(get_video_recording)
FUNC(get_histo_range)
FUNC(shot_histo_enable)
FUNC(shot_histo_write_to_file)
FUNC(get_live_histo)
FUNC(play_sound)
FUNC(get_temperature)
FUNC(peek)
FUNC(poke)
FUNC(bitand)
FUNC(bitor)
FUNC(bitxor)
FUNC(bitshl)
FUNC(bitshri)
FUNC(bitshru)
FUNC(bitnot)
FUNC(get_time)
FUNC(set_clock)
FUNC(get_buildinfo)
FUNC(get_mode)
FUNC(set_raw_develop)
2936     // NOTE these functions normally run in the spytask.
2937     // called from lua they will run from kbd task instead
FUNC(raw_merge_start)
FUNC(raw_merge_add_file)
FUNC(raw_merge_end)
FUNC(set_backlight)
FUNC(set_lcd_display)
FUNC(set_draw_title_line)
FUNC(get_draw_title_line)
FUNC(set_aelock)
FUNC(set_aflock)
FUNC(set_mf)
FUNC(get_sd_over_modes)
FUNC(set_curve_state)
FUNC(get_curve_state)
FUNC(set_curve_file)
FUNC(get_curve_file)
2953     // get levent definition by name or id, nil if not found
FUNC(get_levent_def)
2955     // get levent definition by index, nil if out of range
FUNC(get_levent_def_by_index)
2957     // get levent index from name or ID
FUNC(get_levent_index)
FUNC(post_levent_to_ui)
FUNC(post_levent_for_npt)
FUNC(set_levent_active)
FUNC(set_levent_script_mode)
FUNC(set_capture_mode)
FUNC(set_capture_mode_canon)
FUNC(is_capture_mode_valid)
FUNC(set_record)
FUNC(switch_mode_usb)
FUNC(force_analog_av)
FUNC(call_event_proc)
FUNC(call_func_ptr)
FUNC(reboot)
FUNC(get_config_value)
FUNC(set_config_value)
FUNC(set_config_autosave)
FUNC(save_config_file)
FUNC(load_config_file)
FUNC(set_file_attributes)
FUNC(get_meminfo)
FUNC(file_browser)
FUNC(textbox)
FUNC(draw_pixel)
FUNC(draw_line)
FUNC(draw_rect)
FUNC(draw_rect_filled)
FUNC(draw_ellipse)
FUNC(draw_ellipse_filled)
FUNC(draw_clear)
FUNC(draw_string)
FUNC(get_gui_screen_width)
FUNC(get_gui_screen_height)
FUNC(set_yield)
FUNC(read_usb_msg)
FUNC(write_usb_msg)
FUNC(get_usb_capture_support)
FUNC(init_usb_capture)
FUNC(get_usb_capture_target)
FUNC(set_usb_capture_timeout)
FUNC(iso_to_sv96)
FUNC(sv96_to_iso)
FUNC(iso_real_to_market)
FUNC(iso_market_to_real)
FUNC(sv96_real_to_market)
FUNC(sv96_market_to_real)
FUNC(aperture_to_av96)
FUNC(av96_to_aperture)
FUNC(usec_to_tv96)
FUNC(tv96_to_usec)
FUNC(seconds_to_tv96)
3018     {NULL, NULL},
3019 };
3021 void register_shoot_hook_fn(lua_State* L, int hook, void *hook_fn, const char *name)
3022 {
lua_pushnumber( L, hook );
lua_pushcclosure( L, hook_fn, 1 );
lua_setfield( L, -2, name);
3026 }
3028 void register_shoot_hooks( lua_State* L )
3029 {
3030     int i;
3031     for(i=0; i<SCRIPT_NUM_SHOOT_HOOKS;i++) {
lua_createtable(L, 0, 4);
register_shoot_hook_fn(L,i,luaCB_shoot_hook_set,"set");
3034 //        register_shoot_hook_fn(L,i,luaCB_shoot_hook_wait_ready,"wait_ready");
register_shoot_hook_fn(L,i,luaCB_shoot_hook_is_ready,"is_ready");
register_shoot_hook_fn(L,i,luaCB_shoot_hook_continue,"continue");
register_shoot_hook_fn(L,i,luaCB_shoot_hook_count,"count");
lua_setglobal( L, shoot_hook_names[i] );
3039     }
3040 }
3042 void register_lua_funcs( lua_State* L )
3043 {
3044   const luaL_reg *r;
register_shoot_hooks( L );
luaopen_rawop( L );
lua_pushlightuserdata( L, action_push_click );
lua_pushcclosure( L, luaCB_keyfunc, 1 );
lua_setglobal( L, "click" );
lua_pushlightuserdata( L, action_push_press );
lua_pushcclosure( L, luaCB_keyfunc, 1 );
lua_setglobal( L, "press" );
lua_pushlightuserdata( L, action_push_release );
lua_pushcclosure( L, luaCB_keyfunc, 1 );
lua_setglobal( L, "release" );
3061   for(r=chdk_funcs;r->name;r++) {
lua_pushcfunction( L, r->func );
lua_setglobal( L, r->name );
3064   }
3065   (void)luaL_dostring(L,"function usb_msg_table_to_string(t)"
3066                     " local v2s=function(v)"
3067                         " local t=type(v)"
3068                         " if t=='string' then return v end"
3069                         " if t=='number' or t=='boolean' or t=='nil' then return tostring(v) end"
3070                         " return '' end"
3071                     " local r=''"
3072                     " for k,v in pairs(t) do"
3073                         " local s,vs=''"
3074                         " if type(v)=='table' then"
3075                             " for i=1,table.maxn(v) do"
3076                             " s=s..'\\t'..v2s(v[i]) end"
3077                         " else"
3078                             " vs=v2s(v)"
3079                             " if #vs then s=s..'\\t'..vs end"
3080                         " end"
3081                         " vs=v2s(k)"
3082                         " if #vs>0 and #s>0 then r=r..vs..s..'\\n' end"
3083                     " end"
3084                     " return r"
3085                    " end");
3087 }
3089 // =========  MODULE INIT =================
3091 /***************** BEGIN OF AUXILARY PART *********************
3092   ATTENTION: DO NOT REMOVE OR CHANGE SIGNATURES IN THIS SECTION
3093  **************************************************************/
3095 static void lua_set_variable(char *name, int value, int isBool, int isTable, int labelCount, const char **labels)
3096 {
lua_pushstring( L, name );
3098     if (isTable)
3099     {
lua_createtable(L, labelCount, 2);
3101         int i;
3102         for (i=0; i<labelCount; i++)
3103         {
lua_pushstring(L,labels[i]);
lua_rawseti(L,-2,i+1);
3106         }
SET_INT_FIELD("index", value+1);        // Make value 1 based for Lua table index
SET_STR_FIELD("value", labels[value]);
3109     }
3110     else
3111     {
3112         if (isBool)
lua_pushboolean( L, value );
3114         else
lua_pushnumber( L, value );
3116     }
lua_settable( L, LUA_GLOBALSINDEX );
3118 }
3120 static void lua_set_as_ret(int md_ret)                  { lua_pushnumber(Lt,md_ret); }
3122 /******************** Module Information structure ******************/
libscriptapi_sym _liblua =
3125 {
3126     {
3127          0, 0, 0, 0, 0
3128     },
lua_script_start,
lua_script_start_file,
lua_script_run,
lua_script_reset,
lua_set_variable,
lua_set_as_ret,
lua_run_restore,
script_shoot_hook_run,
3138 };
ModuleInfo _module_info =
3141 {
MODULEINFO_V1_MAGICNUM,
3143     sizeof(ModuleInfo),
SCRIPT_API_VERSION,         // Module version
ANY_CHDK_BRANCH, 0, OPT_ARCHITECTURE,   // Requirements of CHDK version
ANY_PLATFORM_ALLOWED,       // Specify platform dependency
3149     -LANG_MODULE_LUA,           // Module name
MTYPE_SCRIPT_LANG,          //Run Lua Scripts
3152     &_liblua.base,
CONF_VERSION,               // CONF version
CAM_SCREEN_VERSION,         // CAM SCREEN version
CAM_SENSOR_VERSION,         // CAM SENSOR version
CAM_INFO_VERSION,           // CAM INFO version
3159     0,
3160 };
3162 /*************** END OF AUXILARY PART *******************/