aboutsummaryrefslogtreecommitdiff
path: root/vendor/x11iraf/cdl/cdliraf.c
diff options
context:
space:
mode:
Diffstat (limited to 'vendor/x11iraf/cdl/cdliraf.c')
-rw-r--r--vendor/x11iraf/cdl/cdliraf.c848
1 files changed, 848 insertions, 0 deletions
diff --git a/vendor/x11iraf/cdl/cdliraf.c b/vendor/x11iraf/cdl/cdliraf.c
new file mode 100644
index 00000000..87c28e57
--- /dev/null
+++ b/vendor/x11iraf/cdl/cdliraf.c
@@ -0,0 +1,848 @@
+#include <stdio.h>
+#ifdef linux
+/*#include <gnu/types.h>*/
+#include <sys/types.h>
+#endif
+#ifdef ULTRIX
+#include <sys/types.h>
+#endif
+#include <unistd.h>
+#define CDL_LIBRARY_SOURCE
+#include "cdl.h"
+
+
+/*
+ * CDLIRAF.C -- Routines to read IRAF OIF images.
+ *
+ * cdl_displayIRAF (cdl, fname, band, frame, fbconfig, zscale)
+ * cdl_isIRAF (fname)
+ * cdl_readIRAF (fname, band, &pix, &nx, &ny, &bitpix, title);
+ */
+
+
+#define VERSION_1 1
+#define VERSION_2 2
+
+/* Image header parmeters. */
+#define SZ_V1PIXFILE 79
+#define SZ_V1TITLE 79
+#define SZ_V1HDR 2048
+
+/* Offsets into header (in sizeof(int) units) for various parameters */
+#define IM_V1PIXTYPE 4 /* datatype of the pixels */
+#define IM_V1NDIM 5 /* number of dimensions */
+#define IM_V1LEN 6 /* image dimensions */
+#define IM_V1PHYSLEN 13 /* physical length (as stored) */
+#define IM_V1PIXOFF 22 /* offset of the pixels */
+#define IM_V1PIXFILE 103 /* name of pixel storage file */
+#define IM_V1TITLE 183 /* title of image */
+
+/* Image header parmeters. */
+#define SZ_V2PIXFILE 255
+#define SZ_V2TITLE 383
+#define SZ_V2HDR 1024
+
+/* Offsets into header (in sizeof(int) units) for various parameters */
+#define IM_V2PIXTYPE 10 /* datatype of the pixels */
+#define IM_V2SWAPPED 14 /* number of dimensions */
+#define IM_V2NDIM 18 /* number of dimensions */
+#define IM_V2LEN 22 /* image dimensions */
+#define IM_V2PHYSLEN 50 /* physical length (as stored) */
+#define IM_V2PIXOFF 86 /* offset of the pixels */
+#define IM_V2PIXFILE 126 /* name of pixel storage file */
+#define IM_V2TITLE 638 /* title of image */
+
+/* IRAF dataype codes */
+#define TY_CHAR 2
+#define TY_SHORT 3
+#define TY_INT 4
+#define TY_LONG 5
+#define TY_REAL 6
+#define TY_DOUBLE 7
+#define TY_USHORT 11
+#define TY_UCHAR 12
+
+#ifdef __STDC__
+#include <stddef.h>
+#include <stdlib.h>
+#endif
+
+#undef max
+#define max(a,b) ((a) > (b) ? (a) : (b))
+#undef min
+#define min(a,b) ((a) < (b) ? (a) : (b))
+
+extern int cdl_debug;
+
+
+#ifdef ANSI_FUNC
+
+static char *cdl_getIRAFPixels(char *fname, int band, uchar **image, int *nx, int *ny, int *bitpix, char *title);
+static int cdl_readImageHdr(char *fname, int *version, int *px, int *py, int *nx, int *ny, int *nbands, int *ptype, int *offset, int *swapped, char *pfile, char *title);
+static int cdl_getVersion(FILE *fd);
+static void cdl_getPixfile(char *fname, char *pfile);
+static int cdl_setBitpix(int ptype, int *pix_size, int *bitpix);
+static void cdl_swapPixels(int swapped, int nx, int ny, int ptype, uchar **image);
+static void cdl_strpak(char *in, char *out, int len);
+static void bswap2(char *a, char *b, int nbytes);
+static void bswap4(char *a, int aoff, char *b, int boff, int nbytes);
+static void bswap8(char *a, int aoff, char *b, int boff, int nbytes);
+static int is_swapped_machine(void);
+
+#else
+
+static char *cdl_getIRAFPixels();
+static void cdl_getPixfile(), cdl_strpak();
+static void bswap2(), bswap4(), bswap8();
+static void cdl_swapPixels ();
+static int cdl_readImageHdr(), cdl_setBitpix();
+static int cdl_getVersion();
+static int is_swapped_machine();
+
+#endif
+
+
+
+/* CDL_DISPLAYIRAF -- Display an IRAF OIF format image to the given frame,
+ * optionally doing a Zscale transform of the image pixels.
+ */
+
+#ifdef ANSI_FUNC
+
+int
+cdl_displayIRAF (
+ CDLPtr cdl, /* package ptr */
+ char *fname, /* image name */
+ int band, /* image band if 3-d */
+ int frame, /* display frame */
+ int fbconfig, /* frame buffer config */
+ int zscale /* do zscale of image? */
+)
+#else
+
+int
+cdl_displayIRAF (cdl, fname, band, frame, fbconfig, zscale)
+CDLPtr cdl; /* package ptr */
+char *fname; /* image name */
+int band; /* image band if 3-d */
+int frame; /* display frame */
+int fbconfig; /* frame buffer config */
+int zscale; /* do zscale of image? */
+#endif
+{
+ char title[128];
+ int status, nx, ny, bitpix;
+ uchar *pix = NULL;
+ float z1 = 0.0, z2 = 0.0;
+
+
+ /* See if this is a valid IRAF file. */
+ if (!cdl_isIRAF (fname)) {
+ fprintf (stderr, "%s: not a valid IRAF file or doesn't exist.\n",
+ fname);
+ return (ERR);
+ }
+
+ /* Get the raw IRAF image pixels. */
+ if (cdl_readIRAF (fname, band, &pix, &nx, &ny, &bitpix, title))
+ return (ERR);
+
+ if (cdl_debug) {
+ printf("[cdl_displayIRAF] '%s[%d] frame=%d zscale=%d\n",
+ fname, band, frame, zscale);
+ printf("[cdl_displayIRAF] %dx%d bitpix=%d pixels z1=%g z2=%g\n",
+ nx, ny, bitpix, z1, z2);
+ }
+
+ (void) cdl_setTitle (cdl, title);
+ (void) cdl_setName (cdl, fname);
+ status = cdl_displayPix (cdl, pix, nx, ny, bitpix, frame, fbconfig,
+ zscale);
+ free ((char *) pix);
+ return (status);
+}
+
+
+/* CDL_ISIRAF -- Test a file to see if it is a IRAF file. We check for both
+ * V1 and V2 header magic numbers and return the appropriate version if found.
+ */
+
+#ifdef ANSI_FUNC
+
+int
+cdl_isIRAF (
+ char *fname /* input filename */
+)
+#else
+
+int
+cdl_isIRAF (fname)
+char *fname; /* input filename */
+#endif
+{
+ register FILE *fp;
+ int value = 0;
+ char magic[24];
+
+ if ((fp = fopen (fname, "r"))) {
+ fread (magic, sizeof (char), 12, fp);
+ fclose (fp);
+
+ /* See if this is a valid OIF header file. */
+ if (strncmp(magic, "imhv2", 5) == 0)
+ value = 2;
+ else {
+ cdl_strpak (magic, magic, 5);
+ if (strncmp(magic, "imhdr", 5) == 0)
+ value = 1;
+ }
+ }
+
+ return value;
+}
+
+
+/* CDL_READIRAF -- Read the pixels from an IRAF OIF format image, returning
+ * the pixel array, dimensions, and image type.
+ */
+
+#ifdef ANSI_FUNC
+
+int
+cdl_readIRAF (
+ char *fname, /* image name */
+ int band, /* image band if 3-d */
+ uchar **pix, /* pixel array (output) */
+ int *nx,
+ int *ny, /* dimensions (output) */
+ int *bitpix, /* pixel size (output) */
+ char *title /* image title */
+)
+#else
+
+int
+cdl_readIRAF (fname, band, pix, nx, ny, bitpix, title)
+char *fname; /* image name */
+int band; /* image band if 3-d */
+uchar **pix; /* pixel array (output) */
+int *nx, *ny; /* dimensions (output) */
+int *bitpix; /* pixel size (output) */
+char *title; /* image title */
+#endif
+{
+ char *errstr;
+ char *cdl_getIRAFPixels();
+
+ /* See if this is a valid IRAF file. */
+ if (!cdl_isIRAF (fname)) {
+ fprintf (stderr, "%s: not a valid IRAF file or doesn't exist.\n",
+ fname);
+ return (ERR);
+ }
+
+ if ((errstr=cdl_getIRAFPixels(fname,band,pix,nx,ny,bitpix,title))) {
+ fprintf (stderr, "%s\n", errstr);
+ return (ERR);
+ }
+
+ if (cdl_debug)
+ printf ("[cdl_readIRAF] '%s[%d]' nx=%d ny=%d bitpix=%d\n",
+ fname, band, *nx, *ny, *bitpix);
+
+ return (OK);
+}
+
+
+
+/* ------------------
+ * Private routines.
+ * ------------------*/
+
+/* CDL_GETIRAFPIXELS -- Given an IRAF filename return a pointer to the pixel
+ * array and the image dimensions.
+ */
+
+#ifdef ANSI_FUNC
+
+static char *
+cdl_getIRAFPixels (
+ char *fname, /* input filename */
+ int band, /* image band */
+ uchar **image, /* output pixels */
+ int *nx,
+ int *ny, /* dimensions */
+ int *bitpix, /* pixel size */
+ char *title /* image title */
+)
+#else
+
+static char *
+cdl_getIRAFPixels (fname, band, image, nx, ny, bitpix, title)
+char *fname; /* input filename */
+int band; /* image band */
+uchar **image; /* output pixels */
+int *nx, *ny; /* dimensions */
+int *bitpix; /* pixel size */
+char *title; /* image title */
+#endif
+{
+ register int i;
+ int npix, px, py, nbands, pix_size, version, swapped = 0;
+ FILE *pf;
+ char *line, pixfile[256];
+ int ptype, offset;
+
+
+ /* Read the image header params */
+ if (cdl_readImageHdr (fname, &version, &px, &py, nx, ny, &nbands,
+ &ptype, &offset, &swapped, pixfile, title) == ERR)
+ return "error reading image header";
+
+ /* Do some simple error checking. */
+ if (band > nbands)
+ return "Invalid band request.";
+ if (access (pixfile, R_OK) != 0)
+ return "Cannot access pixel file";
+
+ /* Open the pixel file and seek to the beginning of the data. */
+ if ((pf = fopen (pixfile, "r")) == NULL)
+ return "Cannot open pixel file.";
+
+ npix = (*nx) * (*ny);
+ if (cdl_setBitpix (ptype, &pix_size, bitpix) == ERR) {
+ fclose (pf);
+ return "Invalid pixel type in image";
+ }
+
+ /* Now suck up the pixels. */
+ *image = (uchar *) malloc (npix * pix_size);
+ offset += (band - 1) * (px * py) * pix_size;
+ lseek (fileno(pf), (off_t)offset, SEEK_SET);
+
+ if (*nx == px)
+ fread ((void *)*image, pix_size, npix, pf);
+ else {
+ line = (char *) malloc (px * pix_size);
+ for (i=0; i < (*ny); i++) {
+ fread (line, pix_size, px, pf);
+ bcopy (line, &((*image)[i*(*nx)*pix_size]), (*nx)*pix_size);
+ }
+ free ((char *)line);
+ }
+
+ /* See if we need to swap the bytes. */
+ if (version == 2)
+ cdl_swapPixels (swapped, *nx, *ny, ptype, image);
+
+ fclose (pf);
+ return NULL;
+}
+
+
+/* CDL_READIMAGEHDR -- Read the image header information.
+ */
+
+#ifdef ANSI_FUNC
+
+static int
+cdl_readImageHdr (
+ char *fname, /* image name */
+ int *version, /* OIF version number */
+ int *px,
+ int *py, /* physical storage dims */
+ int *nx,
+ int *ny,
+ int *nbands, /* image dims */
+ int *ptype, /* pixel type */
+ int *offset, /* offset to pixels */
+ int *swapped, /* byte-swapped pixels */
+ char *pfile, /* pixfile pathname */
+ char *title /* image title */
+)
+#else
+
+static int
+cdl_readImageHdr (fname, version, px, py, nx, ny, nbands, ptype, offset,
+ swapped, pfile, title)
+char *fname; /* image name */
+int *version; /* OIF version number */
+int *px, *py; /* physical storage dims */
+int *nx, *ny, *nbands; /* image dims */
+int *ptype; /* pixel type */
+int *offset; /* offset to pixels */
+int *swapped; /* byte-swapped pixels */
+char *pfile; /* pixfile pathname */
+char *title; /* image title */
+#endif
+{
+ FILE *hdr;
+
+ if ((hdr = fopen (fname, "r")) == NULL)
+ return (ERR);
+
+ *version = cdl_getVersion (hdr);
+ if (*version == VERSION_1) {
+ int header_v1[SZ_V1HDR];
+ char pixfile_v1[SZ_V1PIXFILE];
+
+ /* Read in the image header. */
+ fread ((void *)header_v1, sizeof (char), SZ_V1HDR, hdr);
+
+ /* Get the interesting stuff. */
+ *px = header_v1[IM_V1PHYSLEN];
+ *py = header_v1[IM_V1PHYSLEN+1];
+ *nx = header_v1[IM_V1LEN];
+ *ny = header_v1[IM_V1LEN+1];
+ *ptype = header_v1[IM_V1PIXTYPE];
+ *offset = (header_v1[IM_V1PIXOFF] - 1) * sizeof(short);
+ *nbands = header_v1[IM_V1LEN+2];
+ *swapped = 0;
+
+ /* Find the pixfile and see if it exists. */
+ cdl_strpak ((char *)&header_v1[IM_V1PIXFILE], pixfile_v1,
+ SZ_V1PIXFILE);
+ cdl_getPixfile (fname, pixfile_v1);
+ (void) strcpy (pfile, pixfile_v1);
+
+ /* Find the image title string */
+ if (title == (char *)NULL)
+ title = (char *) malloc (SZ_V1TITLE+1);
+ cdl_strpak ((char *)&header_v1[IM_V1TITLE], title, SZ_V1TITLE);
+
+ } else if (*version == VERSION_2) {
+ char header_v2[SZ_V2HDR], *tp;
+ char pixfile_v2[SZ_V2PIXFILE];
+
+ /* Read in the image header. */
+ fread (header_v2, sizeof (char), SZ_V2HDR, hdr);
+
+ /* Get the interesting stuff. */
+
+ if (is_swapped_machine())
+ bswap4 (&header_v2[IM_V2SWAPPED], 1, (char *)swapped,
+ 1, sizeof(int));
+ else
+ bcopy ((char *)&header_v2[IM_V2SWAPPED], (char *)swapped,
+ sizeof(int));
+
+ if (is_swapped_machine()) {
+ bswap4 (&header_v2[IM_V2PHYSLEN], 1, (char *)px, 1,
+ sizeof(int));
+ bswap4 (&header_v2[IM_V2PHYSLEN+sizeof(int)], 1,
+ (char *)py, 1, sizeof(int));
+ bswap4 (&header_v2[IM_V2LEN], 1, (char *)nx, 1,
+ sizeof(int));
+ bswap4 (&header_v2[IM_V2LEN+sizeof(int)], 1, (char *)ny,
+ 1, sizeof(int));
+ bswap4 (&header_v2[IM_V2PIXTYPE], 1, (char *)ptype, 1,
+ sizeof(int));
+ bswap4 (&header_v2[IM_V2PIXOFF], 1, (char *)offset, 1,
+ sizeof(int));
+ bswap4 (&header_v2[IM_V2LEN+(2*sizeof(int))], 1,
+ (char *)nbands, 1, sizeof(int));
+ } else {
+ bcopy ((char *)&header_v2[IM_V2PHYSLEN], px, sizeof(int));
+ bcopy ((char *)&header_v2[IM_V2PHYSLEN+sizeof(int)], py,
+ sizeof(int));
+ bcopy ((char *)&header_v2[IM_V2LEN], nx, sizeof(int));
+ bcopy ((char *)&header_v2[IM_V2LEN+sizeof(int)], ny,
+ sizeof(int));
+ bcopy ((char *)&header_v2[IM_V2PIXTYPE], ptype, sizeof(int));
+ bcopy ((char *)&header_v2[IM_V2PIXOFF], offset, sizeof(int));
+ bcopy ((char *)&header_v2[IM_V2LEN+(2*sizeof(int))], nbands,
+ sizeof(int));
+ }
+ *offset = (*offset - 1) * sizeof(short);
+
+ /* Find the pixfile and see if it exists. */
+ bcopy ((char *)&header_v2[IM_V2PIXFILE], pixfile_v2, SZ_V2PIXFILE);
+ cdl_getPixfile (fname, pixfile_v2);
+ (void) strcpy (pfile, pixfile_v2);
+
+ /* Find the image title string */
+ tp = (char *)&header_v2[IM_V2TITLE];
+ if (title == (char *)NULL)
+ title = (char *) malloc (SZ_V2TITLE+1);
+ strcpy (title, (char *)tp);
+ }
+
+ if (cdl_debug) {
+ printf("[cdl_readImageHdr] px,py=%d,%d nx,ny,nb=%d,%d,%d\n\t",
+ *px, *py, *nx, *ny, *nbands);
+ printf("ptype=%d offset=%d swap=%d pixfile='%s' title='%s'\n",
+ *ptype, *offset, swapped, pfile, title);
+ }
+
+ fclose (hdr); /* we're done with the header */
+ return (OK);
+}
+
+
+/* CDL_GETVERSION -- Return image header version.
+ */
+
+#ifdef ANSI_FUNC
+
+static int
+cdl_getVersion (
+ FILE *fd /* input filename */
+)
+#else
+
+static int
+cdl_getVersion (fd)
+FILE *fd; /* input filename */
+#endif
+{
+ int value = 0;
+ char magic[24];
+
+ rewind (fd);
+ fread (magic, sizeof (char), 12, fd);
+ rewind (fd);
+
+ /* See if this is a valid OIF header file. */
+ if (strncmp(magic, "imhv2", 5) == 0)
+ value = 2;
+ else {
+ cdl_strpak (magic, magic, 5);
+ if (strncmp(magic, "imhdr", 5) == 0)
+ value = 1;
+ }
+ return value;
+}
+
+
+/* CDL_GETPIXFILE -- Get the pixelfile pathname.
+ */
+
+#ifdef ANSI_FUNC
+
+static void
+cdl_getPixfile (char *fname, char *pfile)
+#else
+
+static void
+cdl_getPixfile (fname, pfile)
+char *fname;
+char *pfile;
+#endif
+{
+ char temp[SZ_V1PIXFILE], *ip;
+ int len;
+ char *index();
+
+ if (strncmp (pfile, "HDR$", 4) == 0) {
+ /* Handle the special case of a HDR$ pixfile path, prepend the
+ * current working directory name to the pixfile.
+ */
+ ip = pfile + 4;
+ (void) strncpy (temp, ip, SZ_V1PIXFILE);
+ (void) strncpy (pfile, fname, SZ_V1PIXFILE);
+
+ /* Find the end of the pathname. */
+ len = strlen (pfile);
+ while ( (len > 0) && (pfile[len-1] != '/') )
+ len--;
+
+ /* Add the image name. */
+ pfile[len] = '\0';
+ (void) strncat (pfile, temp, SZ_V1PIXFILE);
+
+ } else if (index (pfile, '!') != NULL) {
+ /* Strip out the leading node! prefix from the pixfile path. */
+ for (ip = pfile; *ip != '!' ; )
+ ip++;
+ (void) strcpy (pfile, ++ip);
+ }
+}
+
+
+/* CDL_SETBITPIX -- Set the number of pixels for a given pixel type.
+ */
+
+#ifdef ANSI_FUNC
+
+static int
+cdl_setBitpix (int ptype, int *pix_size, int *bitpix)
+#else
+
+static int
+cdl_setBitpix (ptype, pix_size, bitpix)
+int ptype;
+int *pix_size;
+int *bitpix;
+#endif
+{
+ switch (ptype) {
+ case TY_USHORT:
+ case TY_SHORT:
+ *pix_size = sizeof (short);
+ *bitpix = 16;
+ break;
+ case TY_INT:
+ *pix_size = sizeof (int);
+ *bitpix = 32;
+ break;
+ case TY_LONG:
+ *pix_size = sizeof (long);
+ *bitpix = 32;
+ break;
+ case TY_REAL:
+ *pix_size = sizeof (float);
+ *bitpix = -32;
+ break;
+ case TY_DOUBLE:
+ *pix_size = sizeof (double);
+ *bitpix = -64;
+ break;
+ default:
+ return (ERR);
+ }
+ return (OK);
+}
+
+
+/* CDL_SWAPPIXELS -- Byte swap pixels if necessary.
+ */
+
+#ifdef ANSI_FUNC
+
+static void
+cdl_swapPixels (int swapped, int nx, int ny, int ptype, uchar **image)
+#else
+
+static void
+cdl_swapPixels (swapped, nx, ny, ptype, image)
+int swapped;
+int nx, ny;
+int ptype;
+uchar **image;
+#endif
+{
+ if ((swapped != is_swapped_machine())) {
+ switch (ptype) {
+ case TY_USHORT:
+ case TY_SHORT:
+ bswap2 ((char *)*image, (char *)*image,
+ nx * ny * sizeof(short));
+ break;
+ case TY_INT:
+ case TY_LONG:
+ bswap4 ((char *)*image, 1, (char *)*image, 1,
+ nx * ny * sizeof(int));
+ break;
+ case TY_REAL:
+ bswap4 ((char *)*image, 1, (char *)*image, 1,
+ nx * ny * sizeof(float));
+ break;
+ case TY_DOUBLE:
+ bswap8 ((char *)*image, 1, (char *)*image, 1,
+ nx * ny * sizeof(double));
+ break;
+ }
+ }
+}
+
+
+/* CDL_STRPAK -- Convert ASCII string from SPP char per short to C char
+ * per byte.
+ */
+
+#ifdef ANSI_FUNC
+
+static void
+cdl_strpak (char *in, char *out, int len)
+#else
+
+static void
+cdl_strpak (in, out, len)
+char *in, *out;
+int len;
+#endif
+{
+ int i, j;
+
+ /* Adaptive byte selection (whichever byte order) chars alternate
+ * with \0.
+ */
+ j = (in[0] == '\0' ? 1 : 0);
+
+ for (i = 0; i < len; i++, j += 2)
+ out[i] = in[j];
+ out[i] = '\0';
+}
+
+
+/* BSWAP2 - Move bytes from array "a" to array "b", swapping successive
+ * pairs of bytes. The two arrays may be the same but may not be offset
+ * and overlapping.
+ */
+
+#ifdef ANSI_FUNC
+
+static void
+bswap2 (
+ char *a,
+ char *b, /* input array */
+ int nbytes /* number of bytes to swap */
+)
+#else
+
+static void
+bswap2 (a, b, nbytes)
+char *a, *b; /* input array */
+int nbytes; /* number of bytes to swap */
+#endif
+{
+ register char *ip=a, *op=b, *otop;
+ register unsigned temp;
+
+ /* Swap successive pairs of bytes.
+ */
+ for (otop = op + (nbytes & ~1); op < otop; ) {
+ temp = *ip++;
+ *op++ = *ip++;
+ *op++ = temp;
+ }
+
+ /* If there is an odd byte left, move it to the output array.
+ */
+ if (nbytes & 1)
+ *op = *ip;
+}
+
+
+/* BSWAP4 - Move bytes from array "a" to array "b", swapping the four bytes
+ * in each successive 4 byte group, i.e., 12345678 becomes 43218765.
+ * The input and output arrays may be the same but may not partially overlap.
+ */
+
+#ifdef ANSI_FUNC
+
+static void
+bswap4 (
+ char *a, /* input array */
+ int aoff, /* first byte in input array */
+ char *b, /* output array */
+ int boff, /* first byte in output array */
+ int nbytes /* number of bytes to swap */
+)
+#else
+
+static void
+bswap4 (a, aoff, b, boff, nbytes)
+char *a; /* input array */
+int aoff; /* first byte in input array */
+char *b; /* output array */
+int boff; /* first byte in output array */
+int nbytes; /* number of bytes to swap */
+#endif
+{
+ register char *ip, *op, *tp;
+ register int n;
+ static char temp[4];
+
+ tp = temp;
+ ip = (char *)a + aoff - 1;
+ op = (char *)b + boff - 1;
+
+ /* Swap successive four byte groups.
+ */
+ for (n = nbytes >> 2; --n >= 0; ) {
+ *tp++ = *ip++;
+ *tp++ = *ip++;
+ *tp++ = *ip++;
+ *tp++ = *ip++;
+ *op++ = *--tp;
+ *op++ = *--tp;
+ *op++ = *--tp;
+ *op++ = *--tp;
+ }
+
+ /* If there are any odd bytes left, move them to the output array.
+ * Do not bother to swap as it is unclear how to swap a partial
+ * group, and really incorrect if the data is not modulus 4.
+ */
+ for (n = nbytes & 03; --n >= 0; )
+ *op++ = *ip++;
+}
+
+
+/* BSWAP8 - Move bytes from array "a" to array "b", swapping the eight bytes
+ * in each successive 8 byte group, i.e., 12345678 becomes 87654321.
+ * The input and output arrays may be the same but may not partially overlap.
+ */
+#ifdef ANSI_FUNC
+
+static void
+bswap8 (
+ char *a, /* input array */
+ int aoff, /* first byte in input array */
+ char *b, /* output array */
+ int boff, /* first byte in output array */
+ int nbytes /* number of bytes to swap */
+)
+#else
+
+static void
+bswap8 (a, aoff, b, boff, nbytes)
+char *a; /* input array */
+int aoff; /* first byte in input array */
+char *b; /* output array */
+int boff; /* first byte in output array */
+int nbytes; /* number of bytes to swap */
+#endif
+{
+ register char *ip, *op, *tp;
+ register int n;
+ static char temp[8];
+
+ tp = temp;
+ ip = (char *)a + aoff - 1;
+ op = (char *)b + boff - 1;
+
+ /* Swap successive eight byte groups.
+ */
+ for (n = nbytes >> 3; --n >= 0; ) {
+ *tp++ = *ip++;
+ *tp++ = *ip++;
+ *tp++ = *ip++;
+ *tp++ = *ip++;
+ *tp++ = *ip++;
+ *tp++ = *ip++;
+ *tp++ = *ip++;
+ *tp++ = *ip++;
+ *op++ = *--tp;
+ *op++ = *--tp;
+ *op++ = *--tp;
+ *op++ = *--tp;
+ *op++ = *--tp;
+ *op++ = *--tp;
+ *op++ = *--tp;
+ *op++ = *--tp;
+ }
+
+ /* If there are any odd bytes left, move them to the output array.
+ * Do not bother to swap as it is unclear how to swap a partial
+ * group, and really incorrect if the data is not modulus 8.
+ */
+ for (n = nbytes & 03; --n >= 0; )
+ *op++ = *ip++;
+}
+
+
+#ifdef ANSI_FUNC
+
+static int
+is_swapped_machine (void)
+#else
+
+static int
+is_swapped_machine ()
+#endif
+{
+ union { char ch[4]; int i; } u;
+ u.i = 1;
+ return (u.ch[0]);
+}
generated by cgit (git 2.34.1) at 2025-09-20 14:27:06 -0400