root/platform/sx730hs/lib.c

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

DEFINITIONS

This source file includes following definitions.
  1. vid_bitmap_refresh
  2. shutdown
  3. debug_led
  4. camera_set_led
  5. shutdown_soft
  6. get_flash_params_count
  7. JogDial_CW
  8. JogDial_CCW
  9. hook_raw_image_addr
  10. vid_get_viewport_fb
  11. vid_get_viewport_fb_d
  12. vid_get_viewport_live_fb
  13. vid_get_viewport_width
  14. vid_get_viewport_height
  15. vid_get_viewport_yoffset
  16. vid_get_viewport_display_xoffset
  17. vid_get_viewport_display_yoffset
  18. vid_get_bitmap_fb
  19. vid_get_viewport_byte_width
  20. vid_get_viewport_display_xoffset_proper
  21. vid_get_viewport_display_yoffset_proper
  22. vid_get_viewport_fullscreen_width
  23. vid_get_viewport_fullscreen_height
  24. vid_get_viewport_buffer_width_proper
  25. vid_get_viewport_type
  26. vid_get_bitmap_active_buffer
  27. vid_get_opacity_active_buffer
  28. update_screen_dimensions
  29. camera_jpeg_count_str

   1 #include "platform.h"
   2 #include "lolevel.h"
   3 #include "live_view.h"
   4 
   5 extern int active_bitmap_buffer;
   6 
   7 void vid_bitmap_refresh() {
   8     // https://chdk.setepontos.com/index.php?topic=12788.msg133958#msg133958
   9     extern void _transfer_src_overlay(int);
  10 // works in most cases but can cause "ghosting" in auto mode when canon UI constantly updates
  11 //  _transfer_src_overlay(active_bitmap_buffer);
  12     _transfer_src_overlay(0);
  13     _transfer_src_overlay(1);
  14 }
  15 
  16 void shutdown() {
  17 //***TODO***
  18 /*
  19     volatile long *p = (void*)0xC022001C;
  20 
  21     asm(
  22         "MRS     R1, CPSR\n"
  23         "AND     R0, R1, #0x80\n"
  24         "ORR     R1, R1, #0x80\n"
  25         "MSR     CPSR_cf, R1\n"
  26         :::"r1","r0"
  27     );
  28 
  29     *p = 0x44;  // power off.
  30 */
  31     while(1);
  32 }
  33 
  34 #define LED_PR 0xd20b0994 // green LED on the back
  35 
  36 void debug_led(int state) {
  37     volatile long *p = (void*)LED_PR;
  38     *p = ((state) ? 0x4d0002 : 0x4c0003);
  39 }
  40 
  41 // Power Led = first entry in table (led 0)
  42 // AF Assist Lamp = second entry in table (led 1)
  43 // orange charge LED does not appear to be controlled by _LEDDrive
  44 void camera_set_led(int led, int state, __attribute__ ((unused))int bright) {
  45     static char led_table[2]={0,4};
  46     _LEDDrive(led_table[led%sizeof(led_table)], state<=1 ? !state : state);
  47 }
  48 
  49 void shutdown_soft() {
  50     _PostLogicalEventForNotPowerType(0x1005,0); // PressOffButton
  51 }
  52 
  53 int get_flash_params_count(void) {
  54     return 0x116; // @fc06b012 GetParameterData
  55 }
  56 
  57 void JogDial_CW(void) {
  58     _PostLogicalEventToUI(0x872, 1);    //RotateJogDialRight
  59 }
  60 
  61 void JogDial_CCW(void) {
  62     _PostLogicalEventToUI(0x873, 1);    //RotateJogDialLeft
  63 }
  64 
  65 // updated by using function in capt_seq, valid between shot start and raw hook end
  66 extern  char* current_raw_addr;
  67 char *hook_raw_image_addr()
  68 {
  69     if(current_raw_addr) {
  70         return current_raw_addr;
  71     }
  72     // TODO fallback if current_raw_addr not set. Would be better to fail, but calling code doesn't check
  73     return  (char *)0x43ec0040; // CRAW BUF = *fc52e180
  74 }
  75 
  76 // TODO - camera has multiple raw buffers, but unclear how to pick safe alt
  77 /*
  78 char *hook_alt_raw_image_addr()
  79 {
  80     return raw_buffers[((active_raw_buffer&1)^1)];
  81 }
  82 */
  83 
  84 void *vid_get_viewport_fb() {
  85     return (void*)0x42e78000; // "first" viewport adr, "VRAM Address  : %p", contains d6 uyvy
  86 }
  87 /*
  88 playback viewport
  89 */
  90 void *vid_get_viewport_fb_d()    {
  91     extern void *current_fb_d;
  92     return current_fb_d;
  93 }
  94 
  95 extern void* viewport_buffers[];
  96 /*
  97 four viewport buffers @0xfc63708c
  98 0x42e78000
  99 0x42f24800
 100 0x42fd1000
 101 0x4307d800
 102 */
 103 
 104 extern void *current_viewport_buffer;
 105 void *vid_get_viewport_live_fb()
 106 {
 107 // current_viewport_buffer assummed not most recent, like g7x
 108     int i;
 109     for(i=0;i<4;i++) {
 110         if(current_viewport_buffer == viewport_buffers[i]) {
 111             return viewport_buffers[(i+1)&3];
 112         }
 113     }
 114     return 0;
 115 }
 116 
 117 // track viewport size changes with display type
 118 // only different from bitmap for HDMI out, playback only, probably pointless
 119 static int vp_full_width = 640;
 120 static int vp_full_buf_width = 640;
 121 static int vp_full_height = 480;
 122 
 123 int vid_get_viewport_width() {
 124     extern int _GetVRAMHPixelsSize();
 125     if (camera_info.state.mode_play)
 126     {
 127         return vp_full_width;
 128     }
 129 // NOTE: currently using actual width rather than half width used on pre d6
 130 // pixel format is uyvy (16bpp)
 131     return _GetVRAMHPixelsSize();
 132 }
 133 
 134 long vid_get_viewport_height() {
 135     extern int _GetVRAMVPixelsSize();
 136     if (camera_info.state.mode_play)
 137     {
 138         return vp_full_height;
 139     }
 140 // NOTE: currently using actual height rather than 240 used on pre d6
 141     return _GetVRAMVPixelsSize();
 142 }
 143 
 144 int vid_get_viewport_yoffset() {
 145     // this seems to be always 0, buffer always begins with actual display data (widescreen or not)
 146     return 0;
 147 }
 148 // 0 = 4:3, 1 = 16:9, 2 = 3:2, 3 = 1:1
 149 static long vp_xo[4] = { 0, 0, 0, 80 };                         // should all be even values for edge overlay
 150 
 151 int vid_get_viewport_display_xoffset() {
 152     if (camera_info.state.mode_play)
 153     {
 154         return 0;
 155     }
 156     // video, ignore still res propcase
 157     if(camera_info.state.mode_video || is_video_recording()) {
 158         return 0; //neither 4:3 nor 16:9 video have x offset
 159     }
 160     return vp_xo[shooting_get_prop(PROPCASE_ASPECT_RATIO)];
 161 }
 162 
 163 // 0 = 4:3, 1 = 16:9, 2 = 3:2, 3 = 1:1
 164 static long vp_yo[4] = { 0, 60, 28, 0 };
 165 
 166 int vid_get_viewport_display_yoffset() {
 167     if (camera_info.state.mode_play)
 168     {
 169         return 0;
 170     }
 171     // video, ignore still res propcase
 172     if(camera_info.state.mode_video || is_video_recording()) {
 173         if(shooting_get_prop(PROPCASE_VIDEO_RESOLUTION) == 2) {
 174             return 0; // 4:3 video, no Y offset
 175         } else {
 176             return 60; // 16:9 video
 177         }
 178     }
 179     return vp_yo[shooting_get_prop(PROPCASE_ASPECT_RATIO)];
 180 }
 181 
 182 extern char* bitmap_buffer[];
 183 
 184 void *vid_get_bitmap_fb() {
 185     return (void *)0x5fe80000; // from sub_fc0a3ed2, alt 0x5fd00000, based on caller fc348732 == sx710 fc309cd4
 186                                 // called from GUISrv_StartGUISystem_FW
 187 }
 188 
 189 int vid_get_viewport_byte_width() {
 190     return vp_full_buf_width*2;
 191 }
 192 
 193 // Functions for PTP Live View system
 194 int vid_get_viewport_display_xoffset_proper()   { return vid_get_viewport_display_xoffset(); }
 195 int vid_get_viewport_display_yoffset_proper()   { return vid_get_viewport_display_yoffset(); }
 196 int vid_get_viewport_fullscreen_width()         { return vp_full_width; }
 197 int vid_get_viewport_fullscreen_height()        { return vp_full_height; }
 198 int vid_get_viewport_buffer_width_proper()      { return vp_full_buf_width; }
 199 int vid_get_viewport_type()                     { return LV_FB_YUV8B; }
 200 
 201 void *vid_get_bitmap_active_buffer() {
 202     return bitmap_buffer[active_bitmap_buffer&1];
 203 }
 204 
 205 // the opacity buffer defines opacity for the bitmap overlay's pixels
 206 // fc0a3dee, similar to sx710 fc1631ee, BmpDDev.c assert + switch
 207 // following function match sx710 fc12e008 == sx730 fc0e36b2
 208 volatile char *opacity_buffer[2] = {(void*)0x5FC40000, (char*)0x5FB80000};
 209 
 210 void *vid_get_opacity_active_buffer() {
 211     return (void *)opacity_buffer[active_bitmap_buffer&1];
 212 }
 213 #ifdef CAM_SUPPORT_BITMAP_RES_CHANGE
 214 /*
 215  * needed because bitmap buffer resolutions change when an external display is used
 216  * an extra screen erase doesn't seem to be needed
 217  */
 218 void update_screen_dimensions() {
 219     // see sub_fc0a3d32 in 100d for values
 220     extern int displaytype;
 221     static int old_displaytype = -1;
 222 
 223     if (old_displaytype == displaytype) {
 224         return;
 225     }
 226     old_displaytype = displaytype;
 227 
 228     switch(displaytype) {
 229         case 0:
 230         case 3:
 231         case 4: // normal screen
 232         case 5:
 233             // lcd
 234             camera_screen.width = camera_screen.physical_width = camera_screen.buffer_width = 640;
 235             camera_screen.height = camera_screen.buffer_height = 480;
 236             camera_screen.size = camera_screen.buffer_size = 640*480;
 237             break;
 238             // tv-out  - doesn't have analog AV connector
 239         case 1: // NTSC
 240         case 2: // PAL
 241         case 8: // HDMI to non-HD display, (both NTSC and PAL)
 242         case 9:
 243         case 10:
 244             camera_screen.physical_width = camera_screen.width = 720;
 245             camera_screen.buffer_width = 736;
 246             camera_screen.height = camera_screen.buffer_height = 480;
 247             camera_screen.size = 720*480;
 248             camera_screen.buffer_size = 736*480;
 249             break;
 250             // hdmi, playback only
 251         case 6: // NTSC
 252         case 7: // PAL
 253             camera_screen.width = camera_screen.physical_width = camera_screen.buffer_width = 960;
 254             camera_screen.height = camera_screen.buffer_height = 540;
 255             camera_screen.size = camera_screen.buffer_size = 960*540;
 256             break;
 257 // unknown / invalid, but in canon code. Can be set with sub_fc0e383e but display is garbled, unstable
 258         case 11:// O_o
 259             camera_screen.width = camera_screen.physical_width = camera_screen.buffer_width = 1024;
 260             camera_screen.height = camera_screen.buffer_height = 768;
 261             camera_screen.size = 1024*768;
 262             camera_screen.buffer_size = 1024*768;
 263             break;
 264         case 12:// o_0
 265             camera_screen.width = 900;
 266             camera_screen.physical_width = camera_screen.buffer_width = 928;
 267             camera_screen.height = camera_screen.buffer_height = 600;
 268             camera_screen.size = 900*600;
 269             camera_screen.buffer_size = 928*600;
 270             break;
 271 
 272     }
 273     if(displaytype == 6 || displaytype == 7) {
 274         vp_full_width = 1920;
 275         vp_full_buf_width = 1920;
 276         vp_full_height = 1080;
 277     } else {
 278         // others are unclear, but unlikely to come up in practice
 279         vp_full_width = camera_screen.width;
 280         vp_full_buf_width = camera_screen.buffer_width;
 281         vp_full_height = camera_screen.height;
 282     }
 283 }
 284 #endif
 285 
 286 char *camera_jpeg_count_str()
 287 {
 288     extern char jpeg_count_str[];
 289         return jpeg_count_str;
 290 }

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