cacalabs
/
libcaca
espelhamento de https://github.com/cacalabs/libcaca.git
1
0
Fork 0
Código Issues 0 Versões 7 Wiki Atividade
247 Commits
1 Branch
6.0 MiB
 
 
 
 
 
 
Tag: 8b7bd031a7
libcaca/examples/cacaview.c

674 linhas
19 KiB
Original Anotar Histórico 

  1. /*

  2.  *  cacaview      image viewer for libcaca

  3.  *  Copyright (c) 2003 Sam Hocevar <sam@zoy.org>

  4.  *                All Rights Reserved

  5.  *

  6.  *  $Id$

  7.  *

  8.  *  This program is free software; you can redistribute it and/or

  9.  *  modify it under the terms of the GNU Lesser General Public

  10.  *  License as published by the Free Software Foundation; either

  11.  *  version 2 of the License, or (at your option) any later version.

  12.  *

  13.  *  This program is distributed in the hope that it will be useful,

  14.  *  but WITHOUT ANY WARRANTY; without even the implied warranty of

  15.  *  MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU

  16.  *  Lesser General Public License for more details.

  17.  *

  18.  *  You should have received a copy of the GNU Lesser General Public

  19.  *  License along with this program; if not, write to the Free Software

  20.  *  Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA

  21.  *  02111-1307  USA

  22.  */

  23. 

  24. #include "config.h"

  25. 

  26. #include <stdio.h>

  27. #include <string.h>

  28. #include <stdlib.h>

  29. 

  30. #if defined(HAVE_IMLIB2_H)

  31. #   include <Imlib2.h>

  32. #else

  33. #   include <stdio.h>

  34. #endif

  35. 

  36. #if defined(HAVE_SLEEP)

  37. #   include <windows.h>

  38. #endif

  39. 

  40. #include "caca.h"

  41. 

  42. /* Local macros */

  43. #define STATUS_DITHERING 1

  44. #define STATUS_ANTIALIASING 2

  45. #define STATUS_BACKGROUND 3

  46. 

  47. /* Local functions */

  48. static void load_image(char const *);

  49. static void unload_image(void);

  50. static void draw_checkers(unsigned int, unsigned int,

  51.                           unsigned int, unsigned int);

  52. #if !defined(HAVE_IMLIB2_H)

  53. static int freadint(FILE *);

  54. static int freadshort(FILE *);

  55. static int freadchar(FILE *);

  56. #endif

  57. 

  58. /* Local variables */

  59. #if defined(HAVE_IMLIB2_H)

  60. Imlib_Image image = NULL;

  61. #endif

  62. char *pixels = NULL;

  63. struct caca_bitmap *bitmap = NULL;

  64. int x, y;

  65. unsigned int w, h, depth, bpp, rmask, gmask, bmask, amask;

  66. #if !defined(HAVE_IMLIB2_H)

  67. unsigned int red[256], green[256], blue[256], alpha[256];

  68. #endif

  69. 

  70. int main(int argc, char **argv)

  71. {

  72.     int quit = 0, update = 1, help = 0, fullscreen = 0, status = 0;

  73.     int reload = 0, zoom = 0;

  74. 

  75.     char **list = NULL;

  76.     int current = 0, items = 0, opts = 1;

  77.     int i;

  78. 

  79.     /* Initialise libcaca */

  80.     if(caca_init())

  81.     {

  82.         fprintf(stderr, "%s: unable to initialise libcaca\n", argv[0]);

  83.         return 1;

  84.     }

  85. 

  86.     /* Set the window title */

  87.     caca_set_window_title("cacaview");

  88. 

  89.     /* Load items into playlist */

  90.     for(i = 1; i < argc; i++)

  91.     {

  92.         /* Skip options except after `--' */

  93.         if(opts && argv[i][0] == '-')

  94.         {

  95.             if(argv[i][1] == '-' && argv[i][2] == '\0')

  96.                 opts = 0;

  97.             continue;

  98.         }

  99. 

  100.         /* Add argv[i] to the list */

  101.         if(items)

  102.             list = realloc(list, (items + 1) * sizeof(char *));

  103.         else

  104.             list = malloc(sizeof(char *));

  105.         list[items] = argv[i];

  106.         items++;

  107. 

  108.         reload = 1;

  109.     }

  110. 

  111.     /* Go ! */

  112.     while(!quit)

  113.     {

  114.         int ww, wh;

  115.         unsigned int event, new_status = 0, new_help = 0;

  116. 

  117.         ww = caca_get_width();

  118.         wh = caca_get_height();

  119. 

  120.         if(update)

  121.             event = caca_get_event(CACA_EVENT_KEY_PRESS | CACA_EVENT_RESIZE);

  122.         else

  123.             event = caca_wait_event(CACA_EVENT_KEY_PRESS | CACA_EVENT_RESIZE);

  124. 

  125.         while(event)

  126.         {

  127.             unsigned int key = event & 0x00ffffff;

  128. 

  129.             if(key) switch(key)

  130.             {

  131.             case 'n':

  132.             case 'N':

  133.                 if(items) current = (current + 1) % items;

  134.                 reload = 1;

  135.                 break;

  136.             case 'p':

  137.             case 'P':

  138.                 if(items) current = (items + current - 1) % items;

  139.                 reload = 1;

  140.                 break;

  141.             case 'f':

  142.             case 'F':

  143.                 fullscreen = ~fullscreen;

  144.                 update = 1;

  145.                 break;

  146.             case 'b':

  147.                 i = 1 + caca_get_feature(CACA_BACKGROUND);

  148.                 if(i > CACA_BACKGROUND_MAX) i = CACA_BACKGROUND_MIN;

  149.                 caca_set_feature(i);

  150.                 new_status = STATUS_BACKGROUND;

  151.                 update = 1;

  152.                 break;

  153.             case 'B':

  154.                 i = -1 + caca_get_feature(CACA_BACKGROUND);

  155.                 if(i < CACA_BACKGROUND_MIN) i = CACA_BACKGROUND_MAX;

  156.                 caca_set_feature(i);

  157.                 new_status = STATUS_BACKGROUND;

  158.                 update = 1;

  159.                 break;

  160.             case 'a':

  161.                 i = 1 + caca_get_feature(CACA_ANTIALIASING);

  162.                 if(i > CACA_ANTIALIASING_MAX) i = CACA_ANTIALIASING_MIN;

  163.                 caca_set_feature(i);

  164.                 new_status = STATUS_ANTIALIASING;

  165.                 update = 1;

  166.                 break;

  167.             case 'A':

  168.                 i = -1 + caca_get_feature(CACA_ANTIALIASING);

  169.                 if(i < CACA_ANTIALIASING_MIN) i = CACA_ANTIALIASING_MAX;

  170.                 caca_set_feature(i);

  171.                 new_status = STATUS_ANTIALIASING;

  172.                 update = 1;

  173.                 break;

  174.             case 'd':

  175.                 i = 1 + caca_get_feature(CACA_DITHERING);

  176.                 if(i > CACA_DITHERING_MAX) i = CACA_DITHERING_MIN;

  177.                 caca_set_feature(i);

  178.                 new_status = STATUS_DITHERING;

  179.                 update = 1;

  180.                 break;

  181.             case 'D':

  182.                 i = -1 + caca_get_feature(CACA_DITHERING);

  183.                 if(i < CACA_DITHERING_MIN) i = CACA_DITHERING_MAX;

  184.                 caca_set_feature(i);

  185.                 new_status = STATUS_DITHERING;

  186.                 update = 1;

  187.                 break;

  188.             case '+':

  189.                 zoom++;

  190.                 if(zoom > 48) zoom = 48; else update = 1;

  191.                 break;

  192.             case '-':

  193.                 zoom--;

  194.                 if(zoom < -48) zoom = -48; else update = 1;

  195.                 break;

  196.             case 'x':

  197.             case 'X':

  198.                 zoom = 0;

  199.                 update = 1;

  200.                 break;

  201.             case 'k':

  202.             case 'K':

  203.             case CACA_KEY_UP:

  204.                 if(zoom > 0) y -= 1 + h / (2 + zoom) / 8;

  205.                 update = 1;

  206.                 break;

  207.             case 'j':

  208.             case 'J':

  209.             case CACA_KEY_DOWN:

  210.                 if(zoom > 0) y += 1 + h / (2 + zoom) / 8;

  211.                 update = 1;

  212.                 break;

  213.             case 'h':

  214.             case 'H':

  215.             case CACA_KEY_LEFT:

  216.                 if(zoom > 0) x -= 1 + w / (2 + zoom) / 8;

  217.                 update = 1;

  218.                 break;

  219.             case 'l':

  220.             case 'L':

  221.             case CACA_KEY_RIGHT:

  222.                 if(zoom > 0) x += 1 + w / (2 + zoom) / 8;

  223.                 update = 1;

  224.                 break;

  225.             case '?':

  226.                 new_help = !help;

  227.                 update = 1;

  228.                 break;

  229.             case 'q':

  230.             case 'Q':

  231.                 quit = 1;

  232.                 break;

  233.             }

  234. 

  235.             if(event == CACA_EVENT_RESIZE)

  236.             {

  237.                 caca_refresh();

  238.                 ww = caca_get_width();

  239.                 wh = caca_get_height();

  240.                 update = 1;

  241.             }

  242. 

  243.             if(status || new_status)

  244.                 status = new_status;

  245. 

  246.             if(help || new_help)

  247.                 help = new_help;

  248. 

  249.             event = caca_get_event(CACA_EVENT_KEY_PRESS);

  250.         }

  251. 

  252.         if(items && reload)

  253.         {

  254.             char *buffer;

  255.             int len = strlen(" Loading `%s'... ") + strlen(list[current]);

  256. 

  257.             if(len < ww + 1)

  258.                 len = ww + 1;

  259. 

  260.             buffer = malloc(len);

  261. 

  262.             /* Reset image-specific runtime variables */

  263.             zoom = 0;

  264. 

  265.             sprintf(buffer, " Loading `%s'... ", list[current]);

  266.             buffer[ww] = '\0';

  267.             caca_set_color(CACA_COLOR_WHITE, CACA_COLOR_BLUE);

  268.             caca_putstr((ww - strlen(buffer)) / 2, wh / 2, buffer);

  269.             caca_refresh();

  270.             ww = caca_get_width();

  271.             wh = caca_get_height();

  272. 

  273.             unload_image();

  274.             load_image(list[current]);

  275.             reload = 0;

  276.             update = 1;

  277. 

  278.             free(buffer);

  279.         }

  280. 

  281.         caca_clear();

  282. 

  283.         if(!items)

  284.         {

  285.             caca_set_color(CACA_COLOR_WHITE, CACA_COLOR_BLUE);

  286.             caca_printf(ww / 2 - 5, wh / 2, " No image. ");

  287.         }

  288.         else if(!pixels)

  289.         {

  290. #if defined(HAVE_IMLIB2_H)

  291. #   define ERROR_STRING " Error loading `%s'. "

  292. #else

  293. #   define ERROR_STRING " Error loading `%s'. Only BMP is supported. "

  294. #endif

  295.             char *buffer;

  296.             int len = strlen(ERROR_STRING) + strlen(list[current]);

  297. 

  298.             if(len < ww + 1)

  299.                 len = ww + 1;

  300. 

  301.             buffer = malloc(len);

  302. 

  303.             sprintf(buffer, ERROR_STRING, list[current]);

  304.             buffer[ww] = '\0';

  305.             caca_set_color(CACA_COLOR_WHITE, CACA_COLOR_BLUE);

  306.             caca_putstr((ww - strlen(buffer)) / 2, wh / 2, buffer);

  307.             free(buffer);

  308.         }

  309.         else if(zoom < 0)

  310.         {

  311.             int xo = (ww - 1) / 2;

  312.             int yo = (wh - 1) / 2;

  313.             int xn = (ww - 1) / (2 - zoom);

  314.             int yn = (wh - 1) / (2 - zoom);

  315.             draw_checkers(xo - xn, yo - yn, xo + xn, yo + yn);

  316.             caca_draw_bitmap(xo - xn, yo - yn, xo + xn, yo + yn,

  317.                              bitmap, pixels);

  318.         }

  319.         else if(zoom > 0)

  320.         {

  321.             struct caca_bitmap *newbitmap;

  322.             int xn = w / (2 + zoom);

  323.             int yn = h / (2 + zoom);

  324.             if(x < xn) x = xn;

  325.             if(y < yn) y = yn;

  326.             if(xn + x > (int)w) x = w - xn;

  327.             if(yn + y > (int)h) y = h - yn;

  328.             newbitmap = caca_create_bitmap(bpp, 2 * xn, 2 * yn, depth * w,

  329.                                            rmask, gmask, bmask, amask);

  330. #if !defined(HAVE_IMLIB2_H)

  331.             if(bpp == 8)

  332.                 caca_set_bitmap_palette(newbitmap, red, green, blue, alpha);

  333. #endif

  334.             draw_checkers(0, fullscreen ? 0 : 1,

  335.                           ww - 1, fullscreen ? wh - 1 : wh - 3);

  336.             caca_draw_bitmap(0, fullscreen ? 0 : 1,

  337.                              ww - 1, fullscreen ? wh - 1 : wh - 3,

  338.                              newbitmap,

  339.                              pixels + depth * (x - xn) + depth * w * (y - yn));

  340.             caca_free_bitmap(newbitmap);

  341.         }

  342.         else

  343.         {

  344.             draw_checkers(0, fullscreen ? 0 : 1,

  345.                           ww - 1, fullscreen ? wh - 1 : wh - 3);

  346.             caca_draw_bitmap(0, fullscreen ? 0 : 1,

  347.                              ww - 1, fullscreen ? wh - 1 : wh - 3,

  348.                              bitmap, pixels);

  349.         }

  350. 

  351.         if(!fullscreen)

  352.         {

  353.             caca_set_color(CACA_COLOR_WHITE, CACA_COLOR_BLUE);

  354.             caca_draw_line(0, 0, ww - 1, 0, ' ');

  355.             caca_draw_line(0, wh - 2, ww - 1, wh - 2, '-');

  356.             caca_putstr(0, 0, "q:Quit  np:Next/Prev  +-x:Zoom  "

  357.                               "hjkl:Move  d:Dithering  a:Antialias");

  358.             caca_putstr(ww - strlen("?:Help"), 0, "?:Help");

  359.             caca_printf(3, wh - 2, "cacaview %s", VERSION);

  360.             caca_printf(ww - 14, wh - 2,

  361.                         "(zoom: %s%i)", zoom > 0 ? "+" : "", zoom);

  362. 

  363.             caca_set_color(CACA_COLOR_LIGHTGRAY, CACA_COLOR_BLACK);

  364.             caca_draw_line(0, wh - 1, ww - 1, wh - 1, ' ');

  365.             switch(status)

  366.             {

  367.                 case STATUS_ANTIALIASING:

  368.                     caca_printf(0, wh - 1, "Antialiasing: %s",

  369.                   caca_get_feature_name(caca_get_feature(CACA_ANTIALIASING)));

  370.                     break;

  371.                 case STATUS_DITHERING:

  372.                     caca_printf(0, wh - 1, "Dithering: %s",

  373.                   caca_get_feature_name(caca_get_feature(CACA_DITHERING)));

  374.                     break;

  375.                 case STATUS_BACKGROUND:

  376.                     caca_printf(0, wh - 1, "Background: %s",

  377.                   caca_get_feature_name(caca_get_feature(CACA_BACKGROUND)));

  378.                     break;

  379.             }

  380.         }

  381. 

  382.         if(help)

  383.         {

  384.             caca_set_color(CACA_COLOR_WHITE, CACA_COLOR_BLUE);

  385.             caca_putstr(ww - 25, 2,  " +: zoom in             ");

  386.             caca_putstr(ww - 25, 3,  " -: zoom out            ");

  387.             caca_putstr(ww - 25, 4,  " x: reset zoom          ");

  388.             caca_putstr(ww - 25, 5,  " ---------------------- ");

  389.             caca_putstr(ww - 25, 6,  " hjkl: move view        ");

  390.             caca_putstr(ww - 25, 7,  " arrows: move view      ");

  391.             caca_putstr(ww - 25, 8,  " ---------------------- ");

  392.             caca_putstr(ww - 25, 9,  " a: antialiasing method ");

  393.             caca_putstr(ww - 25, 10, " d: dithering method    ");

  394.             caca_putstr(ww - 25, 11, " b: background mode     ");

  395.             caca_putstr(ww - 25, 12, " ---------------------- ");

  396.             caca_putstr(ww - 25, 13, " ?: help                ");

  397.             caca_putstr(ww - 25, 14, " q: quit                ");

  398.         }

  399. 

  400.         caca_refresh();

  401.         update = 0;

  402.     }

  403. 

  404.     /* Clean up */

  405.     unload_image();

  406.     caca_end();

  407. 

  408.     return 0;

  409. }

  410. 

  411. static void unload_image(void)

  412. {

  413. #if defined(HAVE_IMLIB2_H)

  414.     if(image)

  415.         imlib_free_image();

  416.     image = NULL;

  417.     pixels = NULL;

  418. #else

  419.     if(pixels)

  420.         free(pixels);

  421.     pixels = NULL;

  422. #endif

  423.     if(bitmap)

  424.         caca_free_bitmap(bitmap);

  425.     bitmap = NULL;

  426. }

  427. 

  428. static void load_image(char const *name)

  429. {

  430. #if defined(HAVE_IMLIB2_H)

  431.     /* Load the new image */

  432.     image = imlib_load_image(name);

  433. 

  434.     if(!image)

  435.         return;

  436. 

  437.     imlib_context_set_image(image);

  438.     pixels = (char *)imlib_image_get_data_for_reading_only();

  439.     w = imlib_image_get_width();

  440.     h = imlib_image_get_height();

  441.     rmask = 0x00ff0000;

  442.     gmask = 0x0000ff00;

  443.     bmask = 0x000000ff;

  444.     amask = 0xff000000;

  445.     bpp = 32;

  446.     depth = 4;

  447. 

  448.     /* Create the libcaca bitmap */

  449.     bitmap = caca_create_bitmap(bpp, w, h, depth * w,

  450.                                 rmask, gmask, bmask, amask);

  451.     if(!bitmap)

  452.     {

  453.         imlib_free_image();

  454.         image = NULL;

  455.     }

  456. 

  457. #else

  458.     /* Try to load a BMP file */

  459.     FILE *fp;

  460.     unsigned int i, colors, offset, tmp, planes;

  461. 

  462.     fp = fopen(name, "rb");

  463.     if(!fp)

  464.         return;

  465. 

  466.     if(freadshort(fp) != 0x4d42)

  467.     {

  468.         fclose(fp);

  469.         return;

  470.     }

  471. 

  472.     freadint(fp); /* size */

  473.     freadshort(fp); /* reserved 1 */

  474.     freadshort(fp); /* reserved 2 */

  475. 

  476.     offset = freadint(fp);

  477. 

  478.     tmp = freadint(fp); /* header size */

  479.     if(tmp == 40)

  480.     {

  481.         w = freadint(fp);

  482.         h = freadint(fp);

  483.         planes = freadshort(fp);

  484.         bpp = freadshort(fp);

  485. 

  486.         tmp = freadint(fp); /* compression */

  487.         if(tmp != 0)

  488.         {

  489.             fclose(fp);

  490.             return;

  491.         }

  492. 

  493.         freadint(fp); /* sizeimage */

  494.         freadint(fp); /* xpelspermeter */

  495.         freadint(fp); /* ypelspermeter */

  496.         freadint(fp); /* biclrused */

  497.         freadint(fp); /* biclrimportantn */

  498. 

  499.         colors = (offset - 54) / 4;

  500.         for(i = 0; i < colors && i < 256; i++)

  501.         {

  502.             blue[i] = freadchar(fp) * 16;

  503.             green[i] = freadchar(fp) * 16;

  504.             red[i] = freadchar(fp) * 16;

  505.             alpha[i] = 0;

  506.             freadchar(fp);

  507.         }

  508.     }

  509.     else if(tmp == 12)

  510.     {

  511.         w = freadint(fp);

  512.         h = freadint(fp);

  513.         planes = freadshort(fp);

  514.         bpp = freadshort(fp);

  515. 

  516.         colors = (offset - 26) / 3;

  517.         for(i = 0; i < colors && i < 256; i++)

  518.         {

  519.             blue[i] = freadchar(fp);

  520.             green[i] = freadchar(fp);

  521.             red[i] = freadchar(fp);

  522.             alpha[i] = 0;

  523.         }

  524.     }

  525.     else

  526.     {

  527.         fclose(fp);

  528.         return;

  529.     }

  530. 

  531.     /* Fill the rest of the palette */

  532.     for(i = colors; i < 256; i++)

  533.         blue[i] = green[i] = red[i] = alpha[i] = 0;

  534. 

  535.     depth = (bpp + 7) / 8;

  536. 

  537.     /* Sanity check */

  538.     if(!w || w > 0x10000 || !h || h > 0x10000 || planes != 1 /*|| bpp != 24*/)

  539.     {

  540.         fclose(fp);

  541.         return;

  542.     }

  543. 

  544.     /* Allocate the pixel buffer */

  545.     pixels = malloc(w * h * depth);

  546.     if(!pixels)

  547.     {

  548.         fclose(fp);

  549.         return;

  550.     }

  551. 

  552.     memset(pixels, 0, w * h * depth);

  553. 

  554.     /* Read the bitmap data */

  555.     for(i = h; i--; )

  556.     {

  557.         unsigned int j, k, bits = 0;

  558. 

  559.         switch(bpp)

  560.         {

  561.             case 1:

  562.                 for(j = 0; j < w; j++)

  563.                 {

  564.                     k = j % 32;

  565.                     if(k == 0)

  566.                         bits = freadint(fp);

  567.                     pixels[w * i * depth + j] =

  568.                         (bits >> ((k & ~0xf) + 0xf - (k & 0xf))) & 0x1;

  569.                 }

  570.                 break;

  571.             case 4:

  572.                 for(j = 0; j < w; j++)

  573.                 {

  574.                     k = j % 8;

  575.                     if(k == 0)

  576.                         bits = freadint(fp);

  577.                     pixels[w * i * depth + j] =

  578.                         (bits >> (4 * ((k & ~0x1) + 0x1 - (k & 0x1)))) & 0xf;

  579.                 }

  580.                 break;

  581.             default:

  582.                 /* Works for 8bpp, but also for 16, 24 etc. */

  583.                 fread(pixels + w * i * depth, w * depth, 1, fp);

  584.                 /* Pad reads to 4 bytes */

  585.                 tmp = (w * depth) % 4;

  586.                 tmp = (4 - tmp) % 4;

  587.                 while(tmp--)

  588.                     freadchar(fp);

  589.                 break;

  590.         }

  591.     }

  592. 

  593.     switch(depth)

  594.     {

  595.     case 3:

  596.         rmask = 0xff0000;

  597.         gmask = 0x00ff00;

  598.         bmask = 0x0000ff;

  599.         amask = 0x000000;

  600.         break;

  601.     case 2: /* XXX: those are the 16 bits values */

  602.         rmask = 0x7c00;

  603.         gmask = 0x03e0;

  604.         bmask = 0x001f;

  605.         amask = 0x0000;

  606.         break;

  607.     case 1:

  608.     default:

  609.         bpp = 8;

  610.         rmask = gmask = bmask = amask = 0;

  611.         break;

  612.     }

  613. 

  614.     fclose(fp);

  615. 

  616.     /* Create the libcaca bitmap */

  617.     bitmap = caca_create_bitmap(bpp, w, h, depth * w,

  618.                                 rmask, gmask, bmask, amask);

  619.     if(!bitmap)

  620.     {

  621.         free(pixels);

  622.         pixels = NULL;

  623.         return;

  624.     }

  625. 

  626.     if(bpp == 8)

  627.         caca_set_bitmap_palette(bitmap, red, green, blue, alpha);

  628. #endif

  629. 

  630.     x = w / 2;

  631.     y = h / 2;

  632. }

  633. 

  634. static void draw_checkers(unsigned int x1, unsigned int y1,

  635.                           unsigned int x2, unsigned int y2)

  636. {

  637.     unsigned int xn, yn;

  638. 

  639.     for(yn = y1; yn <= y2; yn++)

  640.         for(xn = x1; xn <= x2; xn++)

  641.     {

  642.         if((((xn - x1) / 5) ^ ((yn - y1) / 3)) & 1)

  643.             caca_set_color(CACA_COLOR_LIGHTGRAY, CACA_COLOR_DARKGRAY);

  644.         else

  645.             caca_set_color(CACA_COLOR_DARKGRAY, CACA_COLOR_LIGHTGRAY);

  646.         caca_putchar(xn, yn, ' ');

  647.     }

  648. }

  649. 

  650. #if !defined(HAVE_IMLIB2_H)

  651. static int freadint(FILE *fp)

  652. {

  653.     unsigned char buffer[4];

  654.     fread(buffer, 4, 1, fp);

  655.     return ((int)buffer[3] << 24) | ((int)buffer[2] << 16)

  656.              | ((int)buffer[1] << 8) | ((int)buffer[0]);

  657. }

  658. 

  659. static int freadshort(FILE *fp)

  660. {

  661.     unsigned char buffer[2];

  662.     fread(buffer, 2, 1, fp);

  663.     return ((int)buffer[1] << 8) | ((int)buffer[0]);

  664. }

  665. 

  666. static int freadchar(FILE *fp)

  667. {

  668.     unsigned char buffer;

  669.     fread(&buffer, 1, 1, fp);

  670.     return (int)buffer;

  671. }

  672. #endif