Initial commit

1 files changed, 117 insertions, 0 deletions

diff --git a/sys/imio/imsetbuf.x b/sys/imio/imsetbuf.x
new file mode 100644
index 00000000..3938f30a
--- /dev/null
+++ b/sys/imio/imsetbuf.x
@@ -0,0 +1,117 @@
+# Copyright(c) 1986 Association of Universities for Research in Astronomy Inc.
+
+include	<imhdr.h>
+include	<fset.h>
+include	<imio.h>
+
+# IMSETBUF -- Set the FIO file buffer size for the pixel storage file.
+# We always make the buffer size equal to an integral number of image lines
+# if possible.  The actual number of image lines chosen depends on the
+# type of access expected and the size of an image line.  If image lines are
+# very large the FIO buffer will be shorter than a line.  We also compute
+# IM_FAST, the flag determining whether or not direct access to the FIO
+# buffer is permissible.
+
+procedure imsetbuf (fd, im)
+
+int	fd			# pixel storage file
+pointer	im			# image header pointer
+
+long	imsize, bufoff, blkoff
+int	maxlines, bufsize, szline, nlines, i
+int	opt_bufsize, max_bufsize, dev_blksize
+int	fstati(), sizeof()
+
+begin
+	IM_FAST(im) = NO
+
+	max_bufsize = fstati (fd, F_MAXBUFSIZE)
+	opt_bufsize = fstati (fd, F_OPTBUFSIZE)
+	dev_blksize = max (1, fstati (fd, F_BLKSIZE))
+
+	szline = IM_PHYSLEN(im,1) * sizeof(IM_PIXTYPE(im))
+	imsize = szline
+	do i = 2, IM_NDIM(im)
+	    imsize = imsize * IM_PHYSLEN(im,i)
+
+	# Compute the suggested buffer size.  If bufsize is set externally
+	# and buffrac is disabled (zero) then we try to use the bufsize
+	# value given.  If buffrac is enabled then we compute a bufsize
+	# based on this, and use the larger of this value or the default
+	# bufsize, but not more than DEF_MAXFIOBUFSIZE.  The parameter
+	# buffrac specifies the size of an image buffer as a fraction,
+	# in percent, of the total size of the image.
+	#
+	# For example if buffrac=10, the default buffer size will be either
+	# "bufsize", or 10% of the full image size, whichever is larger, but
+	# not more than DEF_MAXFIOBUFSIZE.  The intent of buffrac is to
+	# provide an adaptive mechanism for adjusting the size of the image
+	# buffers to match the image being accessed.  For small images the
+	# buffer will be the default bufsize (or less if the image is 
+	# smaller than this).  For very large images the buffer size will 
+	# increase until the builtin default maximum value DEF_MAXFIOBUFSIZE 
+	# is reached.  If more control is needed, buffrac can be set to zero,
+	# and bufsize will specify the buffer size to be used.  Even if
+	# buffrac is enabled, bufsize can be set to a large value to force
+	# a large buffer to be used.
+
+	bufsize = IM_VBUFSIZE(im)
+	if (IM_VBUFFRAC(im) > 0)
+	    bufsize = max(bufsize, min(IM_VBUFMAX(im),
+		imsize / 100 * min(100,IM_VBUFFRAC(im)) ))
+
+	# Compute max number of image lines that will fit in default buffer.
+	if (max_bufsize > 0)
+	    nlines = min(max_bufsize,max(opt_bufsize,bufsize)) / szline
+	else
+	    nlines = bufsize / szline
+
+	# Compute final number of image lines in buffer.
+	if (nlines == 0) {
+	    # Image lines are very long.  Use a buffer smaller than a line.
+	    call fseti (fd, F_ADVICE, SEQUENTIAL)
+	    return
+	} else if (IM_VADVICE(im) == RANDOM) {
+	    # Always buffer at least one line if the lines are short.
+	    nlines = 1
+	}
+
+	# Don't make the buffer any larger than the image.
+	maxlines = 1
+	do i = 2, IM_NDIM(im)
+	    maxlines = maxlines * IM_PHYSLEN(im,i)
+	nlines = min (nlines, maxlines)
+
+	# Tell FIO to align the first file buffer to the device block
+	# containing the first image line.  Ideally the image line will
+	# start on a block boundary but this does not have to be the case.
+
+	bufoff = (IM_PIXOFF(im) - 1) / dev_blksize * dev_blksize + 1
+	blkoff = IM_PIXOFF(im) - bufoff
+	call fseti (fd, F_FIRSTBUFOFF, bufoff)
+
+	# An integral number of image lines fit inside the default size
+	# buffer.  Tell FIO the minimum size buffer to use.  FIO will actually
+	# allocate a slightly larger buffer if bufsize is not an integral
+	# number of device blocks.
+
+	bufsize = blkoff + nlines * szline
+	call fseti (fd, F_BUFSIZE, bufsize)
+
+	# If a FIO buffer will hold at least two image lines, if no image
+	# section was given, if there is only one input line buffer, if
+	# we are not going to be referencing out of bounds, and the pixel
+	# data is properly aligned in the pixel file, then FAST i/o (directly
+	# into the FIO buffer) is possible provided no datatype conversion
+	# or byte swapping is desired or required.  If all these criteria
+	# are true enable fast i/o.
+
+	if ((bufsize / szline >= 2 && IM_SECTUSED(im) == NO) &&
+	    (IM_VNBUFS(im) == 1 && IM_VNBNDRYPIX(im) == 0) &&
+	    (mod (IM_PIXOFF(im), sizeof(IM_PIXTYPE(im)))) == 1 &&
+	    IM_SWAP(im) == NO) {
+
+	    IM_FAST(im) = YES
+IM_FAST(im) = NO
+	}
+end