Calculation of remaining time in video record mode - done

[PhyrePhoX]

edit: read remaining video time,overrides-cusomizations,no-raw@video,just _random_ stuff - it is done

Hi,

as my other project ( Calculation of remaining shots with RAW - done ) seems to be finished very soon, i want to start the second one, a small one. it's also having to do with calculating stuff, this time it is planned that there will be a new OSD item that tells you the remaining time when in video record mode.
this feature is neccessary (in my eyes) for a few reasons:
the built-in canon counter does only show the remaining time in idle mode, before shooting the movie. during recording you only see the time since the start of recording. even IF canon would show you everything while recording, it wouldnt make much sense if you choose to override the movie settings (quality, bitrate) via chdk.
as a temporary workaround for finding out how long you can record a movie (DURING shooting) you can use my filespace icon or TXT (in megabyte) (from the thread mentioned above - soon to be in official trunk).

I quickly searched the sourcecode, but i couldnt find anything i could use to find out if a movie recording is being made. i can only check if we are in playback mode or in rec mode (and WHICH rec mode, i.e. C, M or movie). i guess i can somehow circumvent this, but it will not be as accurate.

whim already had an idea for implementing it, pseudo-code wise:

// pseudo-code snippet for calc time left

if (video_recording_started) {
    original_space = GetFreeCardSpaceKb();
    original_time = get_current_time();

    while(video_recording) {
        space_eaten = original_space - GetFreeCardSpaceKb();
        time_elapsed = get_current_time() - original_time;

        avg_use = space_eaten / time_elapsed; // Kb/sec

        time_left = GetFreeCardSpaceKb() / avg_use
    }
}

but if we lack a check for "if video_rec started/running" it will be difficult.
devs - any ideas?

[whim]

Hi PhyrePhox - some out-loud-thinking here:

To start a video, what do we do --> switch to video mode (we can detect that)
then we press shoot full (we can detect that too)

wim

[PhyrePhoX]

good idea!

Code: C

1. static void gui_space_draw_mb() {
2. int o=mode_get(),m=(mode_get()&MODE_SHOOTING_MASK);
3. static int a;
4. if (((o&MODE_MASK) == MODE_REC) & ((m&MODE_SHOOTING_MASK)==MODE_VIDEO_STD))
5. {
6.  
7. if (kbd_is_key_pressed(KEY_SHOOT_FULL) == 1)
8. {
9.     a=!a;
10. }
11. if (a==1)
12. {
13.             draw_string(100, 100, "SHOOT!", conf.osd_color);
14. }
15. else
16. {
17.             draw_string(100,100, "NOT SHOOT", conf.osd_color);
18. }
19. }

you have to disable the check for kbd_is_key_pressed(KEY_SHOOT_HALF)!=1) down in that file when gui_space_draw_mb is called in order for that to work.
this actually works, but: since this is checked about 12 times a second, a is overwritten again, because no human can press a button within a timeframe of 1/12 s. we can extend that time (like i did in the RAW icon function) but then we maybe miss that the button is being pressed. there has got to be a way to find out if vide_rec is running. but i guess i'd have to analyze firmware or something. propcases doesnt seem to help here either.
edit: i will just add a timecheck...
edit2: hmm, i just patched gui_osd_draw_clock to show the seconds as well. might come in handy when you want to take a picture at an exact moment.
edit3: hm, too tired to test it. but we're getting there

[Barney Fife]

Deleted

[PhyrePhoX]

that indeed is a snafu. thanks for the input! i still have the feeling we will make it, somehow

[whim]

@PhyrePhox

Funny, i had gone to bed, couldn't fall asleep and dreamed up something very similar
to your code, abstractly. Then saw your code and reworked it a bit:

Code: C

