开通博客赚积分
发布资源赚积分
分类

源码开发语言/平台
当前位置：首页 > 源码/资料 > Internet/网络编程 > 浏览器 > 查看源码
main.c
资源名称：fbv-1.0b.tar.gz　[点击查看]
上传用户：hengzhunsh
上传日期：2013-09-07
资源大小：19k
文件大小：13k
源码类别：

浏览器

开发平台：

Unix_Linux

main.c：源码内容
  1. /*
  2. fbv  --  simple image viewer for the linux framebuffer
  3. Copyright (C) 2000, 2001, 2003, 2004  Mateusz 'mteg' Golicz
  5. This program is free software; you can redistribute it and/or modify
  6. it under the terms of the GNU General Public License as published by
  7. the Free Software Foundation; either version 2 of the License, or
  8. (at your option) any later version.
  10. This program is distributed in the hope that it will be useful,
  11. but WITHOUT ANY WARRANTY; without even the implied warranty of
  12. MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
  13. GNU General Public License for more details.
  15. You should have received a copy of the GNU General Public License
  16. along with this program; if not, write to the Free Software
  17. Foundation, Inc., 675 Mass Ave, Cambridge, MA 02139, USA.
  18. */
  20. #include <stdio.h>
  21. #include <sys/time.h>
  22. #include <sys/types.h>
  23. #include <unistd.h>
  24. #include <getopt.h>
  25. #include <stdlib.h>
  26. #include <termios.h>
  27. #include <string.h>
  28. #include <signal.h>
  29. #include "config.h"
  30. #include "fbv.h"
  32. #define PAN_STEPPING 20
  34. static int opt_clear = 1,
  35.    opt_alpha = 0,
  36.    opt_hide_cursor = 1,
  37.    opt_image_info = 1,
  38.    opt_stretch = 0,
  39.    opt_delay = 0,
  40.    opt_enlarge = 0,
  41.    opt_ignore_aspect = 0;
  45. void setup_console(int t)
  46. {
  47. struct termios our_termios;
  48. static struct termios old_termios;
  50. if(t)
  51. {
  52. tcgetattr(0, &old_termios);
  53. memcpy(&our_termios, &old_termios, sizeof(struct termios));
  54. our_termios.c_lflag &= !(ECHO | ICANON);
  55. tcsetattr(0, TCSANOW, &our_termios);
  56. }
  57. else
  58. tcsetattr(0, TCSANOW, &old_termios);
  60. }
  62. static inline void do_rotate(struct image *i, int rot)
  63. {
  64. if(rot)
  65. {
  66. unsigned char *image, *alpha = NULL;
  67. int t;
  69. image = rotate(i->rgb, i->width, i->height, rot);
  70. if(i->alpha)
  71. alpha = alpha_rotate(i->alpha, i->width, i->height, rot);
  72. if(i->do_free)
  73. {
  74. free(i->alpha);
  75. free(i->rgb);
  76. }
  78. i->rgb = image;
  79. i->alpha = alpha;
  80. i->do_free = 1;
  82. if(rot & 1)
  83. {
  84. t = i->width;
  85. i->width = i->height;
  86. i->height = t;
  87. }
  88. }
  89. }
  92. static inline void do_enlarge(struct image *i, int screen_width, int screen_height, int ignoreaspect)
  93. {
  94. if(((i->width > screen_width) || (i->height > screen_height)) && (!ignoreaspect))
  95. return;
  96. if((i->width < screen_width) || (i->height < screen_height))
  97. {
  98. int xsize = i->width, ysize = i->height;
  99. unsigned char * image, * alpha = NULL;
  101. if(ignoreaspect)
  102. {
  103. if(i->width < screen_width)
  104. xsize = screen_width;
  105. if(i->height < screen_height)
  106. ysize = screen_height;
  108. goto have_sizes;
  109. }
  111. if((i->height * screen_width / i->width) <= screen_height)
  112. {
  113. xsize = screen_width;
  114. ysize = i->height * screen_width / i->width;
  115. goto have_sizes;
  116. }
  118. if((i->width * screen_height / i->height) <= screen_width)
  119. {
  120. xsize = i->width * screen_height / i->height;
  121. ysize = screen_height;
  122. goto have_sizes;
  123. }
  124. return;
  125. have_sizes:
  126. image = simple_resize(i->rgb, i->width, i->height, xsize, ysize);
  127. if(i->alpha)
  128. alpha = alpha_resize(i->alpha, i->width, i->height, xsize, ysize);
  130. if(i->do_free)
  131. {
  132. free(i->alpha);
  133. free(i->rgb);
  134. }
  136. i->rgb = image;
  137. i->alpha = alpha;
  138. i->do_free = 1;
  139. i->width = xsize;
  140. i->height = ysize;
  141. }
  142. }
  145. static inline void do_fit_to_screen(struct image *i, int screen_width, int screen_height, int ignoreaspect, int cal)
  146. {
  147. if((i->width > screen_width) || (i->height > screen_height))
  148. {
  149. unsigned char * new_image, * new_alpha = NULL;
  150. int nx_size = i->width, ny_size = i->height;
  152. if(ignoreaspect)
  153. {
  154. if(i->width > screen_width)
  155. nx_size = screen_width;
  156. if(i->height > screen_height)
  157. ny_size = screen_height;
  158. }
  159. else
  160. {
  161. if((i->height * screen_width / i->width) <= screen_height)
  162. {
  163. nx_size = screen_width;
  164. ny_size = i->height * screen_width / i->width;
  165. }
  166. else
  167. {
  168. nx_size = i->width * screen_height / i->height;
  169. ny_size = screen_height;
  170. }
  171. }
  173. if(cal)
  174. new_image = color_average_resize(i->rgb, i->width, i->height, nx_size, ny_size);
  175. else
  176. new_image = simple_resize(i->rgb, i->width, i->height, nx_size, ny_size);
  178. if(i->alpha)
  179. new_alpha = alpha_resize(i->alpha, i->width, i->height, nx_size, ny_size);
  181. if(i->do_free)
  182. {
  183. free(i->alpha);
  184. free(i->rgb);
  185. }
  187. i->rgb = new_image;
  188. i->alpha = new_alpha;
  189. i->do_free = 1;
  190. i->width = nx_size;
  191. i->height = ny_size;
  192. }
  193. }
  196. int show_image(char *filename)
  197. {
  198. int (*load)(char *, unsigned char *, unsigned char **, int, int);
  200. unsigned char * image = NULL;
  201. unsigned char * alpha = NULL;
  203. int x_size, y_size, screen_width, screen_height;
  204. int x_pan, y_pan, x_offs, y_offs, refresh = 1, c, ret = 1;
  205. int delay = opt_delay, retransform = 1;
  207. int transform_stretch = opt_stretch, transform_enlarge = opt_enlarge, transform_cal = (opt_stretch == 2),
  208.     transform_iaspect = opt_ignore_aspect, transform_rotation = 0;
  210. struct image i;
  212. #ifdef FBV_SUPPORT_GIF
  213. if(fh_gif_id(filename))
  214. if(fh_gif_getsize(filename, &x_size, &y_size) == FH_ERROR_OK)
  215. {
  216. load = fh_gif_load;
  217. goto identified;
  218. }
  219. #endif
  221. #ifdef FBV_SUPPORT_PNG
  222. if(fh_png_id(filename))
  223. if(fh_png_getsize(filename, &x_size, &y_size) == FH_ERROR_OK)
  224. {
  225. load = fh_png_load;
  226. goto identified;
  227. }
  228. #endif
  230. #ifdef FBV_SUPPORT_JPEG
  231. if(fh_jpeg_id(filename))
  232. if(fh_jpeg_getsize(filename, &x_size, &y_size) == FH_ERROR_OK)
  233. {
  234. load = fh_jpeg_load;
  235. goto identified;
  236. }
  237. #endif
  239. #ifdef FBV_SUPPORT_BMP
  240. if(fh_bmp_id(filename))
  241. if(fh_bmp_getsize(filename, &x_size, &y_size) == FH_ERROR_OK)
  242. {
  243. load = fh_bmp_load;
  244. goto identified;
  245. }
  246. #endif
  247. fprintf(stderr, "%s: Unable to access file or file format unknown.n", filename);
  248. return(1);
  250. identified:
  252. if(!(image = (unsigned char*) malloc(x_size * y_size * 3)))
  253. {
  254. fprintf(stderr, "%s: Out of memory.n", filename);
  255. goto error_mem;
  256. }
  258. if(load(filename, image, &alpha, x_size, y_size) != FH_ERROR_OK)
  259. {
  260. fprintf(stderr, "%s: Image data is corrupt?n", filename);
  261. goto error_mem;
  262. }
  264. if(!opt_alpha)
  265. {
  266. free(alpha);
  267. alpha = NULL;
  268. }
  272. getCurrentRes(&screen_width, &screen_height);
  273. i.do_free = 0;
  274. while(1)
  275. {
  276. if(retransform)
  277. {
  278. if(i.do_free)
  279. {
  280. free(i.rgb);
  281. free(i.alpha);
  282. }
  283. i.width = x_size;
  284. i.height = y_size;
  285. i.rgb = image;
  286. i.alpha = alpha;
  287. i.do_free = 0;
  290. if(transform_rotation)
  291. do_rotate(&i, transform_rotation);
  293. if(transform_stretch)
  294. do_fit_to_screen(&i, screen_width, screen_height, transform_iaspect, transform_cal);
  296. if(transform_enlarge)
  297. do_enlarge(&i, screen_width, screen_height, transform_iaspect);
  299. x_pan = y_pan = 0;
  300. refresh = 1; retransform = 0;
  301. if(opt_clear)
  302. {
  303. printf("33[H33[J");
  304. fflush(stdout);
  305. }
  306. if(opt_image_info)
  307. printf("fbv - The Framebuffer Viewern%sn%d x %dn", filename, x_size, y_size); 
  308. }
  309. if(refresh)
  310. {
  311. if(i.width < screen_width)
  312. x_offs = (screen_width - i.width) / 2;
  313. else
  314. x_offs = 0;
  316. if(i.height < screen_height)
  317. y_offs = (screen_height - i.height) / 2;
  318. else
  319. y_offs = 0;
  321. fb_display(i.rgb, i.alpha, i.width, i.height, x_pan, y_pan, x_offs, y_offs);
  322. refresh = 0;
  323. }
  324. if(delay)
  325. {
  326. struct timeval tv;
  327. fd_set fds;
  328. tv.tv_sec = delay / 10;
  329. tv.tv_usec = (delay % 10) * 100000;
  330. FD_ZERO(&fds);
  331. FD_SET(0, &fds);
  333. if(select(1, &fds, NULL, NULL, &tv) <= 0)
  334. break;
  335. delay = 0;
  336. }
  338. c = getchar();
  339. switch(c)
  340. {
  341. case EOF:
  342. case 'q':
  343. ret = 0;
  344. goto done;
  345. case ' ': case 10: case 13: 
  346. goto done;
  347. case '>': case '.':
  348. goto done;
  349. case '<': case ',':
  350. ret = -1;
  351. goto done;
  352. case 'r':
  353. refresh = 1;
  354. break;
  355. case 'a': case 'D':
  356. if(x_pan == 0) break;
  357. x_pan -= i.width / PAN_STEPPING;
  358. if(x_pan < 0) x_pan = 0;
  359. refresh = 1;
  360. break;
  361. case 'd': case 'C':
  362. if(x_offs) break;
  363. if(x_pan >= (i.width - screen_width)) break;
  364. x_pan += i.width / PAN_STEPPING;
  365. if(x_pan > (i.width - screen_width)) x_pan = i.width - screen_width;
  366. refresh = 1;
  367. break;
  368. case 'w': case 'A':
  369. if(y_pan == 0) break;
  370. y_pan -= i.height / PAN_STEPPING;
  371. if(y_pan < 0) y_pan = 0;
  372. refresh = 1;
  373. break;
  374. case 'x': case 'B':
  375. if(y_offs) break;
  376. if(y_pan >= (i.height - screen_height)) break;
  377. y_pan += i.height / PAN_STEPPING;
  378. if(y_pan > (i.height - screen_height)) y_pan = i.height - screen_height;
  379. refresh = 1;
  380. break;
  381. case 'f': 
  382. transform_stretch = !transform_stretch;
  383. retransform = 1;
  384. break;
  385. case 'e':
  386. transform_enlarge = !transform_enlarge;
  387. retransform = 1;
  388. break;
  389. case 'k':
  390. transform_cal = !transform_cal;
  391. retransform = 1;
  392. break;
  393. case 'i':
  394. transform_iaspect = !transform_iaspect;
  395. retransform = 1;
  396. break;
  397. case 'p':
  398. transform_cal = 0;
  399. transform_iaspect = 0;
  400. transform_enlarge = 0;
  401. transform_stretch = 0;
  402. retransform = 1;
  403. break;
  404. case 'n':
  405. transform_rotation -= 1;
  406. if(transform_rotation < 0)
  407. transform_rotation += 4;
  408. retransform = 1;
  409. break;
  410. case 'm':
  411. transform_rotation += 1;
  412. if(transform_rotation > 3)
  413. transform_rotation -= 4;
  414. retransform = 1;
  415. break;
  417. }
  419. }
  421. done:
  422. if(opt_clear)
  423. {
  424. printf("33[H33[J");
  425. fflush(stdout);
  426. }
  428. error_mem:
  429. free(image);
  430. free(alpha);
  431. if(i.do_free)
  432. {
  433. free(i.rgb);
  434. free(i.alpha);
  435. }
  436. return(ret);
  438. }
  440. void help(char *name)
  441. {
  442. printf("Usage: %s [options] image1 image2 image3 ...nn"
  443.    "Available options:n"
  444.    " --help        | -h : Show this helpn"
  445.    " --alpha       | -a : Use the alpha channel (if applicable)n"
  446.    " --dontclear   | -c : Do not clear the screen before and after displaying the imagen"
  447.    " --donthide    | -u : Do not hide the cursor before and after displaying the imagen"
  448.    " --noinfo      | -i : Supress image informationn"
  449.    " --stretch     | -f : Strech (using a simple resizing routine) the image to fit onto screen if necessaryn"
  450.    " --colorstretch| -k : Strech (using a 'color average' resizing routine) the image to fit onto screen if necessaryn"
  451.    " --enlarge     | -e : Enlarge the image to fit the whole screen if necessaryn"
  452.    " --ignore-aspect| -r : Ignore the image aspect while resizingn"
  453.                    " --delay <d>   | -s <delay> : Slideshow, 'delay' is the slideshow delay in tenths of seconds.nn"
  454.    "Keys:n"
  455.    " r            : Redraw the imagen"
  456.    " a, d, w, x   : Pan the imagen"
  457.    " f            : Toggle resizing on/offn"
  458.    " k            : Toggle resizing qualityn"
  459.    " e            : Toggle enlarging on/offn"
  460.    " i            : Toggle respecting the image aspect on/offn"
  461.    " n            : Rotate the image 90 degrees leftn"
  462.    " m            : Rotate the image 90 degrees rightn"
  463.    " p            : Disable all transformationsn"
  464.    "Copyright (C) 2000 - 2004 Mateusz Golicz, Tomasz Sterna.n", name);
  465. }
  467. void sighandler(int s)
  468. {
  469. if(opt_hide_cursor)
  470. {
  471. printf("33[?25h");
  472. fflush(stdout);
  473. }
  474. setup_console(0);
  475. _exit(128 + s);
  477. }
  479. int main(int argc, char **argv)
  480. {
  481. static struct option long_options[] =
  482. {
  483. {"help", no_argument, 0, 'h'},
  484. {"noclear",  no_argument,  0, 'c'},
  485. {"alpha",  no_argument,  0, 'a'},
  486. {"unhide",   no_argument,  0, 'u'},
  487. {"noinfo",   no_argument,  0, 'i'},
  488. {"stretch",  no_argument,  0, 'f'},
  489. {"colorstrech", no_argument,  0, 'k'},
  490. {"delay",  required_argument, 0, 's'},
  491. {"enlarge", no_argument, 0, 'e'},
  492. {"ignore-aspect", no_argument, 0, 'r'},
  493. {0, 0, 0, 0}
  494. };
  495. int c, i;
  497. if(argc < 2)
  498. {
  499. help(argv[0]);
  500. fprintf(stderr, "Error: Required argument missing.n");
  501. return(1);
  502. }
  504. while((c = getopt_long_only(argc, argv, "hcauifks:er", long_options, NULL)) != EOF)
  505. {
  506. switch(c)
  507. {
  508. case 'a':
  509. opt_alpha = 1;
  510. break;
  511. case 'c':
  512. opt_clear = 0;
  513. break;
  514. case 's':
  515. opt_delay = atoi(optarg);
  516. break;
  517. case 'u':
  518. opt_hide_cursor = 0;
  519. break;
  520. case 'h':
  521. help(argv[0]);
  522. return(0);
  523. case 'i':
  524. opt_image_info = 0;
  525. break;
  526. case 'f':
  527. opt_stretch = 1;
  528. break;
  529. case 'k':
  530. opt_stretch = 2;
  531. break;
  532. case 'e':
  533. opt_enlarge = 1;
  534. break;
  535. case 'r':
  536. opt_ignore_aspect = 1;
  537. break;
  538. }
  539. }
  542. if(!argv[optind])
  543. {
  544. fprintf(stderr, "Required argument missing! Consult %s -h.n", argv[0]);
  545. return(1);
  546. }
  548. signal(SIGHUP, sighandler);
  549. signal(SIGINT, sighandler);
  550. signal(SIGQUIT, sighandler);
  551. signal(SIGSEGV, sighandler);
  552. signal(SIGTERM, sighandler);
  553. signal(SIGABRT, sighandler);
  555. if(opt_hide_cursor)
  556. {
  557. printf("33[?25l");
  558. fflush(stdout);
  559. }
  561. setup_console(1);
  563. for(i = optind; argv[i]; )
  564. {
  565. int r = show_image(argv[i]);
  567. if(!r) break;
  569. i += r;
  570. if(i < optind)
  571. i = optind;
  572. }
  574. setup_console(0);
  576. if(opt_hide_cursor)
  577. {
  578. printf("33[?25h");
  579. fflush(stdout);
  580. }
  581. return(0);
  582. }