home
***
CD-ROM
|
disk
|
FTP
|
other
***
search
/
Amiga Games 1996 January
/
amigagames-cdrom-1996-01.iso
/
rexx
/
picasso.filer
< prev
next >
Wrap
Text File
|
1995-01-12
|
23KB
|
591 lines
/*
$VER: Picasso.filer 1.7 (16.12.94)
Author:
Michael Böhnisch (billy@uni-paderborn.de) (mb)
Matthias Scheler (tron@lyssa.pb.owl.de) (ms)
Function:
ViewGIF, the GIF viewer that accompanies the Picasso II graphics
board, often selects wrong resolutions when displaying oversized
pictures. E.g. I´ve got a picture, 600×800 in size, ViewGIF
displays on a 1024×768 screen, cropping off the lower 34 rows.
Picasso.filer scans the GIF file for the picture size and forces
ViewGIF into a better resolution.
ViewJPEG uses 640×480×24 by default, regardless whether it crops
the image or not. I prefer seeing the whole image when possible,
so Picasso.filer allows 16 or 8 bits per pixel resolutions. Bigger
pictures may take a while to display, especially on unaccelerated
Amigas. Stay patient.
ViewIFF does not show Multi Palette pictures (PCHG chunk)
correctly. Picasso.filer provides a fallback to an external viewer
when such pictures are selected.
Pixels on the Picasso II board usually are square shaped, or in
other words have an X/Y aspect ratio of 1. This results in
distorted picture displays for special view modes like "NTSC:LoRes
Lace".
Picasso.filer handles this by supplying one of the keywords DOUBLEX
or DOUBLEY to ViewIFF as appropriate. For extreme distortions
(e.g. pictures for PAL:SuperHighres non-interlaced) a fallback to
an external external viewer on conservative Amiga screens is
choosen.
Requires:
Picasso II graphics board
ViewGIF, ViewJPEG and ViewIFF supplied with Picasso II
VT 2.0 by Thomas Krehbiel or any other standard IFF viewer. Must
support PCHG Multi Palette pictures if you want to view this
picture type.
Call:
Picasso TYPE FILE
Where TYPE is one of GIF, IFF or JPG. Picasso.filer relies on the
correctness of this info and does no further file type checking.
Example for "Filer.RC":
REXXCLASS "#?","GIF8","Picasso GIF %s"
REXXCLASS "#?","??????JFIF","Picasso JPG %s"
REXXCLASS "#?","FORM????ILBM","Picasso IFF %s"
ToDo:
IFF pictures with aspect ratios outside the range from 0.35 to 2.83
are displayed on standard Amiga screens. Maybe some tool should be
used to do a scale operation on the picture first and then forward
it to the Picasso viewer.
History:
06.02.94 1.0 Initial Release (mb)
07.02.94 1.1 IFF & JPEG added (mb)
08.02.94 1.2 fallback for HAM/EHB pictures removed (ms)
09.02.94 1.3 removed VT dependency for GIF
removed VT dependency for IFF, any viewer
wil do now
added IFF PCHG fallback
added fallback for non-square aspect ratios (mb)
10.02.94 1.4 used ViewIFF keywords DOUBLEX and DOUBLEY
for a wider range of pictures displayed on
the Picasso II (mb)
10.03.94 1.5 removed VT dependency for JPEG
no need for rexxsupport.library any longer
added user confirmation for oversized JPEGs (mb)
25.11.94 1.6 Bugfix: GIF files with extension block
present were not displayed (mb)
16.12.94 1.7 Added some support for nested IFF FORMS (mb)
*/
/* -------------------------------------------------------------------- */
/* External commands. Adjust these to your individual settings. */
/* -------------------------------------------------------------------- */
vtcommand = "VT"
vgcommand = "ViewGIF"
vjcommand = "ViewJPEG"
vicommand = "ViewIFF"
/* -------------------------------------------------------------------- */
OPTIONS RESULTS /* we need response from filer */
PARSE ARG TYPE PICFILE /* get arguments */
TYPE = STRIP( TYPE )
PICFILE = STRIP( PICFILE )
/* -------------------------------------------------------------------- */
/* Default to Filer's AReXX port and prevent Filer from quitting */
/* -------------------------------------------------------------------- */
ADDRESS 'FilerRexx'
LOCKFILER
Key = RESULT
/* -------------------------------------------------------------------- */
/* Get source dircetory name, append "/" if it is not a device name. */
/* Tag name of file to view. */
/* -------------------------------------------------------------------- */
GETSOURCEPATH
SrcPath = RESULT
IF RIGHT(SrcPath, 1) = ':' THEN
FileName = SrcPath || STRIP( PICFILE, B, X2C(22) )
ELSE
FileName = SrcPath || '/' || STRIP( PICFILE, B, X2C(22) )
SELECT
/* ---------------------------------------------------------------- */
/* Show GIF picture */
/* ---------------------------------------------------------------- */
WHEN TYPE = 'GIF' THEN DO
/* ------------------------------------------------------------ */
/* determine ViewGIF RESOLUTION parameter and call viewer */
/* ------------------------------------------------------------ */
CALL GIFSize
PARSE VAR RESULT xsize ysize depth
xsize = STRIP( xsize )
ysize = STRIP( ysize )
depth = STRIP( depth )
res = 1600
IF ( xsize <= 1280 ) & ( ysize <= 1024 ) THEN res = 1280
IF ( xsize <= 1152 ) & ( ysize <= 900 ) THEN res = 1152
IF ( xsize <= 1120 ) & ( ysize <= 832 ) THEN res = 1120
IF ( xsize <= 1024 ) & ( ysize <= 768 ) THEN res = 1024
IF ( xsize <= 800 ) & ( ysize <= 600 ) THEN res = 800
IF ( xsize <= 640 ) & ( ysize <= 480 ) THEN res = 640
IF ( xsize <= 320 ) & ( ysize <= 240 ) THEN res = 320
HISTORY 'Picasso: GIF "' || FileName || '"' xsize || '×' || ysize || '×' || depth
SHELL COMMAND vgcommand RESOLUTION res CENTER FileName '>NIL:'
END
/* ---------------------------------------------------------------- */
/* Show JPG picture */
/* ---------------------------------------------------------------- */
WHEN TYPE = 'JPG' THEN DO
/* ------------------------------------------------------------ */
/* Determine JPEG picture size */
/* ------------------------------------------------------------ */
CALL JPGSize
PARSE VAR RESULT xsize ysize depth
xsize = STRIP( xsize )
ysize = STRIP( ysize )
depth = STRIP( depth )
/* ------------------------------------------------------------ */
/* choose maximum number of colors available without cropping */
/* and call ViewJPG */
/* ------------------------------------------------------------ */
dep = '8BIT'
IF ( xsize <= 1152 ) & ( ysize <= 900 ) THEN dep = '16BIT'
IF ( xsize <= 800 ) & ( ysize <= 600 ) THEN dep = '24BIT'
banner = xsize || '×' || ysize || '×' || depth
HISTORY 'Picasso: JPG "' || FileName || '"' banner '(' || dep || ')'
/* ------------------------------------------------------------ */
/* Ask for confirmation if picture is "on the big side" */
/* ------------------------------------------------------------ */
display = 1
IF xsize * ysize > 1000000 THEN DO
txt = "This operation may take a long time.|"
txt = txt || " Shall I continue anyway?"
QUESTBOX txt
display = RESULT
END
IF display = 1 THEN SHELL COMMAND vjcommand dep FileName '>NIL:'
END
/* ---------------------------------------------------------------- */
/* Show IFF ILBM picture */
/* ---------------------------------------------------------------- */
WHEN TYPE = IFF THEN DO
/* ------------------------------------------------------------ */
/* determine size and depth of the picture */
/* ------------------------------------------------------------ */
CALL IFFSize
PARSE VAR RESULT xsize ysize depth ratio
xsize = STRIP( xsize )
ysize = STRIP( ysize )
depth = STRIP( depth )
ratio = STRIP( ratio )
banner = xsize || '×' || ysize || '×' || depth
/* ------------------------------------------------------------ */
/* Does the IFF file contain a PCHG chunk? These pictures may */
/* have a dedicated palette for each scanline and currently are */
/* not displayed correctly by ViewIFF. */
/* ------------------------------------------------------------ */
CALL PCHGTest
test = RESULT
SELECT
WHEN test = 'ERRR' THEN DO
/* ---------------------------------------------------- */
/* An error occured, inform user and exit */
/* ---------------------------------------------------- */
HISTORY 'Picasso: error processing' FileName
END
WHEN test = 'PCHG' THEN DO
/* ---------------------------------------------------- */
/* Display Multi-Palette picture */
/* ---------------------------------------------------- */
HISTORY 'Picasso: IFF "' || FileName || '"' banner '(PCHG)'
SHELL COMMAND vtcommand FileName '>NIL:'
END
/* -------------------------------------------------------- */
/* do some correction of aspect ratios in number range */
/* 0.35 = sqrt(0.5) ... 2.83 = 2 * sqrt(2) */
/* by ViewIFF options DOUBLEX and DOUBLEY */
/* -------------------------------------------------------- */
WHEN ( ratio < 0.71 ) & ( ratio >= 0.35 ) THEN DO
/* ---------------------------------------------------- */
/* Pixels are about half as wide than tall */
/* ---------------------------------------------------- */
HISTORY 'Picasso: IFF "' || FileName || '"' banner '(X:Y =' ratio || ')'
SHELL COMMAND vicommand CENTER MODE DOUBLEY FileName '>NIL:'
END
WHEN ( ratio < 1.41 ) & ( ratio >= 0.71 ) THEN DO
/* ---------------------------------------------------- */
/* Take this for square, some distortion tolerated */
/* ---------------------------------------------------- */
HISTORY 'Picasso: IFF "' || FileName || '"' banner '(X:Y =' ratio || ')'
SHELL COMMAND vicommand CENTER FileName '>NIL:'
END
WHEN ( ratio < 2.83 ) & ( ratio >= 1.41 ) THEN DO
/* ---------------------------------------------------- */
/* Pixels are about twice as wide than tall */
/* ---------------------------------------------------- */
HISTORY 'Picasso: IFF "' || FileName || '"' banner '(X:Y =' ratio || ')'
SHELL COMMAND vicommand CENTER MODE DOUBLEX FileName '>NIL:'
END
OTHERWISE DO
/* ---------------------------------------------------- */
/* Fall back to externalviewer if outside aspect bounds */
/* This should happen very rarely, e.g. for pictures in */
/* Superhires without interlace (aspect ratio ~ 4) or */
/* Multiscan productivity with interlace (aspect ratio */
/* ~ 0.25) */
/* ---------------------------------------------------- */
HISTORY 'Picasso: IFF "' || FileName || '"' banner '(X:Y =' ratio || 'FB)'
SHELL COMMAND vtcommand FileName '>NIL:'
END
END
END
/* ---------------------------------------------------------------- */
/* unknown type */
/* ---------------------------------------------------------------- */
OTHERWISE DO
/* ------------------------------------------------------------ */
/* Wrong type parameter, inform user */
/* ------------------------------------------------------------ */
HISTORY 'Picasso: Type' TYPE 'not supported'
END
END
/* -------------------------------------------------------------------- */
/* re-allow quitting Filer */
/* -------------------------------------------------------------------- */
UNLOCKFILER Key
EXIT
/************************************************************************/
/* JPGSize : subroutine parses a JFIF file and returns the picture's */
/* dimensions */
/************************************************************************/
JPGSize: PROCEDURE EXPOSE FileName
M_SOF0 = X2C( C0 ) /* SOF code for arithmetic encoding */
M_SOF1 = X2C( C1 ) /* SOF code for baseline implementation */
M_SOF9 = X2C( C9 ) /* SOF code for non-baseline Huffmann file */
IF OPEN( jpg, FileName, 'READ' ) THEN DO
/* ------------------------------------------------------------ */
/* skip over SOI marker */
/* ------------------------------------------------------------ */
SEEK( jpg, 2, 'BEGIN' ) /* point to JFIF APP0 block */
/* ------------------------------------------------------------ */
/* Loop through data blocks until EOF or a SOF block is found */
/* ------------------------------------------------------------ */
DO UNTIL EOF( jpg )
IF READCH( jpg ) ~= X2C( FF ) THEN RETURN
/* -------------------------------------------------------- */
/* Get block type marker */
/* -------------------------------------------------------- */
type = READCH( jpg )
/* -------------------------------------------------------- */
/* Test for SOF block */
/* -------------------------------------------------------- */
IF type = M_SOF0 | type = M_SOF1 | type = M_SOF9 THEN DO
/* ---------------------------------------------------- */
/* Skip to size information words */
/* ---------------------------------------------------- */
SEEK( jpg, 3, 'CURRENT' )
/* ---------------------------------------------------- */
/* read size information and return to calling proc */
/* ---------------------------------------------------- */
hi = C2D( READCH( jpg ) )
lo = C2D( READCH( jpg ) )
h = lo + 256 * hi
hi = C2D( READCH( jpg ) )
lo = C2D( READCH( jpg ) )
w = lo + 256 * hi
CLOSE( jpg )
RETURN w h 24
END
/* -------------------------------------------------------- */
/* No SOF, skip to next marker */
/* -------------------------------------------------------- */
hi = C2D( READCH( jpg ) )
lo = C2D( READCH( jpg ) )
SEEK( jpg, lo + 256 * hi - 2, 'CURRENT' )
END
CLOSE( jpg )
END
RETURN
/************************************************************************/
/* GIFSize : subroutine parses a GIF file and returns the picture's */
/* dimensions */
/************************************************************************/
GIFSize: PROCEDURE EXPOSE FileName
IF OPEN( gif, FileName, 'READ' ) THEN DO
/* ------------------------------------------------------------ */
/* extract colour depth information */
/* ------------------------------------------------------------ */
SEEK( gif, 10, 'BEGIN' ) /* point to resolution flag reg. */
rf = C2D( READCH( gif ) ) /* resolution flag register */
r = ( rf // 8 ) + 1 /* extract bits/pixel */
SEEK( gif, 13, 'BEGIN' ) /* point behind screen descriptor */
/* ------------------------------------------------------------ */
/* skip global colour map if present */
/* ------------------------------------------------------------ */
IF rf >= 128 THEN SEEK( gif, 3 * 2**r, 'CURRENT' )
/* ------------------------------------------------------------ */
/* skip extension block if present */
/* ------------------------------------------------------------ */
IF READCH( gif ) = '!' THEN DO /* read header */
SEEK( gif, 1, 'CURRENT' ) /* skip function code */
DO UNTIL len = 0 /* up to last block */
len = C2D( READCH( gif ) ) /* get data block size */
SEEK( gif, len, 'CURRENT' ) /* skip data block */
END
SEEK( gif, 1, 'CURRENT' ) /* skip next header */
END
/* ------------------------------------------------------------ */
/* The image descriptor block is reached, at last. Now let's */
/* look for the actual image size... */
/* ------------------------------------------------------------ */
SEEK( gif, 4, 'CURRENT' ) /* skip topleft coords */
/* ------------------------------------------------------------ */
/* all numbers are stored in INTEL format, lo-byte first */
/* ------------------------------------------------------------ */
lo = C2D( READCH( gif ) ) /* get width */
hi = C2D( READCH( gif ) )
w = lo + 256 * hi
lo = C2D( READCH( gif ) ) /* get height */
hi = C2D( READCH( gif ) )
h = lo + 256 * hi
CLOSE( gif )
RETURN w h r
END
RETURN
/************************************************************************/
/* IFFSize : subroutine parses an IFF ILBM file and returns the picture */
/* size and pixel aspect ratio */
/************************************************************************/
IFFSize: PROCEDURE EXPOSE FileName
IF OPEN( iff, FileName, 'READ' ) THEN DO
/* ------------------------------------------------------------ */
/* File starts with FORM????ILBM. */
/* ------------------------------------------------------------ */
len = 12 /* offset for first chunk in file */
DO UNTIL type = 'BMHD'
/* -------------------------------------------------------- */
/* seek to next chunk */
/* -------------------------------------------------------- */
SEEK( iff, len, 'CURRENT' )
/* -------------------------------------------------------- */
/* parse out chunk type and length */
/* -------------------------------------------------------- */
type = READCH( iff, 4 )
IF type = 'FORM' THEN
len = 8;
ELSE DO
len = C2D( READCH( iff ) )
len = len * 256 + C2D( READCH( iff ) )
len = len * 256 + C2D( READCH( iff ) )
len = len * 256 + C2D( READCH( iff ) )
END
IF len // 2 = 1 THEN len = len + 1 /* add 1 for odd length */
END
/* ------------------------------------------------------------ */
/* We're now positioned on a BMHD chunk. */
/* ------------------------------------------------------------ */
hi = C2D( READCH( iff ) ) /* read image width */
lo = C2D( READCH( iff ) )
w = lo + 256 * hi
hi = C2D( READCH( iff ) ) /* read image height */
lo = C2D( READCH( iff ) )
h = lo + 256 * hi
SEEK( iff, 4, 'CURRENT' ) /* seek to nPlanes entry */
d = C2D( READCH( iff ) ) /* number of bitplanes (depth) */
SEEK( iff, 5, 'CURRENT' ) /* seek to aspect ratio entries */
xa = C2D( READCH( iff ) ) /* xAspect */
ya = C2D( READCH( iff ) ) /* yAspect */
NUMERIC DIGITS 3 /* sometimes less is more... */
a = xa / ya /* Aspect ratio */
NUMERIC DIGITS
CLOSE( iff ) /* clean up */
RETURN w h d a
END
RETURN
/************************************************************************/
/* PCHGTest : Returns true if IFFFile contains a PCHG chunk and thus, */
/* is not correctly displayed by ViewIFF. */
/************************************************************************/
PCHGTest: PROCEDURE EXPOSE FileName
IF OPEN( iff, FileName, "READ" ) THEN DO
len = 12
DO UNTIL ( Type = 'PCHG' ) | EOF( iff )
SEEK( iff, len, 'CURRENT' )
type = READCH( iff, 4 )
IF type = 'FORM' THEN
len = 8;
ELSE DO
b1 = C2D( READCH( iff ) ) * 2**24
b2 = C2D( READCH( iff ) ) * 2**16
b3 = C2D( READCH( iff ) ) * 2**8
b4 = C2D( READCH( iff ) )
len = b1 + b2 + b3 + b4
END
IF len // 2 = 1 THEN len = len + 1 /* add 1 for odd length */
END
CLOSE( iff )
IF Type = 'PCHG' THEN
RETURN 'PCHG'
ELSE
RETURN 'NORM'
END
RETURN 'ERROR'