root/modules/scrdump.c

DEFINITIONS

1. send_data_to_file
2. scrdump_start
3. scrdump_frame
4. scrdump_finish
5. scrdump_task
6. scrdump_schedule
7. scrdump_menu_schedule
8. scrdump_menu_exit
9. _run
10. _module_unloader
11. _module_can_unload

   1 #include "camera_info.h"
   2 #include "lang.h"
   3 #include "conf.h"
   4 #include "shooting.h"
   5 #include "time.h"
   6 #include "clock.h"
   7 #include "task.h"
   9 #include "gui.h"
  10 #include "gui_menu.h"
  11 #include "gui_lang.h"
  12 #include "semaphore.h"
  14 static int running = 0;
  16 typedef struct {
  17     int handle;
  18     int (*send_data)(int handle, const char *buf, int part_size, int total_size, int, int, int); // total_size will be 0 except for the first call
  19 } dummy_ptp_data;
  21 extern int live_view_get_data(dummy_ptp_data *data, int flags);
  23 int send_data_to_file(int handle, const char *buf, int part_size, int total_size, __attribute__ ((unused))int u1, __attribute__ ((unused))int u2, __attribute__ ((unused))int u3)
  24 {
  25     // TODO write on some cams may require uncached, buffers are but structs + palette may not be
  26     // only the first call has total size set, write length of following record
  27     if(total_size) {
write(handle, &total_size, sizeof(total_size));
  29     }
write(handle, buf, part_size);
  31     return 0;
  32 }
  33 static dummy_ptp_data ptp_data = {
  34     -1,
send_data_to_file,
  36 };
  37 static char fn[32];
  39 static int scrdump_start(void)
  40 {
running = 1;
  42     int fd;
  43     static int lvdump_header[] = {
  44         0x766c6863, // magic chlv
  45         8, // size of version record
  46         1, // major ver
  47         0, // minor ver
  48     };
  49     // could be desirable but unlikely to work well. Better to use PTP
  50     if ( is_video_recording() ) {
  51         return -1;
  52     }
  53     // TODO might want to allow specifying name
mkdir("A/DCIM");
mkdir("A/DCIM/100CANON");
fd = -1;
  57     int cnt = 0;
  58     do {
sprintf(fn, "A/DCIM/100CANON/CRW_%04d.JPG", cnt++);
  60         if (stat(fn,0) != 0) {
fd = open(fn, O_WRONLY|O_CREAT, 0777);
  62             break;
  63         }
  64     } while(cnt<9999);
  65     if (fd>=0) {
ptp_data.handle = fd;
  67         // TODO write on some cams may require uncached
write(fd, lvdump_header,sizeof(lvdump_header));
  69         return 0;
  70     }
  71     return -1;
  72 }
  73 static void scrdump_frame(int what)
  74 {
  75     // TODO could limit frames, time, roll over files at specific size
  76     if(ptp_data.handle >= 0) {
live_view_get_data(&ptp_data,what);
  78     }
  79 }
  80 static void scrdump_finish(void)
  81 {
  82     if(ptp_data.handle >= 0) {
close(ptp_data.handle);
ptp_data.handle = -1;
  85         struct utimbuf t;
t.actime = t.modtime = time(NULL);
utime(fn, &t);
  88     }
  89 }
  91 // commands from the gui to the dumper task
  92 enum SCRDUMP_CMD
  93 {
SCRDUMP_CMD_NONE = 0, // no command
SCRDUMP_CMD_SCHEDULE, // schedule a dump
SCRDUMP_CMD_EXIT,     // end task, ending any current dump
  97 };
  99 #define CMD_SEM_TIMEOUT 1000
 100 static int cmd_sem;   // semaphore for command and settings
 101 static int cmd_next;  // command for dumper task, cleared on receipt
 103 typedef struct {
 104     int frame_buffers; // buffer selection, as used by live_view_get_data
 105     int frame_count;   // number of frames to grab
 106     int frame_time;    // ms between frame starts
 107     int start_delay;   // ms delay from dump request to dump start
 108 } scrdump_settings_t;
