root/core/usb_module.c

/* [<][>][^][v][top][bottom][index][help] */

DEFINITIONS

This source file includes following definitions.
  1. usb_playback_module
  2. usb_shoot_module_normal
  3. usb_shoot_module_quick
  4. usb_shoot_module_burst
  5. usb_zoom_step
  6. usb_shoot_module_zoom
  7. usb_bracketing_done
  8. usb_shoot_module_bracketing
  9. usb_video_module_normal
  10. usb_null_module

   1 /*===================================================================================================================================================
   2 
   3     USB Remote : Shooting Control Modules
   4 
   5         - shooting control modules monitor the state of the "virtual switch" variable and take
   6           appropriate action according to the logic defined for that mode
   7         - all interface to the physical camera is performed by these modules
   8         - the active control module is selected from a menu entry in the USB Remote menu
   9         - to add a control module, create a new function here, add string to gui_USB_control_modes[]
  10           in gui.c and add ptr below to stucture (*usb_control_module[10])(int)
  11  ===================================================================================================================================================*/
  12 
  13 #include "camera_info.h"
  14 #include "stdlib.h"
  15 #include "clock.h"
  16 #include "shooting.h"
  17 #include "keyboard.h"
  18 #include "conf.h"
  19 #include "action_stack.h"
  20 #include "usb_remote.h"
  21 
  22 /*===================================================================================================
  23     Debug and error handling
  24   ===================================================================================================*/
  25 
  26 #ifdef USB_REMOTE_DEBUGGING
  27 
  28 extern int debug_errors[] ;
  29 extern void debug_error(int ) ;
  30 
  31 #else
  32 
  33 extern void debug_error(int ) ;
  34 
  35 #endif
  36 
  37 
  38 /*---------------------------------------------------------------------------------------------------
  39     Control Module :  Playback
  40         - does right & left key presses in playback mode to allow scrolling through images in LCD
  41         - most useful with stereo photography to allow sync'd review of multiple cameras
  42   ---------------------------------------------------------------------------------------------------*/
  43 
  44  void usb_playback_module()
  45  {
  46     static int time_stamp = 0 ;
  47     static int direction = 0 ;                                          // 0 = left button,  1 = right button
  48     int i, current_time ;
  49 
  50     current_time = get_tick_count();
  51 
  52     switch( logic_module_state )
  53     {
  54         case LM_RESET :
  55             logic_module_state = LM_RELEASE ;
  56             break ;
  57         case LM_RELEASE :
  58             i =  get_usb_power(LM_PULSE_COUNT) ;
  59             switch( i )
  60             {
  61                 case PLAYBACK_REVERSE :
  62                     direction = direction ? 0 : 1 ;                     // fall through to next case
  63                 case PLAYBACK_NEXT :
  64                     if ( direction ) kbd_key_press(KEY_LEFT);
  65                     else  kbd_key_press(KEY_RIGHT);
  66                     logic_module_state = LM_KEY_PRESS ;
  67                     time_stamp = current_time ;
  68                     break ;
  69                 case PLAYBACK_LEFT :
  70                     direction = 0 ;
  71                     break ;
  72                 case PLAYBACK_RIGHT :
  73                     direction = 1 ;
  74                     break ;
  75                 default :
  76                     break ;
  77             }
  78             break ;
  79 
  80         case LM_KEY_PRESS :
  81             if( (current_time - time_stamp) > REMOTE_CLICK_TIME )
  82             {
  83                 if ( direction ) kbd_key_release(KEY_LEFT);
  84                 else  kbd_key_release(KEY_RIGHT);
  85                 logic_module_state = LM_RELEASE ;
  86             }
  87             break ;
  88 
  89         default :
  90             break ;
  91     }
  92 }
  93 
  94 /*---------------------------------------------------------------------------------------------------
  95     Control Module :  Shoot Normal
  96         - module to activate camera's half press key on virtual half press and full press key on virtual full press
  97         - implements sync as follows :
  98             1) one press switch - starts a full shoot on half press so that sync happens on "full press"
  99             2) two press switch - does half press action, starts shoot on full press, sync will happen when full press released
 100             3) CA-1 - does half press action, starts shoot on full press - sync happens at end of CA-1 150 mSec pulse
 101   ---------------------------------------------------------------------------------------------------*/
 102 
 103 void usb_shoot_module_normal()
 104 {
 105     static AS_ID usb_remote_stack_name = 0;
 106 
 107     if ( conf.synch_enable == 0  )                                      // handle key presses differently if in sync mode
 108     {
 109         switch( logic_module_state )
 110         {
 111             case LM_RESET :
 112                 kbd_key_release(KEY_SHOOT_FULL);
 113                 kbd_key_release(KEY_SHOOT_HALF);
 114                 logic_module_state = LM_RELEASE ;
 115                 break ;
 116             case LM_RELEASE :
 117                 switch ( virtual_remote_state )
 118                 {
 119                     case REMOTE_RELEASE :
 120                         break ;
 121                     case REMOTE_HALF_PRESS :
 122                         kbd_key_press(KEY_SHOOT_HALF);
 123                         logic_module_state = LM_HALF_PRESS ;
 124                         break ;
 125                     case REMOTE_FULL_PRESS:
 126                         kbd_key_press(KEY_SHOOT_HALF);
 127                         kbd_key_press(KEY_SHOOT_FULL);
 128                         logic_module_state = LM_FULL_PRESS ;
 129                         break ;
 130                     default :
 131                         debug_error(INVALID_STATE) ;
 132                         break ;
 133                 }
 134                 break ;
 135 
 136             case LM_HALF_PRESS :
 137                 switch ( virtual_remote_state )
 138                 {
 139                     case REMOTE_RELEASE :
 140                         kbd_key_release(KEY_SHOOT_HALF);
 141                         logic_module_state = LM_RELEASE ;
 142                         break ;
 143                     case REMOTE_HALF_PRESS :
 144                         break ;
 145                     case REMOTE_FULL_PRESS:
 146                         kbd_key_press(KEY_SHOOT_FULL);
 147                         logic_module_state = LM_FULL_PRESS ;
 148                         break ;
 149                     default :
 150                         debug_error(INVALID_STATE) ;
 151                         break ;
 152                 }
 153                 break ;
 154 
 155 
 156             case LM_FULL_PRESS :
 157                 switch ( virtual_remote_state )
 158                 {
 159                     case REMOTE_RELEASE :
 160                         kbd_key_release(KEY_SHOOT_FULL);
 161                         kbd_key_release(KEY_SHOOT_HALF);
 162                         logic_module_state = LM_RELEASE ;
 163                         break ;
 164                     case REMOTE_HALF_PRESS:
 165                         kbd_key_release(KEY_SHOOT_FULL);
 166                         logic_module_state = LM_HALF_PRESS ;
 167                         break ;
 168                     case REMOTE_FULL_PRESS:
 169                         break ;
 170                     default :
 171                         debug_error(INVALID_STATE) ;
 172                         break ;
 173                 }
 174                 break ;
 175 
 176             default :
 177                 debug_error(INVALID_STATE) ;
 178                 break ;
 179 
 180         }
 181     }
 182     else                    // syncable remote mode
 183     {
 184         switch( logic_module_state )
 185         {
 186             case LM_RESET :
 187                 logic_module_state = LM_RELEASE ;
 188                 break ;
 189 
 190             case LM_RELEASE :
 191                 switch ( virtual_remote_state )
 192                 {
 193                     case REMOTE_HALF_PRESS :
 194                         switch ( switch_type)
 195                         {
 196                             case SW_ONE_PRESS :
 197                                 usb_remote_stack_name = action_stack_create(&action_stack_AS_SHOOT);
 198                                 usb_sync_wait_flag = 1;
 199                                 logic_module_state = LM_HALF_PRESS ;
 200                                 break ;
 201                             case SW_TWO_PRESS :
 202                             case SW_RICOH_CA1 :
 203                                 kbd_key_press(KEY_SHOOT_HALF);
 204                                 logic_module_state = LM_HALF_PRESS ;
 205                                 break ;
 206                             default :
 207                                 break ;
 208                         }
 209                         break ;
 210 
 211                     case REMOTE_RELEASE :
 212                     case REMOTE_FULL_PRESS:
 213                         break ;
 214                     default :
 215                         debug_error(INVALID_STATE) ;
 216                         break ;
 217                 }
 218                 break ;
 219 
 220             case LM_HALF_PRESS :
 221                 switch ( virtual_remote_state )
 222                 {
 223                     case REMOTE_FULL_PRESS:
 224                         switch ( switch_type)
 225                         {
 226                             case SW_ONE_PRESS :
 227                                 logic_module_state = LM_FULL_PRESS ;
 228                                 break ;
 229                             case SW_TWO_PRESS :
 230                             case SW_RICOH_CA1 :
 231                                 usb_sync_wait_flag = 1;
 232                                 kbd_key_press(KEY_SHOOT_FULL);
 233                                 logic_module_state = LM_FULL_PRESS ;
 234                                 break ;
 235                             default :
 236                                 break ;
 237                         }
 238                         break ;
 239                     case REMOTE_RELEASE :
 240                         switch ( switch_type)
 241                         {
 242                             case SW_ONE_PRESS :
 243                                 if( action_stack_is_finished(usb_remote_stack_name) )
 244                                 {
 245                                     logic_module_state = LM_RELEASE ;
 246                                 }
 247                                 break ;
 248                             case SW_TWO_PRESS :
 249                             case SW_RICOH_CA1 :
 250                                 kbd_key_release(KEY_SHOOT_HALF);
 251                                 logic_module_state = LM_RELEASE ;
 252                                 break ;
 253                             default :
 254                                 break ;
 255                         }
 256                         break ;
 257                     case REMOTE_HALF_PRESS :
 258                         break ;
 259                     default :
 260                         debug_error(INVALID_STATE) ;
 261                         break ;
 262                 }
 263                 break ;
 264 
 265             case LM_FULL_PRESS :
 266                 switch ( virtual_remote_state )
 267                 {
 268                     case REMOTE_RELEASE :
 269                         switch ( switch_type)
 270                         {
 271                             case SW_ONE_PRESS :
 272                                 if( action_stack_is_finished(usb_remote_stack_name) )
 273                                 {
 274                                     logic_module_state = LM_RELEASE ;
 275                                 }
 276                                 break ;
 277                             case SW_TWO_PRESS :
 278                             case SW_RICOH_CA1 :
 279                                 usb_sync_wait_flag = 0;
 280                                 logic_module_state = LM_RELEASE ;
 281                                 kbd_key_release(KEY_SHOOT_FULL);
 282                                 kbd_key_release(KEY_SHOOT_HALF);
 283                                 break ;
 284                             default :
 285                                 break ;
 286                         }
 287                         break ;
 288                     case REMOTE_HALF_PRESS :
 289                     case REMOTE_FULL_PRESS:
 290                         break ;
 291                     default :
 292                         debug_error(INVALID_STATE) ;
 293                         break ;
 294                 }
 295                 break ;
 296             default :
 297                 debug_error(INVALID_STATE) ;
 298                 break ;
 299         }
 300     }
 301 
 302 };
 303 
 304 /*---------------------------------------------------------------------------------------------------
 305     Control Module :  Shoot Quick
 306         - module to launch "shoot()" on leading edge of either virtual HALF_PRESS or FULL_PRESS
 307         - does not support sync
 308   ---------------------------------------------------------------------------------------------------*/
 309 
 310  void usb_shoot_module_quick()
 311 {
 312     static AS_ID usb_remote_stack_name = 0;
 313 
 314     switch( logic_module_state )
 315     {
 316         case LM_RESET :
 317             logic_module_state = LM_RELEASE ;
 318             break ;
 319         case LM_RELEASE :
 320             switch ( virtual_remote_state )
 321             {
 322                 case REMOTE_RELEASE :
 323                     break ;
 324                 case REMOTE_HALF_PRESS :
 325                 case REMOTE_FULL_PRESS:
 326                     usb_remote_stack_name = action_stack_create(&action_stack_AS_SHOOT);
 327                     logic_module_state = LM_FULL_PRESS ;
 328                     break ;
 329                 default :
 330                     debug_error(INVALID_STATE) ;
 331                     break ;
 332             }
 333             break ;
 334 
 335         case LM_FULL_PRESS :
 336             if (( virtual_remote_state == REMOTE_RELEASE ) && action_stack_is_finished(usb_remote_stack_name) )
 337             {
 338                 logic_module_state = LM_RELEASE ;
 339             }
 340             break ;
 341 
 342         default :
 343             debug_error(INVALID_STATE) ;
 344             break ;
 345 
 346     }
 347 
 348 }
 349 
 350 /*---------------------------------------------------------------------------------------------------
 351     Control Module :  Shoot Burst
 352         - module to launch "shoot()" continuously while virtual HALF_PRESSED is true
 353         - refocus & exposure set on each shot - another mode could be added to lock those on first shot
 354         - virtual FULL_PRESS is ignored
 355   ---------------------------------------------------------------------------------------------------*/
 356 
 357 void usb_shoot_module_burst()
 358 {
 359     static AS_ID usb_remote_stack_name = 0;
 360 
 361     switch( logic_module_state )
 362     {
 363         case LM_RESET :
 364             logic_module_state = LM_RELEASE ;
 365             break ;
 366         case LM_RELEASE :
 367             switch ( virtual_remote_state )
 368             {
 369                 case REMOTE_RELEASE :
 370                     break ;
 371                 case REMOTE_HALF_PRESS :
 372                 case REMOTE_FULL_PRESS:
 373                     usb_remote_stack_name = action_stack_create(&action_stack_AS_SHOOT);
 374                     logic_module_state = LM_HALF_PRESS ;
 375                     break ;
 376                 default :
 377                     debug_error(INVALID_STATE) ;
 378                     break ;
 379             }
 380             break ;
 381         case LM_HALF_PRESS :
 382             if( action_stack_is_finished(usb_remote_stack_name) )
 383             {
 384                 logic_module_state = LM_RELEASE ;
 385             }
 386             break ;
 387         default :
 388             debug_error(INVALID_STATE) ;
 389             break ;
 390     }
 391 
 392 }
 393 
 394 /*---------------------------------------------------------------------------------------------------
 395     Control Module :  Shoot Zoom
 396         - module to allow zoom action to be synced between two camera
 397         - works with Pulse Count input device
 398             - 1 pulse  = zoom in
 399             - 2 pulses = zoom out
 400             - 3 pulses = shoot
 401             - 4 pulses = zoom full in
 402             - 5 pulses = zoom full out
 403   ---------------------------------------------------------------------------------------------------*/
 404 
 405 void usb_zoom_step(int zdirection)
 406 {
 407     int zpos, zstep, newzpos ;
 408     if (!camera_info.state.mode_play)
 409     {
 410         // currently used zoom_points values are  6 7 8 10 12 14 15 23 64 101 121 126 127 128 129 201
 411         if      (zoom_points <= 16 ) zstep = 1 ;
 412         else if (zoom_points <= 32 ) zstep = 2 ;
 413         else if (zoom_points <= 64 ) zstep = 6 ;
 414         else if (zoom_points <= 110) zstep = 10 ;
 415         else if (zoom_points <= 128) zstep = 12 ;
 416         else                         zstep = 20 ;
 417         zpos = shooting_get_zoom();        
 418         // if new pos less than half a step from end of range, go to end
 419         if(zdirection>0)
 420         {
 421             if(zpos+zstep+zstep/2<zoom_points)
 422             {
 423                 newzpos = zpos+zstep;
 424             }
 425             else
 426             {
 427                 newzpos = zoom_points;
 428             }
 429         }
 430         else
 431         {
 432             if(zpos-zstep-zstep/2>0)
 433             {
 434                 newzpos = zpos-zstep;
 435             }
 436             else
 437             {
 438                 newzpos = 0;
 439             }
 440         }
 441         shooting_set_zoom(newzpos);
 442     }
 443 }
 444 
 445 void usb_shoot_module_zoom()
 446 {
 447     static AS_ID usb_remote_stack_name = 0;
 448 
 449     switch( logic_module_state )
 450     {
 451         case LM_RESET :
 452             logic_module_state = LM_RELEASE ;
 453             break ;
 454         case LM_RELEASE :
 455             switch( get_usb_power(LM_PULSE_COUNT) )
 456             {
 457                 case ZOOM_STEP_OUT :
 458                     usb_zoom_step(1) ;
 459                     break ;
 460                 case ZOOM_STEP_IN :
 461                     usb_zoom_step(-1);
 462                     break ;
 463                 case ZOOM_SHOOT :
 464                     logic_module_state = LM_FULL_PRESS ;
 465                     usb_remote_stack_name = action_stack_create(&action_stack_AS_SHOOT);
 466                     break ;
 467                 case ZOOM_FULL_OUT :
 468                     shooting_set_zoom(zoom_points) ;
 469                     break ;
 470                 case ZOOM_FULL_IN :
 471                     shooting_set_zoom(0) ;
 472                     break ;
 473                 default :
 474                     break ;
 475             }
 476             break ;
 477         case LM_FULL_PRESS :
 478             if( action_stack_is_finished(usb_remote_stack_name) )
 479             {
 480                 logic_module_state = LM_RELEASE ;
 481             }
 482             break ;
 483         default :
 484             break ;
 485     }
 486 };
 487 
 488 /*---------------------------------------------------------------------------------------------------
 489     Control Module :  Shoot Bracketing
 490         - module to allow bracketing shots without using camera's timer or continuous modes
 491         - focus & exposure on each half press - shoots on full press
 492         - times out in 5 seconds after the last full press
 493   ---------------------------------------------------------------------------------------------------*/
 494 extern void bracketing_step() ;
 495 extern void bracketing_reset() ;
 496 
 497 void usb_bracketing_done()
 498 {
 499     bracketing_reset() ;
 500     bracketing_timeout = 0 ;
 501 }
 502 
 503 
 504 void usb_shoot_module_bracketing()
 505 {
 506     int current_time ;
 507 
 508     current_time = get_tick_count() ;
 509 
 510     switch( logic_module_state )
 511     {
 512         case LM_RESET :
 513             logic_module_state = LM_RELEASE ;
 514             break ;
 515         case LM_RELEASE :
 516             if (( bracketing_timeout ) && ( current_time > bracketing_timeout ) ) usb_bracketing_done() ;
 517             switch ( virtual_remote_state )
 518             {
 519                 case REMOTE_RELEASE :
 520                     break ;
 521                 case REMOTE_HALF_PRESS :
 522                 case REMOTE_FULL_PRESS:                                 // Note : need a half-press to setup bracketing step
 523                     kbd_key_press(KEY_SHOOT_HALF);
 524                     logic_module_state = LM_HALF_PRESS ;
 525                     break ;
 526                 default :
 527                     debug_error(INVALID_STATE) ;
 528                     break ;
 529             }
 530             break ;
 531         case LM_HALF_PRESS :
 532             switch ( virtual_remote_state )
 533             {
 534                 case REMOTE_RELEASE :
 535                     kbd_key_release(KEY_SHOOT_HALF);
 536                     logic_module_state = LM_RELEASE ;
 537                     usb_bracketing_done() ;
 538                     break ;
 539                 case REMOTE_HALF_PRESS :
 540                     break ;
 541                 case REMOTE_FULL_PRESS:
 542                     if ( shooting_in_progress() )
 543                     {
 544                         kbd_key_press(KEY_SHOOT_FULL);
 545                         logic_module_state = LM_FULL_PRESS ;
 546                         bracketing_timeout = current_time + BRACKETING_TIMEOUT ;
 547                     }
 548                     break ;
 549                 default :
 550                     debug_error(INVALID_STATE) ;
 551                     break ;
 552             }
 553             break ;
 554         case LM_FULL_PRESS :
 555             switch ( virtual_remote_state )
 556             {
 557                 case REMOTE_RELEASE :
 558                     kbd_key_release(KEY_SHOOT_FULL_ONLY);
 559                     kbd_key_release(KEY_SHOOT_HALF);
 560                     logic_module_state = LM_RELEASE ;
 561                     bracketing_step(SET_LATER) ;
 562                     break ;
 563                 case REMOTE_HALF_PRESS :
 564                     kbd_key_release(KEY_SHOOT_FULL_ONLY);
 565                     logic_module_state = LM_HALF_PRESS ;
 566                     bracketing_step(SET_LATER) ;
 567                     break ;
 568                 case REMOTE_FULL_PRESS:
 569                     break ;
 570                 default :
 571                     debug_error(INVALID_STATE) ;
 572                     break ;
 573             }
 574             break ;
 575         default :
 576             debug_error(INVALID_STATE) ;
 577             break ;
 578     }
 579 
 580 }
 581 
 582  /*---------------------------------------------------------------------------------------------------
 583     Control Module :  Video
 584         - starts video (with sync if selected) on press,  stops on next press
 585   ---------------------------------------------------------------------------------------------------*/
 586 
 587 void usb_video_module_normal()
 588 {
 589     int usb_video_button = (camera_info.cam_has_video_button) ? KEY_VIDEO : KEY_SHOOT_FULL;
 590 
 591     switch( logic_module_state )
 592     {
 593         case LM_RESET :
 594             logic_module_state = LM_RELEASE ;
 595             break ;
 596         case LM_RELEASE :
 597             switch ( virtual_remote_state )
 598             {
 599                 case REMOTE_RELEASE :
 600                     break ;
 601                 case REMOTE_HALF_PRESS :
 602                 case REMOTE_FULL_PRESS:
 603                     kbd_key_press(usb_video_button);
 604                     logic_module_state = LM_START_RECORD ;
 605                     break ;
 606                 default :
 607                     debug_error(INVALID_STATE) ;
 608                     break ;
 609             }
 610             break ;
 611         case LM_START_RECORD:
 612             switch ( virtual_remote_state )
 613             {
 614                 case REMOTE_RELEASE :
 615                     logic_module_state = LM_RECORDING ;
 616                     kbd_key_release(usb_video_button);
 617                     break ;
 618                 case REMOTE_HALF_PRESS :
 619                 case REMOTE_FULL_PRESS:
 620                     break ;
 621                 default :
 622                     debug_error(INVALID_STATE) ;
 623                     break ;
 624             }
 625             break;
 626         case LM_RECORDING :
 627             switch ( virtual_remote_state )
 628             {
 629                 case REMOTE_RELEASE :
 630                     break ;
 631                 case REMOTE_HALF_PRESS :
 632                 case REMOTE_FULL_PRESS:
 633                     kbd_key_press(usb_video_button);
 634                     logic_module_state = LM_STOP_RECORDING ;
 635                     break ;
 636                 default :
 637                     debug_error(INVALID_STATE) ;
 638                     break ;
 639             }
 640             break;
 641         case LM_STOP_RECORDING :
 642             switch ( virtual_remote_state )
 643             {
 644                 case REMOTE_RELEASE :
 645                     logic_module_state = LM_RELEASE ;
 646                     kbd_key_release(usb_video_button);
 647                     break ;
 648                 case REMOTE_HALF_PRESS :
 649                 case REMOTE_FULL_PRESS:
 650                     break ;
 651                 default :
 652                     debug_error(INVALID_STATE) ;
 653                     break ;
 654             }
 655             break;
 656         default :
 657             debug_error(INVALID_STATE) ;
 658             break ;
 659     }
 660 
 661 };
 662 
 663 
 664  /*===================================================================================================
 665 
 666     Control Module Jump Tables
 667 
 668   ===================================================================================================*/
 669 
 670 void usb_null_module(int i) {  } ;              // module that does nothing - useful for unused entries in jump table
 671 
 672 
 673 // play mode jump table for control logic modules - must match gui_USB_control_modes[] in gui.c
 674 
 675 void (*usb_module_play[NUM_USB_MODULES])() =
 676     {
 677                 usb_null_module ,               // [   None]
 678                 usb_playback_module ,           // [ Normal]
 679                 usb_playback_module ,           // [  Quick]
 680                 usb_playback_module ,           // [  Burst]
 681                 usb_playback_module ,           // [Bracket]
 682                 usb_playback_module ,           // [   Zoom]
 683                 usb_playback_module ,           // [  Video]
 684                 usb_playback_module ,           // <- insert new playback module here - update NUM_USB_MODULES if necessary
 685                 usb_playback_module ,           //  --
 686                 usb_null_module                 //  --
 687     };
 688 
 689 
 690 // shooting mode jump table for control logic modules - must match gui_USB_control_modes[] in gui.c
 691 
 692 void (*usb_module_shoot[NUM_USB_MODULES])() =
 693     {
 694                 usb_null_module ,               // [   None]
 695                 usb_shoot_module_normal ,       // [ Normal]
 696                 usb_shoot_module_quick ,        // [  Quick]
 697                 usb_shoot_module_burst ,        // [  Burst]
 698                 usb_shoot_module_bracketing ,   // [Bracket]
 699                 usb_shoot_module_zoom ,         // [   Zoom]
 700                 usb_video_module_normal ,       // [  Video] note : cameras with video button come through here when filming
 701                 usb_null_module,                // <- insert new shoot module here - update NUM_USB_MODULES if necessary
 702                 usb_null_module,                // --
 703                 usb_null_module                 // --
 704     };
 705 
 706 
 707 // video mode jump table for control logic modules - must match gui_USB_control_modes[] in gui.c
 708 
 709 void (*usb_module_video[NUM_USB_MODULES])() =
 710     {
 711                 usb_null_module ,               // [   None]
 712                 usb_video_module_normal ,       // [ Normal]
 713                 usb_video_module_normal ,       // [  Quick]
 714                 usb_null_module ,               // [  Burst]
 715                 usb_null_module ,               // [Bracket]
 716                 usb_null_module ,               // [   Zoom]
 717                 usb_video_module_normal ,       // [  Video]
 718                 usb_null_module ,               // <- insert new video module here - update NUM_USB_MODULES if necessary
 719                 usb_null_module ,               // --
 720                 usb_null_module                 // --
 721         };

/* [<][>][^][v][top][bottom][index][help] */