main.c 15 KB

123456789101112131415161718192021222324252627282930313233343536373839404142434445464748495051525354555657585960616263646566676869707172737475767778798081828384858687888990919293949596979899100101102103104105106107108109110111112113114115116117118119120121122123124125126127128129130131132133134135136137138139140141142143144145146147148149150151152153154155156157158159160161162163164165166167168169170171172173174175176177178179180181182183184185186187188189190191192193194195196197198199200201202203204205206207208209210211212213214215216217218219220221222223224225226227228229230231232233234235236237238239240241242243244245246247248249250251252253254255256257258259260261262263264265266267268269270271272273274275276277278279280281282283284285286287288289290291292293294295296297298299300301302303304305306307308309310311312313314315316317318319320321322323324325326327328329330331332333334335336337338339340341342343344345346347348349350351352353354355356357358359360361362363364365366367368369370371372373374375376377378379380381382383384385386387388389390391392393394395396397398399400401402403404405406407408409410411412413414415416417418419420421422423424425426427428429430431432433434435436437438439440441442443444445446447448449450451452453454455456457458459460461462463464465466467468469470471472473474475476477478479480481482483484485486487488489490491492493494495496497498499500501502503504505506507508509510511512513514515516517518519520521522523524525526527528529530531532533534535536537538539540541542543544545546547548549550551552553554555556557558559560561562563564565566567568569570571
  1. #include "main.h"
  2. #include <errno.h>
  3. #include <fcntl.h>
  4. #include <linux/videodev2.h>
  5. #include <linux/media.h>
  6. #include <linux/v4l2-subdev.h>
  7. #include <sys/ioctl.h>
  8. #include <sys/mman.h>
  9. #include <sys/stat.h>
  10. #include <time.h>
  11. #include <assert.h>
  12. #include <limits.h>
  13. #include <linux/kdev_t.h>
  14. #include <sys/sysmacros.h>
  15. #include <asm/errno.h>
  16. #include <wordexp.h>
  17. #include <gtk/gtk.h>
  18. #include <locale.h>
  19. #include "camera_config.h"
  20. #include "quickpreview.h"
  21. #include "io_pipeline.h"
  22. enum user_control {
  23. USER_CONTROL_ISO,
  24. USER_CONTROL_SHUTTER
  25. };
  26. static bool camera_is_initialized = false;
  27. static const struct mp_camera_config *camera = NULL;
  28. static MPCameraMode mode;
  29. static int preview_width = -1;
  30. static int preview_height = -1;
  31. static bool gain_is_manual = false;
  32. static int gain;
  33. static int gain_max;
  34. static bool exposure_is_manual = false;
  35. static int exposure;
  36. static bool has_auto_focus_continuous;
  37. static bool has_auto_focus_start;
  38. static cairo_surface_t *surface = NULL;
  39. static cairo_surface_t *status_surface = NULL;
  40. static char last_path[260] = "";
  41. static int burst_length = 3;
  42. static enum user_control current_control;
  43. // Widgets
  44. GtkWidget *preview;
  45. GtkWidget *error_box;
  46. GtkWidget *error_message;
  47. GtkWidget *main_stack;
  48. GtkWidget *thumb_last;
  49. GtkWidget *control_box;
  50. GtkWidget *control_name;
  51. GtkAdjustment *control_slider;
  52. GtkWidget *control_auto;
  53. int
  54. remap(int value, int input_min, int input_max, int output_min, int output_max)
  55. {
  56. const long long factor = 1000000000;
  57. long long output_spread = output_max - output_min;
  58. long long input_spread = input_max - input_min;
  59. long long zero_value = value - input_min;
  60. zero_value *= factor;
  61. long long percentage = zero_value / input_spread;
  62. long long zero_output = percentage * output_spread / factor;
  63. long long result = output_min + zero_output;
  64. return (int)result;
  65. }
  66. static void
  67. update_io_pipeline()
  68. {
  69. struct mp_io_pipeline_state io_state = {
  70. .camera = camera,
  71. .burst_length = burst_length,
  72. .preview_width = preview_width,
  73. .preview_height = preview_height,
  74. .gain_is_manual = gain_is_manual,
  75. .gain = gain,
  76. .exposure_is_manual = exposure_is_manual,
  77. .exposure = exposure,
  78. };
  79. mp_io_pipeline_update_state(&io_state);
  80. }
  81. static bool
  82. update_state(const struct mp_main_state *state)
  83. {
  84. if (!camera_is_initialized) {
  85. camera_is_initialized = true;
  86. }
  87. if (camera == state->camera) {
  88. mode = state->mode;
  89. if (!gain_is_manual) {
  90. gain = state->gain;
  91. }
  92. gain_max = state->gain_max;
  93. if (!exposure_is_manual) {
  94. exposure = state->exposure;
  95. }
  96. has_auto_focus_continuous = state->has_auto_focus_continuous;
  97. has_auto_focus_start = state->has_auto_focus_start;
  98. }
  99. return false;
  100. }
  101. void mp_main_update_state(const struct mp_main_state *state)
  102. {
  103. struct mp_main_state *state_copy = malloc(sizeof(struct mp_main_state));
  104. *state_copy = *state;
  105. g_main_context_invoke_full(
  106. g_main_context_default(),
  107. G_PRIORITY_DEFAULT_IDLE,
  108. (GSourceFunc)update_state,
  109. state_copy,
  110. free);
  111. }
  112. static bool
  113. set_preview(cairo_surface_t *image)
  114. {
  115. if (surface) {
  116. cairo_surface_destroy(surface);
  117. }
  118. surface = image;
  119. gtk_widget_queue_draw(preview);
  120. return false;
  121. }
  122. void mp_main_set_preview(cairo_surface_t *image)
  123. {
  124. g_main_context_invoke_full(
  125. g_main_context_default(),
  126. G_PRIORITY_DEFAULT_IDLE,
  127. (GSourceFunc)set_preview,
  128. image,
  129. NULL);
  130. }
  131. static void
  132. draw_surface_scaled_centered(
  133. cairo_t *cr, uint32_t dst_width, uint32_t dst_height, cairo_surface_t *surface)
  134. {
  135. cairo_save(cr);
  136. cairo_translate(cr, dst_width / 2, dst_height / 2);
  137. int width = cairo_image_surface_get_width(surface);
  138. int height = cairo_image_surface_get_height(surface);
  139. double scale = MIN(dst_width / (double) width, dst_height / (double) height);
  140. cairo_scale(cr, scale, scale);
  141. cairo_translate(cr, -width / 2, -height / 2);
  142. cairo_set_source_surface(cr, surface, 0, 0);
  143. cairo_paint(cr);
  144. cairo_restore(cr);
  145. }
  146. static bool
  147. capture_completed(const char *fname)
  148. {
  149. strncpy(last_path, fname, 260);
  150. // Create a thumbnail from the current surface
  151. cairo_surface_t *thumb = cairo_image_surface_create(
  152. CAIRO_FORMAT_ARGB32,
  153. 24,
  154. 24);
  155. cairo_t *cr = cairo_create(thumb);
  156. draw_surface_scaled_centered(cr, 24, 24, surface);
  157. cairo_destroy(cr);
  158. gtk_image_set_from_surface(GTK_IMAGE(thumb_last), thumb);
  159. cairo_surface_destroy(thumb);
  160. return false;
  161. }
  162. void mp_main_capture_completed(const char *fname)
  163. {
  164. gchar *name = g_strdup(fname);
  165. g_main_context_invoke_full(
  166. g_main_context_default(),
  167. G_PRIORITY_DEFAULT_IDLE,
  168. (GSourceFunc)capture_completed,
  169. name,
  170. g_free);
  171. }
  172. static void
  173. draw_controls()
  174. {
  175. cairo_t *cr;
  176. char iso[6];
  177. int temp;
  178. char shutterangle[6];
  179. if (exposure_is_manual) {
  180. temp = (int)((float)exposure / (float)camera->capture_mode.height * 360);
  181. sprintf(shutterangle, "%d\u00b0", temp);
  182. } else {
  183. sprintf(shutterangle, "auto");
  184. }
  185. if (gain_is_manual) {
  186. temp = remap(gain - 1, 0, gain_max, camera->iso_min, camera->iso_max);
  187. sprintf(iso, "%d", temp);
  188. } else {
  189. sprintf(iso, "auto");
  190. }
  191. if (status_surface)
  192. cairo_surface_destroy(status_surface);
  193. // Make a service to show status of controls, 32px high
  194. if (gtk_widget_get_window(preview) == NULL) {
  195. return;
  196. }
  197. status_surface = gdk_window_create_similar_surface(gtk_widget_get_window(preview),
  198. CAIRO_CONTENT_COLOR_ALPHA,
  199. preview_width, 32);
  200. cr = cairo_create(status_surface);
  201. cairo_set_source_rgba(cr, 0, 0, 0, 0.0);
  202. cairo_paint(cr);
  203. // Draw the outlines for the headings
  204. cairo_select_font_face(cr, "sans-serif", CAIRO_FONT_SLANT_NORMAL, CAIRO_FONT_WEIGHT_BOLD);
  205. cairo_set_font_size(cr, 9);
  206. cairo_set_source_rgba(cr, 0, 0, 0, 1);
  207. cairo_move_to(cr, 16, 16);
  208. cairo_text_path(cr, "ISO");
  209. cairo_stroke(cr);
  210. cairo_move_to(cr, 60, 16);
  211. cairo_text_path(cr, "Shutter");
  212. cairo_stroke(cr);
  213. // Draw the fill for the headings
  214. cairo_set_source_rgba(cr, 1, 1, 1, 1);
  215. cairo_move_to(cr, 16, 16);
  216. cairo_show_text(cr, "ISO");
  217. cairo_move_to(cr, 60, 16);
  218. cairo_show_text(cr, "Shutter");
  219. // Draw the outlines for the values
  220. cairo_select_font_face(cr, "sans-serif", CAIRO_FONT_SLANT_NORMAL, CAIRO_FONT_WEIGHT_NORMAL);
  221. cairo_set_font_size(cr, 11);
  222. cairo_set_source_rgba(cr, 0, 0, 0, 1);
  223. cairo_move_to(cr, 16, 26);
  224. cairo_text_path(cr, iso);
  225. cairo_stroke(cr);
  226. cairo_move_to(cr, 60, 26);
  227. cairo_text_path(cr, shutterangle);
  228. cairo_stroke(cr);
  229. // Draw the fill for the values
  230. cairo_set_source_rgba(cr, 1, 1, 1, 1);
  231. cairo_move_to(cr, 16, 26);
  232. cairo_show_text(cr, iso);
  233. cairo_move_to(cr, 60, 26);
  234. cairo_show_text(cr, shutterangle);
  235. cairo_destroy(cr);
  236. gtk_widget_queue_draw_area(preview, 0, 0, preview_width, 32);
  237. }
  238. static gboolean
  239. preview_draw(GtkWidget *widget, cairo_t *cr, gpointer data)
  240. {
  241. if (!camera_is_initialized) {
  242. return FALSE;
  243. }
  244. // Clear preview area with black
  245. cairo_paint(cr);
  246. // Draw camera preview
  247. if (surface) {
  248. draw_surface_scaled_centered(cr, preview_width, preview_height, surface);
  249. }
  250. // Draw control overlay
  251. cairo_set_source_surface(cr, status_surface, 0, 0);
  252. cairo_paint(cr);
  253. return FALSE;
  254. }
  255. static gboolean
  256. preview_configure(GtkWidget *widget, GdkEventConfigure *event)
  257. {
  258. int new_preview_width = gtk_widget_get_allocated_width(widget);
  259. int new_preview_height = gtk_widget_get_allocated_height(widget);
  260. if (preview_width != new_preview_width || preview_height != new_preview_height)
  261. {
  262. preview_width = new_preview_width;
  263. preview_height = new_preview_height;
  264. update_io_pipeline();
  265. }
  266. draw_controls();
  267. return TRUE;
  268. }
  269. void
  270. on_open_last_clicked(GtkWidget *widget, gpointer user_data)
  271. {
  272. char uri[275];
  273. GError *error = NULL;
  274. if(strlen(last_path) == 0) {
  275. return;
  276. }
  277. sprintf(uri, "file://%s.tiff", last_path);
  278. if(!g_app_info_launch_default_for_uri(uri, NULL, &error)){
  279. g_printerr("Could not launch image viewer: %s\n", error->message);
  280. }
  281. }
  282. void
  283. on_open_directory_clicked(GtkWidget *widget, gpointer user_data)
  284. {
  285. char uri[270];
  286. GError *error = NULL;
  287. sprintf(uri, "file://%s/Pictures", getenv("HOME"));
  288. if(!g_app_info_launch_default_for_uri(uri, NULL, &error)){
  289. g_printerr("Could not launch image viewer: %s\n", error->message);
  290. }
  291. }
  292. void
  293. on_shutter_clicked(GtkWidget *widget, gpointer user_data)
  294. {
  295. mp_io_pipeline_capture();
  296. }
  297. void
  298. on_preview_tap(GtkWidget *widget, GdkEventButton *event, gpointer user_data)
  299. {
  300. if (event->type != GDK_BUTTON_PRESS)
  301. return;
  302. // Handle taps on the controls
  303. if (event->y < 32) {
  304. if (gtk_widget_is_visible(control_box)) {
  305. gtk_widget_hide(control_box);
  306. return;
  307. } else {
  308. gtk_widget_show(control_box);
  309. }
  310. if (event->x < 60 ) {
  311. // ISO
  312. current_control = USER_CONTROL_ISO;
  313. gtk_label_set_text(GTK_LABEL(control_name), "ISO");
  314. gtk_toggle_button_set_active(GTK_TOGGLE_BUTTON(control_auto), !gain_is_manual);
  315. gtk_adjustment_set_lower(control_slider, 0.0);
  316. gtk_adjustment_set_upper(control_slider, (float)gain_max);
  317. gtk_adjustment_set_value(control_slider, (double)gain);
  318. } else if (event->x > 60 && event->x < 120) {
  319. // Shutter angle
  320. current_control = USER_CONTROL_SHUTTER;
  321. gtk_label_set_text(GTK_LABEL(control_name), "Shutter");
  322. gtk_toggle_button_set_active(GTK_TOGGLE_BUTTON(control_auto), !exposure_is_manual);
  323. gtk_adjustment_set_lower(control_slider, 1.0);
  324. gtk_adjustment_set_upper(control_slider, 360.0);
  325. gtk_adjustment_set_value(control_slider, (double)exposure);
  326. }
  327. return;
  328. }
  329. // Tapped preview image itself, try focussing
  330. if (has_auto_focus_start) {
  331. mp_io_pipeline_focus();
  332. }
  333. }
  334. void
  335. on_error_close_clicked(GtkWidget *widget, gpointer user_data)
  336. {
  337. gtk_widget_hide(error_box);
  338. }
  339. void
  340. on_camera_switch_clicked(GtkWidget *widget, gpointer user_data)
  341. {
  342. size_t next_index = camera->index + 1;
  343. const struct mp_camera_config *next_camera = mp_get_camera_config(next_index);
  344. if (!next_camera) {
  345. next_index = 0;
  346. next_camera = mp_get_camera_config(next_index);
  347. }
  348. camera = next_camera;
  349. update_io_pipeline();
  350. }
  351. void
  352. on_settings_btn_clicked(GtkWidget *widget, gpointer user_data)
  353. {
  354. gtk_stack_set_visible_child_name(GTK_STACK(main_stack), "settings");
  355. }
  356. void
  357. on_back_clicked(GtkWidget *widget, gpointer user_data)
  358. {
  359. gtk_stack_set_visible_child_name(GTK_STACK(main_stack), "main");
  360. }
  361. void
  362. on_control_auto_toggled(GtkToggleButton *widget, gpointer user_data)
  363. {
  364. bool is_manual = gtk_toggle_button_get_active(widget) ? false : true;
  365. bool has_changed;
  366. switch (current_control) {
  367. case USER_CONTROL_ISO:
  368. if (gain_is_manual != is_manual) {
  369. gain_is_manual = is_manual;
  370. has_changed = true;
  371. }
  372. break;
  373. case USER_CONTROL_SHUTTER:
  374. if (exposure_is_manual != is_manual) {
  375. exposure_is_manual = is_manual;
  376. has_changed = true;
  377. }
  378. break;
  379. }
  380. if (has_changed) {
  381. update_io_pipeline();
  382. draw_controls();
  383. }
  384. }
  385. void
  386. on_control_slider_changed(GtkAdjustment *widget, gpointer user_data)
  387. {
  388. double value = gtk_adjustment_get_value(widget);
  389. bool has_changed = false;
  390. switch (current_control) {
  391. case USER_CONTROL_ISO:
  392. if (value != gain) {
  393. gain = (int)value;
  394. has_changed = true;
  395. }
  396. break;
  397. case USER_CONTROL_SHUTTER:
  398. {
  399. // So far all sensors use exposure time in number of sensor rows
  400. int new_exposure = (int)(value / 360.0 * camera->capture_mode.height);
  401. if (new_exposure != exposure) {
  402. exposure = new_exposure;
  403. has_changed = true;
  404. }
  405. break;
  406. }
  407. }
  408. if (has_changed) {
  409. update_io_pipeline();
  410. draw_controls();
  411. }
  412. }
  413. int
  414. main(int argc, char *argv[])
  415. {
  416. if (!mp_load_config())
  417. return 1;
  418. setenv("LC_NUMERIC", "C", 1);
  419. gtk_init(&argc, &argv);
  420. g_object_set(gtk_settings_get_default(), "gtk-application-prefer-dark-theme", TRUE, NULL);
  421. GtkBuilder *builder = gtk_builder_new_from_resource("/org/postmarketos/Megapixels/camera.glade");
  422. GtkWidget *window = GTK_WIDGET(gtk_builder_get_object(builder, "window"));
  423. GtkWidget *shutter = GTK_WIDGET(gtk_builder_get_object(builder, "shutter"));
  424. GtkWidget *switch_btn = GTK_WIDGET(gtk_builder_get_object(builder, "switch_camera"));
  425. GtkWidget *settings_btn = GTK_WIDGET(gtk_builder_get_object(builder, "settings"));
  426. GtkWidget *settings_back = GTK_WIDGET(gtk_builder_get_object(builder, "settings_back"));
  427. GtkWidget *error_close = GTK_WIDGET(gtk_builder_get_object(builder, "error_close"));
  428. GtkWidget *open_last = GTK_WIDGET(gtk_builder_get_object(builder, "open_last"));
  429. GtkWidget *open_directory = GTK_WIDGET(gtk_builder_get_object(builder, "open_directory"));
  430. preview = GTK_WIDGET(gtk_builder_get_object(builder, "preview"));
  431. error_box = GTK_WIDGET(gtk_builder_get_object(builder, "error_box"));
  432. error_message = GTK_WIDGET(gtk_builder_get_object(builder, "error_message"));
  433. main_stack = GTK_WIDGET(gtk_builder_get_object(builder, "main_stack"));
  434. thumb_last = GTK_WIDGET(gtk_builder_get_object(builder, "thumb_last"));
  435. control_box = GTK_WIDGET(gtk_builder_get_object(builder, "control_box"));
  436. control_name = GTK_WIDGET(gtk_builder_get_object(builder, "control_name"));
  437. control_slider = GTK_ADJUSTMENT(gtk_builder_get_object(builder, "control_adj"));
  438. control_auto = GTK_WIDGET(gtk_builder_get_object(builder, "control_auto"));
  439. g_signal_connect(window, "destroy", G_CALLBACK(gtk_main_quit), NULL);
  440. g_signal_connect(shutter, "clicked", G_CALLBACK(on_shutter_clicked), NULL);
  441. g_signal_connect(error_close, "clicked", G_CALLBACK(on_error_close_clicked), NULL);
  442. g_signal_connect(switch_btn, "clicked", G_CALLBACK(on_camera_switch_clicked), NULL);
  443. g_signal_connect(settings_btn, "clicked", G_CALLBACK(on_settings_btn_clicked), NULL);
  444. g_signal_connect(settings_back, "clicked", G_CALLBACK(on_back_clicked), NULL);
  445. g_signal_connect(open_last, "clicked", G_CALLBACK(on_open_last_clicked), NULL);
  446. g_signal_connect(open_directory, "clicked", G_CALLBACK(on_open_directory_clicked), NULL);
  447. g_signal_connect(preview, "draw", G_CALLBACK(preview_draw), NULL);
  448. g_signal_connect(preview, "configure-event", G_CALLBACK(preview_configure), NULL);
  449. gtk_widget_set_events(preview, gtk_widget_get_events(preview) |
  450. GDK_BUTTON_PRESS_MASK | GDK_POINTER_MOTION_MASK);
  451. g_signal_connect(preview, "button-press-event", G_CALLBACK(on_preview_tap), NULL);
  452. g_signal_connect(control_auto, "toggled", G_CALLBACK(on_control_auto_toggled), NULL);
  453. g_signal_connect(control_slider, "value-changed", G_CALLBACK(on_control_slider_changed), NULL);
  454. GtkCssProvider *provider = gtk_css_provider_new();
  455. if (access("camera.css", F_OK) != -1) {
  456. gtk_css_provider_load_from_path(provider, "camera.css", NULL);
  457. } else {
  458. gtk_css_provider_load_from_resource(provider, "/org/postmarketos/Megapixels/camera.css");
  459. }
  460. GtkStyleContext *context = gtk_widget_get_style_context(error_box);
  461. gtk_style_context_add_provider(context,
  462. GTK_STYLE_PROVIDER(provider),
  463. GTK_STYLE_PROVIDER_PRIORITY_USER);
  464. context = gtk_widget_get_style_context(control_box);
  465. gtk_style_context_add_provider(context,
  466. GTK_STYLE_PROVIDER(provider),
  467. GTK_STYLE_PROVIDER_PRIORITY_USER);
  468. mp_io_pipeline_start();
  469. camera = mp_get_camera_config(0);
  470. update_io_pipeline();
  471. gtk_widget_show(window);
  472. gtk_main();
  473. mp_io_pipeline_stop();
  474. return 0;
  475. }