1. // since this gets called in gui_osd_draw(), the main loop (?) in gui_osd.c,
2. // it should follow the appropiate naming convention, looks better ;)
3. // Note: Also needs an 'extern void gui_osd_draw_movie_time_left();' in gui_osd.h
4.  
5. void gui_osd_draw_movie_time_left()  {
6.  
7. static int card_used, init_space, elapsed, avg_use, time_left;
8. static long init_time;
9. static int movie_running = 0;
10. static int init = 0;
11. static unsigned int skipcalls = 15;
12.  
13. int o=(mode_get() & MODE_MASK), m=(mode_get() & MODE_SHOOTING_MASK);
14. unsigned int hour=0, min=0, sec=0;
15.  
16.     // allow it to be turned on/off
17.     // if (!conf.show_movie_time_left) return;
18.    
19.     if ( (o != MODE_REC) || (m != MODE_VIDEO_STD) )  return;
20.  
21.     if (kbd_is_key_pressed(KEY_SHOOT_FULL) == 1)  movie_running = !movie_running ;
22.  
23.     if (!movie_running)  {
24.         // it's off, reset init
25.         init = 0;
26.         return;
27.         }
28.     else {
29.         //movie recording engaged
30.         if( !init )  {
31.             // initialize
32.             init_space = GetFreeCardSpaceKb();
33.             init_time  = get_tick_count();
34.             init = 1;
35.             }
36.         else {
37.             // already running
38.             if (--skipcalls ==0) {
39.                 // only calc at every 15 th interrupt (should equal every 1 sec for about 15 interupt calls/sec)
40.                 card_used = init_space - GetFreeCardSpaceKb();
41.                 // Note: there's 1000 ticks to a second
42.                 elapsed = (int) ( get_tick_count() - init_time ) / 1000;
43.                 // End Note
44.                 if (elapsed < 10) return;    // initially give it a minimum of say 10 secs to settle ...
45.                 avg_use = card_used / elapsed;  // running average Kb/sec
46.                 time_left = (GetFreeCardSpaceKb() / avg_use);
47.                 hour = time_left / 3600;
48.                 min = (time_left % 3600) / 60;
49.                 sec = (time_left % 3600) % 60;
50.                 skipcalls = 15;
51.                 }
52.             // called at every interrupt    
53.             sprintf(osd_buf, "Avg. %d KB/s ; %2d:%2d:%2d left", avg_use, hour, min, sec);
54.             // use this if we decide to make it configurable ....
55.             // draw_string(conf.mode_movie_time_left.x, conf.mode_movie_time_left.y, osd_buf, conf.osd_color);
56.             // for testing ...
57.             draw_string( 50, 50, osd_buf, conf.osd_color);
58.             }
59.         }
60.  
61. }
62.  

unchecked of course ...
talk to you later and now zzzzzzzzzzzzzz
wim

edit: code improved, we're getting there ...
edit2: gone off to test it now
edit3: compiles OK, but doesn't seem to function ...

[PhyrePhoX]

can't wait to try it this evening (i'm at work right now )

[PhyrePhoX]

heya whim, does this compile, does it work? will somehow test it right now.

[whim]

Hi Phox,
I got it compile without errors, but running ? Can't tell - see nothing 

I'll update previous post, because I haven't done that for almost 3 hours ...

wim

[PhyrePhoX]

yeah it compiles, you are right. and it shows the string with "avg ..." but the values are zero.
hm. too bad there is no debugger

i think the problem is ,that when you press the button, the part where you set movie_running = !movie_running ; is called more than once.

edit: doesnt seem to be the only problem. hm. tough.

[PhyrePhoX]

Code: C

1. // since this gets called in gui_osd_draw(), the main loop (?) in gui_osd.c,
2. // it should follow the appropiate naming convention, looks better ;)
3. // Note: Also needs an 'extern void gui_osd_draw_movie_time_left();' in gui_osd.h
4.  
5. void gui_osd_draw_movie_time_left()  {
6.  
7. static int locked = 0,card_used, init_space, elapsed, avg_use, time_left;
8. static long init_time;
9. static int movie_running = 0,started = 0;
10. static int init = 0;
11. static unsigned int skipcalls = 15;
12.  
13. int o=(mode_get() & MODE_MASK), m=(mode_get() & MODE_SHOOTING_MASK);
14. unsigned int hour=0, min=0, sec=0;
15.  
16.     // allow it to be turned on/off
17.     // if (!conf.show_movie_time_left) return;
18.  
19.     if ( (o != MODE_REC) || (m != MODE_VIDEO_STD) )  return;
20.  
21.     if (kbd_is_key_pressed(KEY_SHOOT_FULL) == 1)  
22.     {
23.     if (locked == 0)
24.     {
25.     movie_running = !movie_running;
26.     locked = 1;
27.    }
28.    }
29.     if (movie_running == 0)  {
30.         // it's off, reset init
31.         init = 0;
32.         started = 0;
33.         return;
34.         }
35.     else {
36.         //movie recording engaged
37.         if( !init )  {
38.             // initialize
39.             if (started == 0)
40.             {
41.             init_space = GetFreeCardSpaceKb();
42.             init_time  = get_tick_count();
43.             init = 1;
44.             started = 1;
45.             }
46.             }
47.         else {
48.             // already running
49.            // if (--skipcalls ==0) {
50.                 // only calc at every 15 th interrupt (should equal every 1 sec for about 15 interupt calls/sec)
51.                 card_used = init_space - GetFreeCardSpaceKb();
52.                 // Note: there's 1000 ticks to a second
53.                 elapsed = (int) ( get_tick_count() - init_time ) / 1000;
54.                 if (elapsed>2)
55.                 {
56.                 locked = 0;
57.                 }
58.                 // End Note
59.             //    if (elapsed < 2) return;    // initially give it a minimum of say 10 secs to settle ...
60.                 avg_use = card_used / elapsed;  // running average Kb/sec
61.                 time_left = (GetFreeCardSpaceKb() / avg_use);
62.                 hour = time_left / 3600;
63.                 min = (time_left % 3600) / 60;
64.                 sec = (time_left % 3600) % 60;
65.                 //skipcalls = 15;
66.              //   }
67.             // called at every interrupt    
68.           //   sprintf(osd_buf, "%4d - %4d", card_used/1024,elapsed);
69. //              draw_string( 50, 50, osd_buf, conf.osd_color);
70.  sprintf(osd_buf, "Avg. %d KB/s ; %2d:%2d:%2d left", avg_use, hour, min, sec);
71.  draw_string( 50, 50, osd_buf, conf.osd_color);
72.             //sprintf(osd_buf, "Avg. %d KB/s ; %2d:%2d:%2d left", avg_use, hour, min, sec);
73.             // use this if we decide to make it configurable ....
74.             // draw_string(conf.mode_movie_time_left.x, conf.mode_movie_time_left.y, osd_buf, conf.osd_color);
75.             // for testing ...
76. //              sprintf(osd_buf, "%d - %u", init_space, ttm );
77. //            draw_string( 50, 50, osd_buf, conf.osd_color);
78.             // 689425
79.             }
80.         }
81.  
82. }
83.  
84.  

