cacalabs
/
libcaca
spogulis no https://github.com/cacalabs/libcaca.git
1
0
Atdalīts 0
Kods Problēmas 0 Laidieni 7 Vikivietne Aktivitāte
Nevar pievienot vairāk kā 25 tēmas Tēmai ir jāsākas ar burtu vai ciparu, tā var saturēt domu zīmes ('-') un var būt līdz 35 simboliem gara.
235 Revīzijas
1 Atzars
37 MiB
 
 
 
 
 
 
Koks: 337e22d1b7
Atzari Tagi
${ item.name }
Izveidot atzaru ${ searchTerm }
no '337e22d1b7'
${ noResults }
libcaca/examples/cacaview.c

661 rinda
18 KiB
Neapstrādāts Vainot Vēsture 

  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. #include <unistd.h>

  30. 

  31. #if defined(HAVE_IMLIB2_H)

  32. #   include <Imlib2.h>

  33. #else

  34. #   include <stdio.h>

  35. #endif

  36. 

  37. #if defined(HAVE_SLEEP)

  38. #   include <windows.h>

  39. #endif

  40. 

  41. #include "caca.h"

  42. 

  43. /* Local macros */

  44. #define STATUS_DITHERING 1

  45. #define STATUS_ANTIALIASING 2

  46. #define STATUS_BACKGROUND 3

  47. 

  48. /* Local functions */

  49. static void load_image(char const *);

  50. static void unload_image(void);

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

  52.                           unsigned int, unsigned int);

  53. #if !defined(HAVE_IMLIB2_H)

  54. static int freadint(FILE *);

  55. static int freadshort(FILE *);

  56. static int freadchar(FILE *);

  57. #endif

  58. 

  59. /* Local variables */

  60. #if defined(HAVE_IMLIB2_H)

  61. Imlib_Image image = NULL;

  62. #endif

  63. char *pixels = NULL;

  64. struct caca_bitmap *bitmap = NULL;

  65. int x, y;

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

  67. #if !defined(HAVE_IMLIB2_H)

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

  69. #endif

  70. 

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

  72. {

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

  74.     int reload = 0, zoom = 0;

  75. 

  76.     char **list = NULL;

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

  78.     int i;

  79. 

  80.     /* Initialise libcaca */

  81.     if(caca_init())

  82.     {

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

  84.         return 1;

  85.     }

  86. 

  87.     /* Load items into playlist */

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

  89.     {

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

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

  92.         {

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

  94.                 opts = 0;

  95.             continue;

  96.         }

  97. 

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

  99.         if(items)

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

  101.         else

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

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

  104.         items++;

  105. 

  106.         reload = 1;

  107.     }

  108. 

  109.     /* Go ! */

  110.     while(!quit)

  111.     {

  112.         int ww = caca_get_width();

  113.         int wh = caca_get_height();

  114. 

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

  116. 

  117.         if(update)

  118.             event = caca_get_event(CACA_EVENT_KEY_PRESS);

  119.         else

  120.             event = caca_wait_event(CACA_EVENT_KEY_PRESS);

  121. 

  122.         while(event)

  123.         {

  124.             unsigned int key = event & 0x00ffffff;

  125. 

  126.             switch(key)

  127.             {

  128.             case 'n':

  129.             case 'N':

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

  131.                 reload = 1;

  132.                 break;

  133.             case 'p':

  134.             case 'P':

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

  136.                 reload = 1;

  137.                 break;

  138.             case 'f':

  139.             case 'F':

  140.                 fullscreen = ~fullscreen;

  141.                 update = 1;

  142.                 break;

  143.             case 'b':

  144.                 i = 1 + caca_get_feature(CACA_BACKGROUND);

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

  146.                 caca_set_feature(i);

  147.                 new_status = STATUS_BACKGROUND;

  148.                 update = 1;

  149.                 break;

  150.             case 'B':

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

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

  153.                 caca_set_feature(i);

  154.                 new_status = STATUS_BACKGROUND;

  155.                 update = 1;

  156.                 break;

  157.             case 'a':

  158.                 i = 1 + caca_get_feature(CACA_ANTIALIASING);

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

  160.                 caca_set_feature(i);

  161.                 new_status = STATUS_ANTIALIASING;

  162.                 update = 1;

  163.                 break;

  164.             case 'A':

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

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

  167.                 caca_set_feature(i);

  168.                 new_status = STATUS_ANTIALIASING;

  169.                 update = 1;

  170.                 break;

  171.             case 'd':

  172.                 i = 1 + caca_get_feature(CACA_DITHERING);

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

  174.                 caca_set_feature(i);

  175.                 new_status = STATUS_DITHERING;

  176.                 update = 1;

  177.                 break;

  178.             case 'D':

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

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

  181.                 caca_set_feature(i);

  182.                 new_status = STATUS_DITHERING;

  183.                 update = 1;

  184.                 break;

  185.             case '+':

  186.                 zoom++;

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

  188.                 break;

  189.             case '-':

  190.                 zoom--;

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

  192.                 break;

  193.             case 'x':

  194.             case 'X':

  195.                 zoom = 0;

  196.                 update = 1;

  197.                 break;

  198.             case 'k':

  199.             case 'K':

  200.             case CACA_KEY_UP:

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

  202.                 update = 1;

  203.                 break;

  204.             case 'j':

  205.             case 'J':

  206.             case CACA_KEY_DOWN:

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

  208.                 update = 1;

  209.                 break;

  210.             case 'h':

  211.             case 'H':

  212.             case CACA_KEY_LEFT:

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

  214.                 update = 1;

  215.                 break;

  216.             case 'l':

  217.             case 'L':

  218.             case CACA_KEY_RIGHT:

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

  220.                 update = 1;

  221.                 break;

  222.             case '?':

  223.                 new_help = !help;

  224.                 update = 1;

  225.                 break;

  226.             case 'q':

  227.             case 'Q':

  228.                 quit = 1;

  229.                 break;

  230.             }

  231. 

  232.             if(status || new_status)

  233.                 status = new_status;

  234. 

  235.             if(help || new_help)

  236.                 help = new_help;

  237. 

  238.             event = caca_get_event(CACA_EVENT_KEY_PRESS);

  239.         }

  240. 

  241.         if(items && reload)

  242.         {

  243.             char *buffer;

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

  245. 

  246.             if(len < ww + 1)

  247.                 len = ww + 1;

  248. 

  249.             buffer = malloc(len);

  250. 

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

  252.             zoom = 0;

  253. 

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

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

  256.             caca_set_color(CACA_COLOR_WHITE, CACA_COLOR_BLUE);

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

  258.             caca_refresh();

  259. 

  260.             unload_image();

  261.             load_image(list[current]);

  262.             reload = 0;

  263.             update = 1;

  264. 

  265.             free(buffer);

  266.         }

  267. 

  268.         caca_clear();

  269. 

  270.         if(!items)

  271.         {

  272.             caca_set_color(CACA_COLOR_WHITE, CACA_COLOR_BLUE);

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

  274.         }

  275.         else if(!pixels)

  276.         {

  277. #if defined(HAVE_IMLIB2_H)

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

  279. #else

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

  281. #endif

  282.             char *buffer;

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

  284. 

  285.             if(len < ww + 1)

  286.                 len = ww + 1;

  287. 

  288.             buffer = malloc(len);

  289. 

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

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

  292.             caca_set_color(CACA_COLOR_WHITE, CACA_COLOR_BLUE);

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

  294.             free(buffer);

  295.         }

  296.         else if(zoom < 0)

  297.         {

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

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

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

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

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

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

  304.                              bitmap, pixels);

  305.         }

  306.         else if(zoom > 0)

  307.         {

  308.             struct caca_bitmap *newbitmap;

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

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

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

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

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

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

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

  316.                                            rmask, gmask, bmask, amask);

  317. #if !defined(HAVE_IMLIB2_H)

  318.             if(bpp == 8)

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

  320. #endif

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

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

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

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

  325.                              newbitmap,

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

  327.             caca_free_bitmap(newbitmap);

  328.         }

  329.         else

  330.         {

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

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

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

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

  335.                              bitmap, pixels);

  336.         }

  337. 

  338.         if(!fullscreen)

  339.         {

  340.             caca_set_color(CACA_COLOR_WHITE, CACA_COLOR_BLUE);

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

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

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

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

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

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

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

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

  349. 

  350.             caca_set_color(CACA_COLOR_LIGHTGRAY, CACA_COLOR_BLACK);

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

  352.             switch(status)

  353.             {

  354.                 case STATUS_ANTIALIASING:

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

  356.                   caca_get_feature_name(caca_get_feature(CACA_ANTIALIASING)));

  357.                     break;

  358.                 case STATUS_DITHERING:

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

  360.                   caca_get_feature_name(caca_get_feature(CACA_DITHERING)));

  361.                     break;

  362.                 case STATUS_BACKGROUND:

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

  364.                   caca_get_feature_name(caca_get_feature(CACA_BACKGROUND)));

  365.                     break;

  366.             }

  367.         }

  368. 

  369.         if(help)

  370.         {

  371.             caca_set_color(CACA_COLOR_WHITE, CACA_COLOR_BLUE);

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

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

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

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

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

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

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

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

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

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

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

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

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

  385.         }

  386. 

  387.         caca_refresh();

  388.         update = 0;

  389.     }

  390. 

  391.     /* Clean up */

  392.     unload_image();

  393.     caca_end();

  394. 

  395.     return 0;

  396. }

  397. 

  398. static void unload_image(void)

  399. {

  400. #if defined(HAVE_IMLIB2_H)

  401.     if(image)

  402.         imlib_free_image();

  403.     image = NULL;

  404.     pixels = NULL;

  405. #else

  406.     if(pixels)

  407.         free(pixels);

  408.     pixels = NULL;

  409. #endif

  410.     if(bitmap)

  411.         caca_free_bitmap(bitmap);

  412.     bitmap = NULL;

  413. }

  414. 

  415. static void load_image(char const *name)

  416. {

  417. #if defined(HAVE_IMLIB2_H)

  418.     /* Load the new image */

  419.     image = imlib_load_image(name);

  420. 

  421.     if(!image)

  422.         return;

  423. 

  424.     imlib_context_set_image(image);

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

  426.     w = imlib_image_get_width();

  427.     h = imlib_image_get_height();

  428.     rmask = 0x00ff0000;

  429.     gmask = 0x0000ff00;

  430.     bmask = 0x000000ff;

  431.     amask = 0xff000000;

  432.     bpp = 32;

  433.     depth = 4;

  434. 

  435.     /* Create the libcaca bitmap */

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

  437.                                 rmask, gmask, bmask, amask);

  438.     if(!bitmap)

  439.     {

  440.         imlib_free_image();

  441.         image = NULL;

  442.     }

  443. 

  444. #else

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

  446.     FILE *fp;

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

  448. 

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

  450.     if(!fp)

  451.         return;

  452. 

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

  454.     {

  455.         fclose(fp);

  456.         return;

  457.     }

  458. 

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

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

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

  462. 

  463.     offset = freadint(fp);

  464. 

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

  466.     if(tmp == 40)

  467.     {

  468.         w = freadint(fp);

  469.         h = freadint(fp);

  470.         planes = freadshort(fp);

  471.         bpp = freadshort(fp);

  472. 

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

  474.         if(tmp != 0)

  475.         {

  476.             fclose(fp);

  477.             return;

  478.         }

  479. 

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

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

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

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

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

  485. 

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

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

  488.         {

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

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

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

  492.             alpha[i] = 0;

  493.             freadchar(fp);

  494.         }

  495.     }

  496.     else if(tmp == 12)

  497.     {

  498.         w = freadint(fp);

  499.         h = freadint(fp);

  500.         planes = freadshort(fp);

  501.         bpp = freadshort(fp);

  502. 

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

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

  505.         {

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

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

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

  509.             alpha[i] = 0;

  510.         }

  511.     }

  512.     else

  513.     {

  514.         fclose(fp);

  515.         return;

  516.     }

  517. 

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

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

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

  521. 

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

  523. 

  524.     /* Sanity check */

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

  526.     {

  527.         fclose(fp);

  528.         return;

  529.     }

  530. 

  531.     /* Allocate the pixel buffer */

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

  533.     if(!pixels)

  534.     {

  535.         fclose(fp);

  536.         return;

  537.     }

  538. 

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

  540. 

  541.     /* Read the bitmap data */

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

  543.     {

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

  545. 

  546.         switch(bpp)

  547.         {

  548.             case 1:

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

  550.                 {

  551.                     k = j % 32;

  552.                     if(k == 0)

  553.                         bits = freadint(fp);

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

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

  556.                 }

  557.                 break;

  558.             case 4:

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

  560.                 {

  561.                     k = j % 8;

  562.                     if(k == 0)

  563.                         bits = freadint(fp);

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

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

  566.                 }

  567.                 break;

  568.             default:

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

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

  571.                 /* Pad reads to 4 bytes */

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

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

  574.                 while(tmp--)

  575.                     freadchar(fp);

  576.                 break;

  577.         }

  578.     }

  579. 

  580.     switch(depth)

  581.     {

  582.     case 3:

  583.         rmask = 0xff0000;

  584.         gmask = 0x00ff00;

  585.         bmask = 0x0000ff;

  586.         amask = 0x000000;

  587.         break;

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

  589.         rmask = 0x7c00;

  590.         gmask = 0x03e0;

  591.         bmask = 0x001f;

  592.         amask = 0x0000;

  593.         break;

  594.     case 1:

  595.     default:

  596.         bpp = 8;

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

  598.         break;

  599.     }

  600. 

  601.     fclose(fp);

  602. 

  603.     /* Create the libcaca bitmap */

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

  605.                                 rmask, gmask, bmask, amask);

  606.     if(!bitmap)

  607.     {

  608.         free(pixels);

  609.         pixels = NULL;

  610.         return;

  611.     }

  612. 

  613.     if(bpp == 8)

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

  615. #endif

  616. 

  617.     x = w / 2;

  618.     y = h / 2;

  619. }

  620. 

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

  622.                           unsigned int x2, unsigned int y2)

  623. {

  624.     unsigned int xn, yn;

  625. 

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

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

  628.     {

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

  630.             caca_set_color(CACA_COLOR_LIGHTGRAY, CACA_COLOR_DARKGRAY);

  631.         else

  632.             caca_set_color(CACA_COLOR_DARKGRAY, CACA_COLOR_LIGHTGRAY);

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

  634.     }

  635. }

  636. 

  637. #if !defined(HAVE_IMLIB2_H)

  638. static int freadint(FILE *fp)

  639. {

  640.     unsigned char buffer[4];

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

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

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

  644. }

  645. 

  646. static int freadshort(FILE *fp)

  647. {

  648.     unsigned char buffer[2];

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

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

  651. }

  652. 

  653. static int freadchar(FILE *fp)

  654. {

  655.     unsigned char buffer;

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

  657.     return (int)buffer;

  658. }

  659. #endif