scrdump_settings_t settings_next; // settings from menu on SCRDUMP_CMD_SCHEDULE
 112 // states of the dumper task
 113 enum SCRDUMP_STATE
 114 {
SCRDUMP_STATE_IDLE = 0, // nothing scheduled, just poll for commands
SCRDUMP_STATE_PENDING,  // dump requested, not started
SCRDUMP_STATE_RUN,      // dump frames
 118 };
 121 static int scrdump_task_running;
 122 void scrdump_task(void)
 123 {
 124     static scrdump_settings_t settings;
 126     int state = SCRDUMP_STATE_IDLE;
 127     int frames_left = 0;
 129     unsigned next_action_tick = get_tick_count();
 131     while(1) {
 132         if (!TakeSemaphore(cmd_sem, CMD_SEM_TIMEOUT)) {
 133             int cmd = cmd_next;
cmd_next = SCRDUMP_CMD_NONE;
 135             if(cmd == SCRDUMP_CMD_SCHEDULE) {
 136                 if(state == SCRDUMP_STATE_RUN) {
scrdump_finish();
 138                 }
memcpy(&settings,&settings_next,sizeof(settings));
next_action_tick = (unsigned)get_tick_count() + settings.start_delay;
frames_left = settings.frame_count;
state = SCRDUMP_STATE_PENDING;
 143             } else if(cmd == SCRDUMP_CMD_EXIT) {
GiveSemaphore(cmd_sem);
 145                 if(state == SCRDUMP_STATE_RUN) {
scrdump_finish();
 147                 }
 148                 break;
 149             }
GiveSemaphore(cmd_sem);
 151         }
 152         if(state == SCRDUMP_STATE_PENDING) {
 153             if(next_action_tick <= (unsigned)get_tick_count()) {
 154                 // if starting dump now, schedule first frame immediately, next_action_tick unchanged
 155                 if(scrdump_start() == 0) {
state = SCRDUMP_STATE_RUN;
 157                 } else { // failed
state = SCRDUMP_STATE_IDLE;
 159                 }
 160             }
 161         }
 162         if(state == SCRDUMP_STATE_RUN) {
 163             unsigned t = (unsigned)get_tick_count();
 164             if(next_action_tick <= t) {
 165                 if(frames_left > 0) {
scrdump_frame(settings.frame_buffers);
frames_left--;
 169                     // next frame from the start of this frame
next_action_tick = t + settings.frame_time;
 171                 }
 172                 if(frames_left == 0) {
scrdump_finish();
state = SCRDUMP_STATE_IDLE;
 175                 }
 176             }
 177         }
 178         if(state == SCRDUMP_STATE_IDLE) {
next_action_tick =  (unsigned)get_tick_count() + 100;
 180         }
 182         unsigned now = (unsigned)get_tick_count();
 183         if(next_action_tick >= now) {
 184             unsigned sleep_time = next_action_tick - now;
 185             // sleep a maximum of 100ms to receive commands
 186             // minimum of 10 to avoid hogging cpu
 187             if(sleep_time > 100) {
sleep_time = 100;
 189             } else if(sleep_time < 10) {
sleep_time = 10;
 191             }
msleep((long)sleep_time);
 193         } else {
msleep(10);
 195         }
 196     }
scrdump_task_running = 0;
ExitTask();
 199 }
 201 // menu values
 202 static int scrdump_frames = 1;
 203 static int scrdump_frame_delay = 10;
 204 static int scrdump_buffers = 2; // both
 205 static int scrdump_skip = 0;
 206 static int scrdump_delay = 5;
 208 void scrdump_schedule(void) {
 209     // if it times out, cmd is ignored
 210     if (!TakeSemaphore(cmd_sem, CMD_SEM_TIMEOUT)) {
cmd_next = SCRDUMP_CMD_SCHEDULE;
 212         // 1 = bitmap 2 = both
 213         if(scrdump_buffers > 0) {
settings_next.frame_buffers = 0x4;
 215             // skip only applies if bitmap selected
 216             // TODO could theoretically want alpha only on d6?
 217             if(!scrdump_skip) {
 218 #ifdef THUMB_FW
settings_next.frame_buffers |= 0x10;
 220 #else
settings_next.frame_buffers |= 0x8;
 222 #endif
 223             }
 224         }
 225         // viewport setting
 226         // 0 = viewport 2 = both
 227         if(scrdump_buffers == 0 || scrdump_buffers == 2) {
settings_next.frame_buffers |= 1;
 229         }
settings_next.frame_count = scrdump_frames;
settings_next.frame_time = scrdump_frame_delay*10;
settings_next.start_delay = scrdump_delay*1000;
GiveSemaphore(cmd_sem);
 234     }
 235 }
 236 void scrdump_menu_schedule(void)
 237 {
scrdump_schedule();
gui_set_mode(&altGuiHandler);
 240 }
 242 void scrdump_menu_exit(void)
 243 {
 244     // if it times out, cmd is ignored
 245     if (!TakeSemaphore(cmd_sem, CMD_SEM_TIMEOUT)) {
cmd_next = SCRDUMP_CMD_EXIT;
GiveSemaphore(cmd_sem);
 248         while(scrdump_task_running) {
msleep(10);
 250         }
gui_set_mode(&altGuiHandler);
running = 0;
 253     }
 254 }
 257 static const char* scrdump_buffer_names[] =            { "Viewprt", "Bitmap", "Both"};
 258 static CMenuItem scrdump_submenu_items[] = {
MENU_ITEM   (0x5c,(int)"Schedule dump",                 MENUITEM_PROC,                  scrdump_menu_schedule,      0 ),
MENU_ITEM   (0x2a,(int)"Frames",                        MENUITEM_INT|MENUITEM_F_UNSIGNED|MENUITEM_F_MINMAX,   &scrdump_frames, MENU_MINMAX(1, 1000) ),
MENU_ITEM   (0x2a,(int)"Frame Time (ms*10)",            MENUITEM_INT|MENUITEM_F_UNSIGNED|MENUITEM_F_MINMAX,   &scrdump_frame_delay, MENU_MINMAX(4, 1000)),
MENU_ENUM2  (0x5c,(int)"Framebuffers",                  &scrdump_buffers,               scrdump_buffer_names ),
 263 #ifdef THUMB_FW
MENU_ITEM   (0x5c,(int)"Skip Opacity",                  MENUITEM_BOOL,                  &scrdump_skip,         0 ),
 265 #else
MENU_ITEM   (0x5c,(int)"Skip Palette",                  MENUITEM_BOOL,                  &scrdump_skip,         0 ),
 267 #endif
MENU_ITEM   (0x2a,(int)"Dump Start Delay (s)",          MENUITEM_INT|MENUITEM_F_UNSIGNED|MENUITEM_F_MINMAX,   &scrdump_delay, MENU_MINMAX(0, 60)),
MENU_ITEM   (0x5c,(int)"Exit module",                   MENUITEM_PROC,                  scrdump_menu_exit,      0 ),
MENU_ITEM   (0x51,LANG_MENU_BACK,                       MENUITEM_UP,                    0,                                  0 ),
 271     {0}
 272 };
 274 static CMenu scrdump_submenu = {0x2a,(int)"Screen Dump Settings", scrdump_submenu_items };
 276 int _run()
 277 {
running = 1;
 279     if(!cmd_sem) {
cmd_sem = CreateBinarySemaphore("ScrDumpCmd", 1);
 281     }
 282     if(!scrdump_task_running) {
 283         // lower priority (higher number) than spytask, like dng reverser
CreateTask("ScrDump",0x1A,0x800,scrdump_task);
scrdump_task_running = 1;
 286     }
gui_activate_sub_menu(&scrdump_submenu);
 289     return 0;
 290 }
 292 #include "simple_module.h"
 294 // =========  MODULE INIT =================
 296 /***************** BEGIN OF AUXILARY PART *********************
 297   ATTENTION: DO NOT REMOVE OR CHANGE SIGNATURES IN THIS SECTION
 298  **************************************************************/
 300 //---------------------------------------------------------
 301 // PURPOSE: Finalize module operations (close allocs, etc)
 302 // RETURN VALUE: 0-ok, 1-fail
 303 //---------------------------------------------------------
 304 int _module_unloader()
 305 {
 306     if(cmd_sem) {
DeleteSemaphore(cmd_sem);
 308     }
 309     return 0;
 310 }
 312 int _module_can_unload()
 313 {
 314     return (running == 0);
 315 }
 317 /******************** Module Information structure ******************/
libsimple_sym _libscrdump =
 320 {
 321     {
 322         0, _module_unloader, _module_can_unload, 0, _run
 323     },
 324 };
ModuleInfo _module_info = {
MODULEINFO_V1_MAGICNUM,
 328     sizeof(ModuleInfo),
SIMPLE_MODULE_VERSION,        // Module version
ANY_CHDK_BRANCH, 0, OPT_ARCHITECTURE,         // Requirements of CHDK version
ANY_PLATFORM_ALLOWED,       // Specify platform dependency
 334     (int)"Screen Record",
MTYPE_TOOL|MTYPE_SUBMENU_TOOL, // configure with menu
 337     &_libscrdump.base,
CONF_VERSION,               // CONF version
CAM_SCREEN_VERSION,         // CAM SCREEN version
ANY_VERSION,                // CAM SENSOR version
CAM_INFO_VERSION,           // CAM INFO version
 343     0,
 344 };
 346 /*************** END OF AUXILARY PART *******************/