this kinda works.forget the commented stuff. it doesnt stop when you press button again. i think there was/is a problem with your skipcalls thingy.

edit: added locked variable. now you can stop recording. doesnt work right way though - you can't start it again.

by the way, this really works. i set the qualitiy to 0.25 and it calculates that there are about 30 minutes left to record. 800 megs free.about 450 kb/s.canon value (when stopped) says there is about 8 minutes left to record.
i call this progress! \o/

edit: now the value is drawn onto display from the beginning. of course it is not stable during the first seconds.

[whim]

@PhyrePhox
Sorry, haven't checked the forum for a couple of hours. I guess your right. This is not gonna be quick.
I think I'm gonna experiment with making the routine insensitive to over-long full-shoot keypresses,
maybe by making it abort out of the routine for say 10- 15 times after it detected a full-shoot.
Or do you have any better ideas ?

wim

BTW have you seen how many keyboard routines there are   kbd_is_key_pressed, kbd_is_key_clicked etc.

[PhyrePhoX]

the kbd routine is not the best solution anyway, since the S3is (and the other s series cams) have an extra button.
there MUST be another way for finding out if the film is rolling.

edit: my locked variable does just that , what you just proposed. mind you, i edited my above post.
if you press the button the first time, locked is set to 1. after 2 seconds it is set to 0, so you can press again.

[PhyrePhoX]

new  post, cant edit the other one everytime i find out something new
i set video bitrate to 3x - recording started, however there was a Red exclamation mark every few seconds. i guess either my sdcard is too slow, or my a620 in general is too slow to write.
in 2x setting this still happens.
i have 2 sd cards, one significantly faster than the other, will test it now.

test with 1.5 setting.

canon value: 3 minutes 19 remaining.
my value after 1 minute: 1:12 left /about 3 megs /s)
after 2 minutes: 0:15 left (40 mb)

final length of movie: 2:06 (sd card was full).
that makes an estimated value of my function of about 2:12.
problem is that when recording is finished, camera writes some extra stuff, i guess avi header and container or something.

uh,. red exclamation mark all the time, gotta find out the meaning

edit: hm, gotta find out the video key for s3is so i can compile a testbuild for our main betatester barney

edit: 2nd test:
video setting: 1x bitrate (normal setting). 30 fps & 640+480 res.
mb left: 209.
time left (canon value): 1:49
my function;
after 30 secs: 1:31 left (about 1760 kb/s)
after 60 secs: 1:02 left (about 1754 kb/s)
after 90 secs:0:32 left (about 1750 kb/s)
final length of movie: 1:58.

this is quiete precise,imo, maybe we should subtract an extra 10 seconds from the output just to make sure.

[PhyrePhoX]

by the way, ewavr let me know a few things:

in memory browser I can find many variables concerning current record time.
For example, in your A620 int variable at 0x73CF4 is current number of captured frames (and if interesting 0x73D0C is limit of frames for current video mode). If this variable changes, video record is in progress.

You can find this variables at top of sub_FFD2E0D8_my() in movie_rec.c for a620.

if we have these values for each camera, we might be able to circumvent catching key presses.
on the other hand, we also could check for changes in freediskspace to start our function, and end it when there is nothing written to disk anymore. lots of ideas