Old tools that got removed a long time ago.
git-svn-id: svn://svn.code.sf.net/p/sc2/code/trunk@1545 8092fc87-c524-0410-9efc-e669fe64eaf9
This commit is contained in:
meep-eep
@@ -0,0 +1,530 @@
|
||||
/*----------------------------------------------------------------------*/
|
||||
/* */
|
||||
/* animio.c - Page-flip animation-- file io code. */
|
||||
/* */
|
||||
/*----------------------------------------------------------------------*/
|
||||
|
||||
|
||||
#include "main.h"
|
||||
#include "anim.h" /* FIRST_FRAME_N */
|
||||
#include "dpiff.h"
|
||||
#include "dialogmg.h" /* for LIST definition */
|
||||
#include "string.h"
|
||||
#include <sys\types.h>
|
||||
#include <sys\stat.h>
|
||||
|
||||
extern SHORT curDepth;
|
||||
extern UWORD *ytable;
|
||||
extern BITMAP hidbm;
|
||||
extern AnimOb curAnimBr;
|
||||
extern SHORT curfps, nPages, curPage;
|
||||
extern animProcHandle *animOps;
|
||||
|
||||
#define local static
|
||||
|
||||
BOOL isAnimBrIO = NO;
|
||||
|
||||
#if 0
|
||||
SHORT saveFrameNum;
|
||||
SHORT saveStart, nSave, loadStart = 0;
|
||||
|
||||
#endif
|
||||
|
||||
typedef struct IntuiMessage IMsg;
|
||||
|
||||
|
||||
DPAnimChunk dpAnimChnk;
|
||||
|
||||
#if 0
|
||||
#define AnimOp(N) (*animOps[N])()
|
||||
#endif
|
||||
|
||||
FreeDelta(register Delta * del)
|
||||
{
|
||||
register int p;
|
||||
|
||||
for (p = 0; p < curDepth; p++) {
|
||||
FP_SEG(del->plane[p]) = SFree(FP_SEG(del->plane[p]));
|
||||
}
|
||||
}
|
||||
|
||||
|
||||
/*--------------------------------------------------------------*/
|
||||
/* Read In ANIM iff files */
|
||||
/*--------------------------------------------------------------*/
|
||||
|
||||
|
||||
#ifdef DBGDLTA
|
||||
BOOL dbgdlta = YES;
|
||||
|
||||
#endif
|
||||
|
||||
|
||||
/*--------------------------------------------------------------*/
|
||||
/*- Read in a DPAN chunk -----------*/
|
||||
/*--------------------------------------------------------------*/
|
||||
IFFP GetDPAnimChunk(context)
|
||||
GroupContext *context;
|
||||
{
|
||||
IFFP iffp = IFFReadBytes(
|
||||
context, (BYTE *) & dpAnimChnk, (LONG) sizeof(DPAnimChunk));
|
||||
|
||||
ByteFlipAnimChunk(&dpAnimChnk);
|
||||
#ifdef DBGDLTA
|
||||
if (dbgdlta) {
|
||||
printf(" GetDPAnimChunk , vers = %d, nframes = %d, flags = %d \n",
|
||||
dpAnimChnk.version, dpAnimChnk.nframes, dpAnimChnk.flags);
|
||||
}
|
||||
#endif
|
||||
return (iffp);
|
||||
}
|
||||
|
||||
|
||||
/*--------------------------------------------------------------*/
|
||||
/*- Write out a DPAN chunk -----------*/
|
||||
/*--------------------------------------------------------------*/
|
||||
IFFP PutDPAN(context)
|
||||
GroupContext *context;
|
||||
{
|
||||
DPAnimChunk dpAnCh;
|
||||
|
||||
setmem(&dpAnCh, sizeof(DPAnimChunk), 0);
|
||||
dpAnCh.version = DPANIM_VERS3;
|
||||
if (isAnimBrIO) {
|
||||
dpAnCh.nframes = curAnimBr.nCels;
|
||||
dpAnCh.duration = curAnimBr.duration;
|
||||
dpAnCh.flags = curAnimBr.flags;
|
||||
dpAnCh.rate = 0;
|
||||
}
|
||||
#if 0 /* Not supporting anims, just animbrushes. */
|
||||
else {
|
||||
dpAnCh.nframes = nSave;
|
||||
dpAnCh.rate = curfps;
|
||||
}
|
||||
#endif
|
||||
ByteFlipAnimChunk(&dpAnCh);
|
||||
return
|
||||
PutCk(context, ID_DPAN, (LONG) sizeof(DPAnimChunk), (BYTE *) & dpAnCh);
|
||||
/* NOTE: needn't flip back to IBM byte-order, since not using further. */
|
||||
}
|
||||
|
||||
#if ANIMDISK
|
||||
/*--------------------------------------------------------------*/
|
||||
/* Anim file IO */
|
||||
/*--------------------------------------------------------------*/
|
||||
typedef char FileName[FILENAME_LENGTH + 1];
|
||||
extern WORD curFrame;
|
||||
|
||||
/*---------------------------------------------------------------*/
|
||||
/* Saving anim as separate ILBM's */
|
||||
/* */
|
||||
/* Assumes <name> contains the desired file extension and that */
|
||||
/* 1 <= start <= animFrames, 1 <= end <= animFrames */
|
||||
/*---------------------------------------------------------------*/
|
||||
void SaveAnimAsILBMs(name, start, end)
|
||||
char *name;
|
||||
SHORT start, end;
|
||||
{
|
||||
auto int i, len;
|
||||
auto int nframes = end - start + 1;
|
||||
FileName nm, bsname;
|
||||
auto char nstr[SEQUENCE_SUFFIX_LENGTH], ext[FILENAME_SUFFIX_LENGTH + 2];
|
||||
auto struct stat filestat;
|
||||
auto char *ptr;
|
||||
auto BOOL overwrite = NO;
|
||||
|
||||
/* seperate out the file extension, if any */
|
||||
strcpy(bsname, name);
|
||||
ptr = strchr(bsname, '.');
|
||||
if (ptr) {
|
||||
strncpy(ext, ptr, sizeof(ext));
|
||||
ext[sizeof(ext) - 1] = *ptr = '\0';
|
||||
} else
|
||||
ext[0] = '\0';
|
||||
|
||||
len = strlen(bsname);
|
||||
if (!len) {
|
||||
NotAcceptableFileNameMsg();
|
||||
return;
|
||||
}
|
||||
if ((len + SEQUENCE_SUFFIX_LENGTH) > FILENAME_ROOT_LENGTH) {
|
||||
BaseNameTooLongMsg();
|
||||
return;
|
||||
}
|
||||
AnimGoTo(start);
|
||||
for (i = 0; i < nframes; i++) {
|
||||
strcpy(nm, bsname);
|
||||
num_to_string_zeroes(curFrame, nstr, SEQUENCE_SUFFIX_LENGTH);
|
||||
strcat(nm, nstr);
|
||||
strcat(nm, ext);
|
||||
if (stat(nm, &filestat) != -1) {
|
||||
if (filestat.st_mode & S_IFDIR) {
|
||||
CantReplaceDirMsg();
|
||||
break;
|
||||
} else if (!(filestat.st_mode & S_IWRITE)) {
|
||||
FileIsWriteProtectedMsg();
|
||||
break;
|
||||
} else if (!overwrite) {
|
||||
if (!ReplaceSequence(nm))
|
||||
break;
|
||||
else
|
||||
overwrite = YES;
|
||||
}
|
||||
}
|
||||
if (!save_picture0(nm))
|
||||
break;
|
||||
AnimStepPage(1);
|
||||
if (CheckAbort()) {
|
||||
ClearAbortFlag();
|
||||
break;
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
#endif /* ANIMDISK */
|
||||
|
||||
|
||||
/*--------------------------------------------------------------*/
|
||||
/* Loading ILBMs as Anim */
|
||||
/* tries to load a sequence of ilbm files (bname...bname+num-1) */
|
||||
/* as a new anim with <num> frames. */
|
||||
/*--------------------------------------------------------------*/
|
||||
extern char **filename_strings;
|
||||
extern char pict_dir[], dir_mark[];
|
||||
|
||||
LoadILBMsAsAnim(char *bname, SHORT num, BOOL insert, char *pictExtension)
|
||||
{
|
||||
int i, starti, endi, off;
|
||||
char *fname;
|
||||
LIST list;
|
||||
|
||||
#if 1 /* Prepare filenames */
|
||||
set_full_directory(pict_dir);
|
||||
setmem(&list, sizeof(LIST), 0);
|
||||
if (!AllocFilenameStrings())
|
||||
goto bail;
|
||||
NewNames0(&list, pictExtension, FALSE);
|
||||
#endif
|
||||
|
||||
off = strlen(dir_mark);
|
||||
starti = -1;
|
||||
for (i = 0; i < list.num_items; i++) {
|
||||
fname = filename_strings[i] + off;
|
||||
if (strcmp(fname, bname) == 0) {
|
||||
starti = i;
|
||||
break;
|
||||
}
|
||||
}
|
||||
if (starti == -1)
|
||||
goto bail;
|
||||
endi = starti + num - 1;
|
||||
endi = MIN(endi, list.num_items - 1);
|
||||
num = endi - starti + 1;
|
||||
|
||||
if (insert) {
|
||||
/* insert pages after curFrame */
|
||||
if (AddPages(num) == FAIL)
|
||||
return;
|
||||
AnimStepPage(1); /* go to first newly added frame */
|
||||
} else {
|
||||
FreeStrings(&list); /* Make room for NewAnim/SaveAnim dialog. */
|
||||
FreeFilenameStrings();
|
||||
/* create a new untitled anim with the appropriate # of frames */
|
||||
if (NewAnim00(TRUE, num, TRUE) == FAIL)
|
||||
return; /* couldn't create new anim or user aborted */
|
||||
#if 1 /* Prepare filenames */
|
||||
set_full_directory(pict_dir);
|
||||
setmem(&list, sizeof(LIST), 0);
|
||||
if (!AllocFilenameStrings())
|
||||
goto bail;
|
||||
NewNames0(&list, pictExtension, FALSE);
|
||||
#endif
|
||||
}
|
||||
|
||||
HideControls();
|
||||
ZZZCursor();
|
||||
for (i = starti; i <= endi; i++) {
|
||||
fname = filename_strings[i];
|
||||
if (fname[0] == dir_mark[0]) {
|
||||
DelPages(1); /* But suppose many pages left unfilled? */
|
||||
break; /* TBD: want to continue to find more
|
||||
* dir's? */
|
||||
}
|
||||
fname += off;
|
||||
|
||||
if (!load_picture00(fname, TRUE, TRUE))
|
||||
break;
|
||||
|
||||
#if comingSoon
|
||||
...remap picture(avoid doing on first picture, when getting
|
||||
palette from first picture ?)
|
||||
CopyPaletteFromFile(curpal, oldPaletteFileLetter);
|
||||
#endif
|
||||
|
||||
if (CheckAbort()) {
|
||||
ClearAbortFlag();
|
||||
break;
|
||||
}
|
||||
AnimStepPage(1);
|
||||
}
|
||||
AnimGoTo(FIRST_FRAME_N);
|
||||
UnZZZCursor();
|
||||
ShowControls();
|
||||
bail:
|
||||
FreeStrings(&list);
|
||||
FreeFilenameStrings();
|
||||
}
|
||||
|
||||
|
||||
/* --------------- Set/Clear AnBrIO ---------------
|
||||
*/
|
||||
SetAnBrIO()
|
||||
{
|
||||
isAnimBrIO = YES;
|
||||
}
|
||||
|
||||
ClearAnBrIO()
|
||||
{
|
||||
isAnimBrIO = NO;
|
||||
}
|
||||
|
||||
|
||||
/*--------------------------------------------------------------*/
|
||||
/* Anim IFF IO routines */
|
||||
/*--------------------------------------------------------------*/
|
||||
|
||||
#if 0
|
||||
SHORT animLoadState;
|
||||
|
||||
local void SetAnimLoadFail()
|
||||
{
|
||||
animLoadState = FAIL;
|
||||
}
|
||||
|
||||
#endif /* 0 */
|
||||
|
||||
|
||||
#define IFF_MEMFAIL -10
|
||||
|
||||
IFFP AnimGetDLTA(context, bmHdr, animHdr, frameCnt, buffer, bufsize)
|
||||
GroupContext *context;
|
||||
BitMapHeader *bmHdr;
|
||||
AnimHdr *animHdr;
|
||||
SHORT frameCnt;
|
||||
BYTE *buffer;
|
||||
LONG bufsize;
|
||||
{
|
||||
IFFP iffp;
|
||||
BITMAP *tmp;
|
||||
int res;
|
||||
|
||||
if (isAnimBrIO)
|
||||
return (GetAnBrDLTA(context, bmHdr, animHdr, frameCnt, buffer, bufsize));
|
||||
#if 1
|
||||
BugExit("AN1");
|
||||
/* "IFF format for Anim only implemented for brush so far"); */
|
||||
#else /* screen anim */
|
||||
if (frameCnt == 1) {
|
||||
animLoadState = SUCCESS;
|
||||
if (loadStart > 0) {
|
||||
#if 0 /* TBD !!!!!!!!!!!!!!!!!!!!!!!!!!!!!! */
|
||||
if (AnimOp(ANIM_SAVECHGS) == FAIL)
|
||||
return (IFF_MEMFAIL);
|
||||
#endif
|
||||
} else
|
||||
AnimClearDirty();
|
||||
if (animHdr->interleave != 0 && animHdr->interleave != 2) {
|
||||
NotValidAnimMsg();
|
||||
#if 0 /* TBD: Not moved over from Amiga. 1/30/90 */
|
||||
SkipErrorMsg(); /* tell dpio not to put another error req.
|
||||
* up */
|
||||
#endif
|
||||
return (BAD_FORM);
|
||||
}
|
||||
#if 0 /* TBD: Not moved over from Amiga. 1/30/90 */
|
||||
ShowLoadedPalette();
|
||||
#endif
|
||||
}
|
||||
if (CheckAbort()) {
|
||||
ClearAbortFlag();
|
||||
return (IFF_DONE);
|
||||
}
|
||||
if (dpAnimChnk.version > DPANIM_VERS1) {
|
||||
if (frameCnt >= dpAnimChnk.nframes) {
|
||||
/* Skip remaining deltas: they are for circular play */
|
||||
#if 0 /* TBD: Not moved over from Amiga. 1/30/90 */
|
||||
/* TBD: Not an error !!!!!! */
|
||||
SkipErrorMsg(); /* tell dpio not to put an error req. up */
|
||||
#endif
|
||||
return (IFF_DONE);
|
||||
}
|
||||
}
|
||||
#if 0 /* TBD !!!!!!!!!!!!!!!!!!!!!!!!!!!!!! */
|
||||
res = (*animOps[ANIM_GETDLTA])(context, bmHdr, animHdr, frameCnt, buffer, bufsize);
|
||||
#endif /* 0 */
|
||||
|
||||
return (res);
|
||||
#endif /* screen anim */
|
||||
}
|
||||
|
||||
|
||||
IFFP AnimPutDLTAs(context, buffer, bufsize)
|
||||
GroupContext *context;
|
||||
BYTE *buffer;
|
||||
LONG bufsize;
|
||||
{
|
||||
if (isAnimBrIO)
|
||||
return (PutAnBrDLTAs(context, buffer, bufsize));
|
||||
#if 1
|
||||
else
|
||||
return CLIENT_ERROR; /* Not ready to handle Anim yet. */
|
||||
#else
|
||||
else
|
||||
return ((*animOps[ANIM_PUTDLTAS])(context, buffer, bufsize));
|
||||
#endif /* 0 */
|
||||
}
|
||||
|
||||
|
||||
#if 0
|
||||
IFFP AnimIFFDone()
|
||||
{
|
||||
SHORT res = IFF_DONE;
|
||||
|
||||
if (isAnimBrIO)
|
||||
return (AnBrIFFDone());
|
||||
else {
|
||||
if (dpAnimChnk.rate > 0)
|
||||
SetRateFPS(dpAnimChnk.rate);
|
||||
res = (*animOps[ANIM_IFF_DONE])();
|
||||
if (animLoadState == FAIL)
|
||||
AnimLoadFailMsg();
|
||||
return (res);
|
||||
}
|
||||
}
|
||||
|
||||
#endif /* 0 */
|
||||
|
||||
|
||||
#if 0
|
||||
/*------------------------------------------------------------*/
|
||||
/* assume the bitmap the delta applies to is in dbm: read the */
|
||||
/* Delta and apply it to dbm */
|
||||
/*------------------------------------------------------------*/
|
||||
IFFP ReadAndApplyDelta(context, bmHdr, animHdr, dbm, buffer, bufsize)
|
||||
GroupContext *context;
|
||||
BitMapHeader *bmHdr;
|
||||
AnimHdr *animHdr;
|
||||
BITMAP *dbm;
|
||||
UBYTE *buffer;
|
||||
ULONG bufsize;
|
||||
{
|
||||
int i, op, bpr;
|
||||
ULONG iffp = 0;
|
||||
ULONG ploffs[16];
|
||||
ULONG planeSize[8], plast, plOffsSize;
|
||||
SHORT depth = bmHdr->nPlanes;
|
||||
|
||||
op = animHdr->operation;
|
||||
if (op != ANIM_SHORTD && op != ANIM_RIFF && op != ANIM_RUNSKIP) {
|
||||
NotValidAnimMsg();
|
||||
return (IFF_DONE);
|
||||
}
|
||||
plOffsSize = (op == ANIM_SHORTD ? 32 : 64);
|
||||
|
||||
/*--------------------------------------------------------
|
||||
* NOTE: these ploffs are from the beginning of the chunk:
|
||||
* the first one should have a value of 32 for short delta, 64 for riff,
|
||||
* ?4? for ANIM_RUNSKIP.
|
||||
*/
|
||||
iffp = IFFReadBytes(context, (BYTE *) ploffs, plOffsSize);
|
||||
CheckIFFP();
|
||||
|
||||
#ifdef DBGDLTA
|
||||
if (dbgdlta) {
|
||||
printf(" planeOffsets = ");
|
||||
for (i = 0; i < 8; i++)
|
||||
printf(" %d | ", ploffs[i]);
|
||||
printf("\n");
|
||||
}
|
||||
#endif
|
||||
|
||||
/* Compute Size of the compressed planes */
|
||||
/* NOTE: ploffs[i] = 0 means no changes for that plane */
|
||||
|
||||
plast = ChunkMoreBytes(context) + plOffsSize;
|
||||
setmem(planeSize, 8 * sizeof(LONG), 0);
|
||||
for (i = depth - 1; i >= 0; i--) {
|
||||
if (ploffs[i]) {
|
||||
planeSize[i] = plast - ploffs[i];
|
||||
plast = ploffs[i];
|
||||
}
|
||||
}
|
||||
#ifdef DBGDLTA
|
||||
if (dbgdlta) {
|
||||
printf(" planeSize = ");
|
||||
for (i = 0; i < 8; i++)
|
||||
printf(" %d | ", planeSize[i]);
|
||||
printf("\n");
|
||||
}
|
||||
#endif
|
||||
|
||||
|
||||
bpr = dbm->width;
|
||||
for (i = 0; i < depth; i++) {
|
||||
if (planeSize[i] != 0) {
|
||||
/* FOR NOW, ONLY READ PLANE IF IT ALL FITS INTO BUFFER */
|
||||
if (planeSize[i] > bufsize) {
|
||||
#ifdef DBGDLTA
|
||||
InfoMessage("ReadAndApplyDLTA: plane too big", "for buffer"); /* ENGLISH */
|
||||
#endif
|
||||
continue;
|
||||
}
|
||||
iffp = IFFReadBytes(context, buffer, planeSize[i]);
|
||||
if (iffp != IFF_OKAY) {
|
||||
#ifdef DBGDLTA
|
||||
InfoMessage(" ReadBytes error", " in ReadAndApplyDLTA"); /* ENGLISH */
|
||||
#endif
|
||||
return (iffp);
|
||||
}
|
||||
if (i < dbm->planes)
|
||||
switch (op) {
|
||||
case ANIM_SHORTD:
|
||||
DecodeDLTA(dbm->seg[i], buffer);
|
||||
break;
|
||||
case ANIM_RIFF:
|
||||
decode_vkplane(buffer, dbm->seg[i], bpr);
|
||||
break;
|
||||
}
|
||||
}
|
||||
}
|
||||
return (IFF_OKAY);
|
||||
}
|
||||
|
||||
#endif /* 0 */
|
||||
|
||||
|
||||
#if 0
|
||||
/*--------------------------------------------------------------*/
|
||||
/* This Computes the RIFF delta between two bitmaps, abm and */
|
||||
/* bbm, and outputs it to the IFF stream */
|
||||
/*--------------------------------------------------------------*/
|
||||
|
||||
IFFP OutputRiffDelta(context, anhdr, abm, bbm, delbm)
|
||||
GroupContext *context;
|
||||
AnimHdr *anhdr;
|
||||
BITMAP *abm, *bbm; /* two bitmaps to be compared */
|
||||
BITMAP *delbm; /* contains the resulting delta planes */
|
||||
{
|
||||
ULONG sizes[8];
|
||||
IFFP ifferror = 0;
|
||||
int i;
|
||||
SHORT bpr = abm->width;
|
||||
|
||||
for (i = 0; i < abm->planes; i++)
|
||||
sizes[i] = MkRIFF(abm->seg[i], bbm->seg[i], delbm->seg[i],
|
||||
abm->Rows, bpr, bpr);
|
||||
ifferror = WriteDelta(context, anhdr, delbm->seg, sizes);
|
||||
return (ifferror);
|
||||
}
|
||||
|
||||
#endif /* 0 */
|
||||
Reference in New Issue
Block a user