Add bink version 1.0p
This commit is contained in:
parent
4b26993891
commit
48889fcf1d
|
|
@ -0,0 +1,620 @@
|
|||
#ifndef BINKH
|
||||
#define BINKH
|
||||
|
||||
#define BINKVERSION "1.0p"
|
||||
#define BINKDATE "2000-06-26"
|
||||
|
||||
#ifndef __RADRES__
|
||||
|
||||
#include "rad.h"
|
||||
|
||||
RADDEFSTART
|
||||
|
||||
typedef struct BINK PTR4* HBINK;
|
||||
|
||||
typedef s32 (RADLINK PTR4* BINKIOOPEN) (struct BINKIO PTR4* Bnkio, const char PTR4 *name, u32 flags);
|
||||
typedef u32 (RADLINK PTR4* BINKIOREADHEADER) (struct BINKIO PTR4* Bnkio, s32 Offset, void PTR4* Dest,u32 Size);
|
||||
typedef u32 (RADLINK PTR4* BINKIOREADFRAME) (struct BINKIO PTR4* Bnkio, u32 Framenum,s32 origofs,void PTR4* dest,u32 size);
|
||||
typedef u32 (RADLINK PTR4* BINKIOGETBUFFERSIZE)(struct BINKIO PTR4* Bnkio, u32 Size);
|
||||
typedef void (RADLINK PTR4* BINKIOSETINFO) (struct BINKIO PTR4* Bnkio, void PTR4* Buf,u32 Size,u32 FileSize,u32 simulate);
|
||||
typedef u32 (RADLINK PTR4* BINKIOIDLE) (struct BINKIO PTR4* Bnkio);
|
||||
typedef void (RADLINK PTR4* BINKIOCLOSE) (struct BINKIO PTR4* Bnkio);
|
||||
|
||||
typedef struct BINKIO {
|
||||
BINKIOREADHEADER ReadHeader;
|
||||
BINKIOREADFRAME ReadFrame;
|
||||
BINKIOGETBUFFERSIZE GetBufferSize;
|
||||
BINKIOSETINFO SetInfo;
|
||||
BINKIOIDLE Idle;
|
||||
BINKIOCLOSE Close;
|
||||
HBINK bink;
|
||||
volatile u32 ReadError;
|
||||
volatile u32 DoingARead;
|
||||
volatile u32 BytesRead;
|
||||
volatile u32 Working;
|
||||
volatile u32 TotalTime;
|
||||
volatile u32 ForegroundTime;
|
||||
volatile u32 IdleTime;
|
||||
volatile u32 ThreadTime;
|
||||
volatile u32 BufSize;
|
||||
volatile u32 BufHighUsed;
|
||||
volatile u32 CurBufSize;
|
||||
volatile u32 CurBufUsed;
|
||||
volatile u8 iodata[128];
|
||||
} BINKIO;
|
||||
|
||||
typedef s32 (RADLINK PTR4* BINKSNDOPEN) (struct BINKSND PTR4* BnkSnd, u32 freq, s32 bits, s32 chans, u32 flags, HBINK bink);
|
||||
typedef s32 (RADLINK PTR4* BINKSNDREADY) (struct BINKSND PTR4* BnkSnd);
|
||||
typedef s32 (RADLINK PTR4* BINKSNDLOCK) (struct BINKSND PTR4* BnkSnd, u8 PTR4* PTR4* addr, u32 PTR4* len);
|
||||
typedef s32 (RADLINK PTR4* BINKSNDUNLOCK) (struct BINKSND PTR4* BnkSnd, u32 filled);
|
||||
typedef void (RADLINK PTR4* BINKSNDVOLUME) (struct BINKSND PTR4* BnkSnd, s32 volume);
|
||||
typedef void (RADLINK PTR4* BINKSNDPAN) (struct BINKSND PTR4* BnkSnd, s32 pan);
|
||||
typedef s32 (RADLINK PTR4* BINKSNDONOFF) (struct BINKSND PTR4* BnkSnd, s32 status);
|
||||
typedef s32 (RADLINK PTR4* BINKSNDPAUSE) (struct BINKSND PTR4* BnkSnd, s32 status);
|
||||
typedef void (RADLINK PTR4* BINKSNDCLOSE) (struct BINKSND PTR4* BnkSnd);
|
||||
|
||||
typedef BINKSNDOPEN (RADLINK PTR4* BINKSNDSYSOPEN) (u32 param);
|
||||
|
||||
typedef struct BINKSND {
|
||||
BINKSNDREADY Ready;
|
||||
BINKSNDLOCK Lock;
|
||||
BINKSNDUNLOCK Unlock;
|
||||
BINKSNDVOLUME Volume;
|
||||
BINKSNDPAN Pan;
|
||||
BINKSNDPAUSE Pause;
|
||||
BINKSNDONOFF SetOnOff;
|
||||
BINKSNDCLOSE Close;
|
||||
u32 BestSizeIn16;
|
||||
u32 SoundDroppedOut;
|
||||
s32 OnOff;
|
||||
u32 Latency;
|
||||
u32 freq;
|
||||
s32 bits,chans;
|
||||
u8 snddata[128];
|
||||
} BINKSND;
|
||||
|
||||
typedef struct BINKRECT {
|
||||
s32 Left,Top,Width,Height;
|
||||
} BINKRECT;
|
||||
|
||||
#define BINKMAXDIRTYRECTS 8
|
||||
|
||||
typedef struct BUNDLEPOINTERS {
|
||||
void* typeptr;
|
||||
void* type16ptr;
|
||||
void* colorptr;
|
||||
void* bits2ptr;
|
||||
void* motionXptr;
|
||||
void* motionYptr;
|
||||
void* dctptr;
|
||||
void* mdctptr;
|
||||
void* patptr;
|
||||
} BUNDLEPOINTERS;
|
||||
|
||||
|
||||
typedef struct BINK {
|
||||
u32 Width; // Width (1 based, 640 for example)
|
||||
u32 Height; // Height (1 based, 480 for example)
|
||||
u32 Frames; // Number of frames (1 based, 100 = 100 frames)
|
||||
u32 FrameNum; // Frame to *be* displayed (1 based)
|
||||
u32 LastFrameNum; // Last frame decompressed or skipped (1 based)
|
||||
|
||||
u32 FrameRate; // Frame Rate Numerator
|
||||
u32 FrameRateDiv; // Frame Rate Divisor (frame rate=numerator/divisor)
|
||||
|
||||
u32 ReadError; // Non-zero if a read error has ocurred
|
||||
u32 OpenFlags; // flags used on open
|
||||
u32 BinkType; // Bink flags
|
||||
|
||||
u32 Size; // size of file
|
||||
u32 FrameSize; // The current frame's size in bytes
|
||||
u32 SndSize; // The current frame sound tracks' size in bytes
|
||||
|
||||
BINKRECT FrameRects[BINKMAXDIRTYRECTS];// Dirty rects from BinkGetRects
|
||||
s32 NumRects;
|
||||
|
||||
u32 PlaneNum; // which set of planes is current
|
||||
void PTR4* YPlane[2]; // pointer to the uncompressed Y (Cr and Cr follow)
|
||||
void PTR4* APlane[2]; // decompressed alpha plane (if present)
|
||||
u32 YWidth; // widths and heights of the video planes
|
||||
u32 YHeight;
|
||||
u32 UVWidth;
|
||||
u32 UVHeight;
|
||||
|
||||
void PTR4* MaskPlane; // pointer to the mask plane (Ywidth/16*Yheight/16)
|
||||
u32 MaskPitch; // Mask Pitch
|
||||
u32 MaskLength; // total length of the mask plane
|
||||
|
||||
u32 LargestFrameSize; // Largest frame size
|
||||
u32 InternalFrames; // how many frames were potentially compressed
|
||||
|
||||
s32 NumTracks; // how many tracks
|
||||
|
||||
u32 Highest1SecRate; // Highest 1 sec data rate
|
||||
u32 Highest1SecFrame; // Highest 1 sec data rate starting frame
|
||||
|
||||
s32 Paused; // is the bink movie paused?
|
||||
|
||||
u32 BackgroundThread; // handle to background thread
|
||||
|
||||
// everything below is for internal Bink use
|
||||
|
||||
void PTR4* compframe; // compressed frame data
|
||||
void PTR4* preloadptr; // preloaded compressed frame data
|
||||
u32* frameoffsets; // offsets of each of the frames
|
||||
|
||||
BINKIO bio; // IO structure
|
||||
u8 PTR4* ioptr; // io buffer ptr
|
||||
u32 iosize; // io buffer size
|
||||
u32 decompwidth; // width not include scaling
|
||||
u32 decompheight; // height not include scaling
|
||||
|
||||
s32 trackindex; // track index
|
||||
u32 PTR4* tracksizes; // largest single frame of track
|
||||
u32 PTR4* tracktypes; // type of each sound track
|
||||
s32 PTR4* trackIDs; // external track numbers
|
||||
|
||||
u32 numrects; // number of rects from BinkGetRects
|
||||
|
||||
u32 playedframes; // how many frames have we played
|
||||
u32 firstframetime; // very first frame start
|
||||
u32 startframetime; // start frame start
|
||||
u32 startblittime; // start of blit period
|
||||
u32 startsynctime; // start of synched time
|
||||
u32 startsyncframe; // frame of startsynctime
|
||||
u32 twoframestime; // two frames worth of time
|
||||
u32 entireframetime; // entire frame time
|
||||
|
||||
u32 slowestframetime; // slowest frame in ms
|
||||
u32 slowestframe; // slowest frame number
|
||||
u32 slowest2frametime; // second slowest frame in ms
|
||||
u32 slowest2frame; // second slowest frame
|
||||
|
||||
u32 soundon; // sound turned on?
|
||||
u32 videoon; // video turned on?
|
||||
|
||||
u32 totalmem; // total memory used
|
||||
u32 timevdecomp; // total time decompressing video
|
||||
u32 timeadecomp; // total time decompressing audio
|
||||
u32 timeblit; // total time blitting
|
||||
u32 timeopen; // total open time
|
||||
|
||||
u32 fileframerate; // frame rate originally in the file
|
||||
u32 fileframeratediv;
|
||||
|
||||
volatile u32 threadcontrol; // controls the background reading thread
|
||||
|
||||
u32 runtimeframes; // max frames for runtime analysis
|
||||
u32 runtimemoveamt; // bytes to move each frame
|
||||
u32 PTR4* rtframetimes; // start times for runtime frames
|
||||
u32 PTR4* rtadecomptimes; // decompress times for runtime frames
|
||||
u32 PTR4* rtvdecomptimes; // decompress times for runtime frames
|
||||
u32 PTR4* rtblittimes; // blit times for runtime frames
|
||||
u32 PTR4* rtreadtimes; // read times for runtime frames
|
||||
u32 PTR4* rtidlereadtimes; // idle read times for runtime frames
|
||||
u32 PTR4* rtthreadreadtimes;// thread read times for runtime frames
|
||||
|
||||
u32 lastblitflags; // flags used on last blit
|
||||
u32 lastdecompframe; // last frame number decompressed
|
||||
|
||||
u32 sndbufsize; // sound buffer size
|
||||
u8 PTR4* sndbuf; // sound buffer
|
||||
u8 PTR4* sndend; // end of the sound buffer
|
||||
u8 PTR4* sndwritepos; // current write position
|
||||
u8 PTR4* sndreadpos; // current read position
|
||||
u32 sndcomp; // sound compression handle
|
||||
u32 sndamt; // amount of sound currently in the buffer
|
||||
volatile u32 sndreenter; // re-entrancy check on the sound
|
||||
u32 sndconvert8; // convert back to 8-bit sound at runtime
|
||||
BINKSND bsnd; // SND structure
|
||||
u32 skippedlastblit; // skipped last frame?
|
||||
u32 skippedblits; // how many blits were skipped
|
||||
u32 soundskips; // number of sound stops
|
||||
u32 sndendframe; // frame number that the sound ends on
|
||||
u32 sndprime; // amount of data to prime the playahead
|
||||
u32 sndpad; // padded this much audio
|
||||
|
||||
BUNDLEPOINTERS bunp; // pointers to internal temporary memory
|
||||
} BINK;
|
||||
|
||||
|
||||
typedef struct BINKSUMMARY {
|
||||
u32 Width; // Width of frames
|
||||
u32 Height; // Height of frames
|
||||
u32 TotalTime; // total time (ms)
|
||||
u32 FileFrameRate; // frame rate
|
||||
u32 FileFrameRateDiv; // frame rate divisor
|
||||
u32 FrameRate; // frame rate
|
||||
u32 FrameRateDiv; // frame rate divisor
|
||||
u32 TotalOpenTime; // Time to open and prepare for decompression
|
||||
u32 TotalFrames; // Total Frames
|
||||
u32 TotalPlayedFrames; // Total Frames played
|
||||
u32 SkippedFrames; // Total number of skipped frames
|
||||
u32 SkippedBlits; // Total number of skipped blits
|
||||
u32 SoundSkips; // Total number of sound skips
|
||||
u32 TotalBlitTime; // Total time spent blitting
|
||||
u32 TotalReadTime; // Total time spent reading
|
||||
u32 TotalVideoDecompTime; // Total time spent decompressing video
|
||||
u32 TotalAudioDecompTime; // Total time spent decompressing audio
|
||||
u32 TotalIdleReadTime; // Total time spent reading while idle
|
||||
u32 TotalBackReadTime; // Total time spent reading in background
|
||||
u32 TotalReadSpeed; // Total io speed (bytes/second)
|
||||
u32 SlowestFrameTime; // Slowest single frame time (ms)
|
||||
u32 Slowest2FrameTime; // Second slowest single frame time (ms)
|
||||
u32 SlowestFrameNum; // Slowest single frame number
|
||||
u32 Slowest2FrameNum; // Second slowest single frame number
|
||||
u32 AverageDataRate; // Average data rate of the movie
|
||||
u32 AverageFrameSize; // Average size of the frame
|
||||
u32 HighestMemAmount; // Highest amount of memory allocated
|
||||
u32 TotalIOMemory; // Total extra memory allocated
|
||||
u32 HighestIOUsed; // Highest extra memory actually used
|
||||
u32 Highest1SecRate; // Highest 1 second rate
|
||||
u32 Highest1SecFrame; // Highest 1 second start frame
|
||||
} BINKSUMMARY;
|
||||
|
||||
|
||||
typedef struct BINKREALTIME {
|
||||
u32 FrameNum; // Current frame number
|
||||
u32 FrameRate; // frame rate
|
||||
u32 FrameRateDiv; // frame rate divisor
|
||||
u32 Frames; // frames in this sample period
|
||||
u32 FramesTime; // time is ms for these frames
|
||||
u32 FramesVideoDecompTime; // time decompressing these frames
|
||||
u32 FramesAudioDecompTime; // time decompressing these frames
|
||||
u32 FramesReadTime; // time reading these frames
|
||||
u32 FramesIdleReadTime; // time reading these frames at idle
|
||||
u32 FramesThreadReadTime; // time reading these frames in background
|
||||
u32 FramesBlitTime; // time blitting these frames
|
||||
u32 ReadBufferSize; // size of read buffer
|
||||
u32 ReadBufferUsed; // amount of read buffer currently used
|
||||
u32 FramesDataRate; // data rate for these frames
|
||||
} BINKREALTIME;
|
||||
|
||||
#define BINKMARKER1 'fKIB'
|
||||
#define BINKMARKER2 'gKIB' // new Bink files use this tag
|
||||
#define BINKMARKER3 'hKIB' // newer Bink files use this tag
|
||||
#define BINKMARKER4 'iKIB' // even newer Bink files use this tag
|
||||
|
||||
typedef struct BINKHDR {
|
||||
u32 Marker; // Bink marker
|
||||
u32 Size; // size of the file-8
|
||||
u32 Frames; // Number of frames (1 based, 100 = 100 frames)
|
||||
u32 LargestFrameSize; // Size in bytes of largest frame
|
||||
u32 InternalFrames; // Number of internal frames
|
||||
|
||||
u32 Width; // Width (1 based, 640 for example)
|
||||
u32 Height; // Height (1 based, 480 for example)
|
||||
u32 FrameRate; // frame rate
|
||||
u32 FrameRateDiv; // frame rate divisor (framerate/frameratediv=fps)
|
||||
|
||||
u32 Flags; // height compression options
|
||||
u32 NumTracks; // number of tracks
|
||||
} BINKHDR;
|
||||
|
||||
|
||||
//=======================================================================
|
||||
#define BINKFRAMERATE 0x00001000L // Override fr (call BinkFrameRate first)
|
||||
#define BINKPRELOADALL 0x00002000L // Preload the entire animation
|
||||
#define BINKSNDTRACK 0x00004000L // Set the track number to play
|
||||
#define BINKOLDFRAMEFORMAT 0x00008000L // using the old Bink frame format (internal use only)
|
||||
#define BINKRBINVERT 0x00010000L // use reversed R and B planes (internal use only)
|
||||
#define BINKGRAYSCALE 0x00020000L // Force Bink to use grayscale
|
||||
#define BINKNOMMX 0x00040000L // Don't use MMX
|
||||
#define BINKNOSKIP 0x00080000L // Don't skip frames if falling behind
|
||||
#define BINKALPHA 0x00100000L // Decompress alpha plane (if present)
|
||||
#define BINKNOFILLIOBUF 0x00200000L // Fill the IO buffer in SmackOpen
|
||||
#define BINKSIMULATE 0x00400000L // Simulate the speed (call BinkSim first)
|
||||
#define BINKFILEHANDLE 0x00800000L // Use when passing in a file handle
|
||||
#define BINKIOSIZE 0x01000000L // Set an io size (call BinkIOSize first)
|
||||
#define BINKIOPROCESSOR 0x02000000L // Set an io processor (call BinkIO first)
|
||||
#define BINKFROMMEMORY 0x04000000L // Use when passing in a pointer to the file
|
||||
#define BINKNOTHREADEDIO 0x08000000L // Don't use a background thread for IO
|
||||
|
||||
#define BINKSURFACEFAST 0x00000000L
|
||||
#define BINKSURFACESLOW 0x08000000L
|
||||
#define BINKSURFACEDIRECT 0x04000000L
|
||||
|
||||
#define BINKCOPYALL 0x80000000L // copy all pixels (not just changed)
|
||||
#define BINKCOPY2XH 0x10000000L // Force doubling height scaling
|
||||
#define BINKCOPY2XHI 0x20000000L // Force interleaving height scaling
|
||||
#define BINKCOPY2XW 0x30000000L // copy the width zoomed by two
|
||||
#define BINKCOPY2XWH 0x40000000L // copy the width and height zoomed by two
|
||||
#define BINKCOPY2XWHI 0x50000000L // copy the width and height zoomed by two
|
||||
#define BINKCOPY1XI 0x60000000L // copy the width and height zoomed by two
|
||||
#define BINKCOPYNOSCALING 0x70000000L // Force scaling off
|
||||
|
||||
//#define BINKALPHA 0x00100000L // Decompress alpha plane (if present)
|
||||
//#define BINKNOSKIP 0x00080000L // don't skip the blit if behind in sound
|
||||
//#define BINKNOMMX 0x00040000L // Don't skip frames if falling behind
|
||||
//#define BINKGRAYSCALE 0x00020000L // force Bink to use grayscale
|
||||
//#define BINKRBINVERT 0x00010000L // use reversed R and B planes
|
||||
|
||||
#define BINKSURFACE8P 0
|
||||
#define BINKSURFACE24 1
|
||||
#define BINKSURFACE24R 2
|
||||
#define BINKSURFACE32 3
|
||||
#define BINKSURFACE32R 4
|
||||
#define BINKSURFACE32A 5
|
||||
#define BINKSURFACE32RA 6
|
||||
#define BINKSURFACE4444 7
|
||||
#define BINKSURFACE5551 8
|
||||
#define BINKSURFACE555 9
|
||||
#define BINKSURFACE565 10
|
||||
#define BINKSURFACE655 11
|
||||
#define BINKSURFACE664 12
|
||||
#define BINKSURFACEYUY2 13
|
||||
#define BINKSURFACEUYVY 14
|
||||
#define BINKSURFACEYV12 15
|
||||
#define BINKSURFACEMASK 15
|
||||
|
||||
#define BINKGOTOQUICK 1
|
||||
|
||||
#define BINKGETKEYPREVIOUS 0
|
||||
#define BINKGETKEYNEXT 1
|
||||
#define BINKGETKEYCLOSEST 2
|
||||
#define BINKGETKEYNOTEQUAL 128
|
||||
|
||||
//=======================================================================
|
||||
|
||||
#ifdef __RADMAC__
|
||||
#include <files.h>
|
||||
|
||||
#pragma export on
|
||||
|
||||
RADEXPFUNC HBINK RADEXPLINK BinkMacOpen(FSSpec* fsp,u32 flags);
|
||||
#endif
|
||||
|
||||
RADEXPFUNC void PTR4* RADEXPLINK BinkLogoAddress(void);
|
||||
|
||||
RADEXPFUNC void RADEXPLINK BinkSetError(const char PTR4* err);
|
||||
RADEXPFUNC char PTR4* RADEXPLINK BinkGetError(void);
|
||||
|
||||
RADEXPFUNC HBINK RADEXPLINK BinkOpen(const char PTR4* name,u32 flags);
|
||||
|
||||
RADEXPFUNC s32 RADEXPLINK BinkDoFrame(HBINK bnk);
|
||||
RADEXPFUNC void RADEXPLINK BinkNextFrame(HBINK bnk);
|
||||
RADEXPFUNC s32 RADEXPLINK BinkWait(HBINK bnk);
|
||||
RADEXPFUNC void RADEXPLINK BinkClose(HBINK bnk);
|
||||
RADEXPFUNC s32 RADEXPLINK BinkPause(HBINK bnk,s32 pause);
|
||||
RADEXPFUNC s32 RADEXPLINK BinkCopyToBuffer(HBINK bnk,void* dest,s32 destpitch,u32 destheight,u32 destx,u32 desty,u32 flags);
|
||||
RADEXPFUNC s32 RADEXPLINK BinkGetRects(HBINK bnk,u32 flags);
|
||||
RADEXPFUNC void RADEXPLINK BinkGoto(HBINK bnk,u32 frame,s32 flags); // use 1 for the first frame
|
||||
RADEXPFUNC u32 RADEXPLINK BinkGetKeyFrame(HBINK bnk,u32 frame,s32 flags);
|
||||
|
||||
RADEXPFUNC s32 RADEXPLINK BinkSetVideoOnOff(HBINK bnk,s32 onoff);
|
||||
RADEXPFUNC s32 RADEXPLINK BinkSetSoundOnOff(HBINK bnk,s32 onoff);
|
||||
RADEXPFUNC void RADEXPLINK BinkSetVolume(HBINK bnk,s32 volume);
|
||||
RADEXPFUNC void RADEXPLINK BinkSetPan(HBINK bnk,s32 pan);
|
||||
RADEXPFUNC void RADEXPLINK BinkService(HBINK bink);
|
||||
|
||||
typedef struct BINKTRACK PTR4* HBINKTRACK;
|
||||
|
||||
typedef struct BINKTRACK
|
||||
{
|
||||
u32 Frequency;
|
||||
u32 Bits;
|
||||
u32 Channels;
|
||||
u32 MaxSize;
|
||||
|
||||
HBINK bink;
|
||||
u32 sndcomp;
|
||||
s32 trackindex;
|
||||
} BINKTRACK;
|
||||
|
||||
|
||||
RADEXPFUNC HBINKTRACK RADEXPLINK BinkOpenTrack(HBINK bnk,u32 trackindex);
|
||||
RADEXPFUNC void RADEXPLINK BinkCloseTrack(HBINKTRACK bnkt);
|
||||
RADEXPFUNC u32 RADEXPLINK BinkGetTrackData(HBINKTRACK bnkt,void PTR4* dest);
|
||||
|
||||
RADEXPFUNC u32 RADEXPLINK BinkGetTrackType(HBINK bnk,u32 trackindex);
|
||||
RADEXPFUNC u32 RADEXPLINK BinkGetTrackMaxSize(HBINK bnk,u32 trackindex);
|
||||
RADEXPFUNC u32 RADEXPLINK BinkGetTrackID(HBINK bnk,u32 trackindex);
|
||||
RADEXPFUNC u32 RADEXPLINK BinkGetTrackLargest(HBINK bnk,u32 trackindex);
|
||||
|
||||
RADEXPFUNC void RADEXPLINK BinkGetSummary(HBINK bnk,BINKSUMMARY PTR4* sum);
|
||||
RADEXPFUNC void RADEXPLINK BinkGetRealtime(HBINK bink,BINKREALTIME PTR4* run,u32 frames);
|
||||
|
||||
#define BINKNOSOUND 0xffffffff
|
||||
|
||||
RADEXPFUNC void RADEXPLINK BinkSetSoundTrack(u32 track);
|
||||
RADEXPFUNC void RADEXPLINK BinkSetIO(BINKIOOPEN io);
|
||||
RADEXPFUNC void RADEXPLINK BinkSetFrameRate(u32 forcerate,u32 forceratediv);
|
||||
RADEXPFUNC void RADEXPLINK BinkSetSimulate(u32 sim);
|
||||
RADEXPFUNC void RADEXPLINK BinkSetIOSize(u32 iosize);
|
||||
|
||||
RADEXPFUNC s32 RADEXPLINK BinkSetSoundSystem(BINKSNDSYSOPEN open, u32 param);
|
||||
|
||||
#ifdef __RADWIN__
|
||||
|
||||
RADEXPFUNC BINKSNDOPEN RADEXPLINK BinkOpenDirectSound(u32 param); // don't call directly
|
||||
#define BinkSoundUseDirectSound(lpDS) BinkSetSoundSystem(BinkOpenDirectSound,(u32)lpDS)
|
||||
|
||||
RADEXPFUNC BINKSNDOPEN RADEXPLINK BinkOpenWaveOut(u32 param); // don't call directly
|
||||
#define BinkSoundUseWaveOut() BinkSetSoundSystem(BinkOpenWaveOut,0)
|
||||
|
||||
#define INCLUDE_MMSYSTEM_H
|
||||
#include "windows.h"
|
||||
#include "windowsx.h"
|
||||
|
||||
#ifdef __RADNT__ // to combat WIN32_LEAN_AND_MEAN
|
||||
#include "mmsystem.h"
|
||||
#endif
|
||||
|
||||
#endif
|
||||
|
||||
|
||||
#ifndef __RADMAC__
|
||||
|
||||
RADEXPFUNC BINKSNDOPEN RADEXPLINK BinkOpenMiles(u32 param); // don't call directly
|
||||
#define BinkSoundUseMiles(hdigdriver) BinkSetSoundSystem(BinkOpenMiles,(u32)hdigdriver)
|
||||
|
||||
#endif
|
||||
|
||||
|
||||
#ifdef __RADMAC__
|
||||
|
||||
RADEXPFUNC BINKSNDOPEN RADEXPLINK BinkOpenSoundManager(u32 param); // don't call directly
|
||||
#define BinkSoundUseSoundManager() BinkSetSoundSystem(BinkOpenSoundManager,0)
|
||||
|
||||
#endif
|
||||
|
||||
|
||||
// The BinkBuffer API isn't currently implemented on DOS
|
||||
#if !defined(__RADDOS__)
|
||||
|
||||
//=========================================================================
|
||||
typedef struct BINKBUFFER * HBINKBUFFER;
|
||||
|
||||
#define BINKBUFFERSTRETCHXINT 0x80000000
|
||||
#define BINKBUFFERSTRETCHX 0x40000000
|
||||
#define BINKBUFFERSHRINKXINT 0x20000000
|
||||
#define BINKBUFFERSHRINKX 0x10000000
|
||||
#define BINKBUFFERSTRETCHYINT 0x08000000
|
||||
#define BINKBUFFERSTRETCHY 0x04000000
|
||||
#define BINKBUFFERSHRINKYINT 0x02000000
|
||||
#define BINKBUFFERSHRINKY 0x01000000
|
||||
#define BINKBUFFERSCALES 0xff000000
|
||||
#define BINKBUFFERRESOLUTION 0x00800000
|
||||
|
||||
#ifdef __RADMAC__
|
||||
|
||||
#include <windows.h>
|
||||
#include <palettes.h>
|
||||
#include <qdoffscreen.h>
|
||||
|
||||
typedef struct BINKBUFFER {
|
||||
u32 Width;
|
||||
u32 Height;
|
||||
u32 WindowWidth;
|
||||
u32 WindowHeight;
|
||||
u32 SurfaceType;
|
||||
void* Buffer;
|
||||
s32 BufferPitch;
|
||||
u32 ScreenWidth;
|
||||
u32 ScreenHeight;
|
||||
u32 ScreenDepth;
|
||||
u32 ScaleFlags;
|
||||
|
||||
s32 destx,desty;
|
||||
s32 wndx,wndy;
|
||||
u32 wnd;
|
||||
|
||||
s32 noclipping;
|
||||
u32 type;
|
||||
s32 issoftcur;
|
||||
u32 cursorcount;
|
||||
|
||||
} BINKBUFFER;
|
||||
|
||||
|
||||
#define BINKBUFFERAUTO 0
|
||||
#define BINKBUFFERDIRECT 1
|
||||
#define BINKBUFFERGWORLD 2
|
||||
#define BINKBUFFERTYPEMASK 31
|
||||
|
||||
RADEXPFUNC HBINKBUFFER RADEXPLINK BinkBufferOpen( WindowPtr wnd, u32 width, u32 height, u32 bufferflags);
|
||||
RADEXPFUNC s32 RADEXPLINK BinkGDSurfaceType( GDHandle gd );
|
||||
RADEXPFUNC s32 RADEXPLINK BinkIsSoftwareCursor(GDHandle gd);
|
||||
RADEXPFUNC s32 RADEXPLINK BinkCheckCursor(WindowPtr wp,s32 x,s32 y,s32 w,s32 h);
|
||||
|
||||
#else
|
||||
|
||||
typedef struct BINKBUFFER {
|
||||
u32 Width;
|
||||
u32 Height;
|
||||
u32 WindowWidth;
|
||||
u32 WindowHeight;
|
||||
u32 SurfaceType;
|
||||
void* Buffer;
|
||||
s32 BufferPitch;
|
||||
s32 ClientOffsetX;
|
||||
s32 ClientOffsetY;
|
||||
u32 ScreenWidth;
|
||||
u32 ScreenHeight;
|
||||
u32 ScreenDepth;
|
||||
u32 ExtraWindowWidth;
|
||||
u32 ExtraWindowHeight;
|
||||
u32 ScaleFlags;
|
||||
u32 StretchWidth;
|
||||
u32 StretchHeight;
|
||||
|
||||
s32 surface;
|
||||
void* ddsurface;
|
||||
void* ddclipper;
|
||||
s32 destx,desty;
|
||||
s32 wndx,wndy;
|
||||
u32 wnd;
|
||||
s32 ddoverlay;
|
||||
s32 ddoffscreen;
|
||||
s32 lastovershow;
|
||||
|
||||
s32 issoftcur;
|
||||
u32 cursorcount;
|
||||
void* buffertop;
|
||||
u32 type;
|
||||
s32 noclipping;
|
||||
|
||||
s32 loadeddd;
|
||||
s32 loadedwin;
|
||||
|
||||
void* dibh;
|
||||
void* dibbuffer;
|
||||
s32 dibpitch;
|
||||
void* dibinfo;
|
||||
u32 dibdc;
|
||||
u32 diboldbitmap;
|
||||
|
||||
} BINKBUFFER;
|
||||
|
||||
|
||||
#define BINKBUFFERAUTO 0
|
||||
#define BINKBUFFERPRIMARY 1
|
||||
#define BINKBUFFERDIBSECTION 2
|
||||
#define BINKBUFFERYV12OVERLAY 3
|
||||
#define BINKBUFFERYUY2OVERLAY 4
|
||||
#define BINKBUFFERUYVYOVERLAY 5
|
||||
#define BINKBUFFERYV12OFFSCREEN 6
|
||||
#define BINKBUFFERYUY2OFFSCREEN 7
|
||||
#define BINKBUFFERUYVYOFFSCREEN 8
|
||||
#define BINKBUFFERRGBOFFSCREENVIDEO 9
|
||||
#define BINKBUFFERRGBOFFSCREENSYSTEM 10
|
||||
#define BINKBUFFERLAST 10
|
||||
#define BINKBUFFERTYPEMASK 31
|
||||
|
||||
RADEXPFUNC HBINKBUFFER RADEXPLINK BinkBufferOpen( HWND wnd, u32 width, u32 height, u32 bufferflags);
|
||||
RADEXPFUNC s32 RADEXPLINK BinkBufferSetHWND( HBINKBUFFER buf, HWND newwnd);
|
||||
RADEXPFUNC s32 RADEXPLINK BinkDDSurfaceType(void PTR4* lpDDS);
|
||||
RADEXPFUNC s32 RADEXPLINK BinkIsSoftwareCursor(void PTR4* lpDDSP,HCURSOR cur);
|
||||
RADEXPFUNC s32 RADEXPLINK BinkCheckCursor(HWND wnd,s32 x,s32 y,s32 w,s32 h);
|
||||
RADEXPFUNC s32 RADEXPLINK BinkBufferSetDirectDraw(void PTR4* lpDirectDraw, void PTR4* lpPrimary);
|
||||
|
||||
#endif
|
||||
|
||||
RADEXPFUNC void RADEXPLINK BinkBufferClose( HBINKBUFFER buf);
|
||||
RADEXPFUNC s32 RADEXPLINK BinkBufferLock( HBINKBUFFER buf);
|
||||
RADEXPFUNC s32 RADEXPLINK BinkBufferUnlock( HBINKBUFFER buf);
|
||||
RADEXPFUNC void RADEXPLINK BinkBufferSetResolution( s32 w, s32 h, s32 bits);
|
||||
RADEXPFUNC void RADEXPLINK BinkBufferCheckWinPos( HBINKBUFFER buf, s32 PTR4* NewWindowX, s32 PTR4* NewWindowY);
|
||||
RADEXPFUNC s32 RADEXPLINK BinkBufferSetOffset( HBINKBUFFER buf, s32 destx, s32 desty);
|
||||
RADEXPFUNC void RADEXPLINK BinkBufferBlit( HBINKBUFFER buf, BINKRECT PTR4* rects, u32 numrects );
|
||||
RADEXPFUNC s32 RADEXPLINK BinkBufferSetScale( HBINKBUFFER buf, u32 w, u32 h);
|
||||
RADEXPFUNC char PTR4* RADEXPLINK BinkBufferGetDescription( HBINKBUFFER buf);
|
||||
RADEXPFUNC char PTR4* RADEXPLINK BinkBufferGetError();
|
||||
RADEXPFUNC s32 RADEXPLINK BinkBufferClear(HBINKBUFFER buf, u32 RGB);
|
||||
|
||||
RADEXPFUNC void RADEXPLINK BinkRestoreCursor(s32 checkcount);
|
||||
|
||||
#endif
|
||||
|
||||
#ifdef __RADMAC__
|
||||
|
||||
#pragma export off
|
||||
|
||||
#endif
|
||||
|
||||
RADDEFEND
|
||||
|
||||
#endif
|
||||
|
||||
#endif
|
||||
|
||||
Binary file not shown.
|
|
@ -0,0 +1,962 @@
|
|||
#ifndef __RAD__
|
||||
#define __RAD__
|
||||
|
||||
#define RADCOPYRIGHT "Copyright (C) 1994-2000, RAD Game Tools, Inc."
|
||||
|
||||
#ifndef __RADRES__
|
||||
|
||||
// __RAD16__ means 16 bit code (Win16)
|
||||
// __RAD32__ means 32 bit code (DOS, Win386, Win32s, Mac)
|
||||
|
||||
// __RADDOS__ means DOS code (16 or 32 bit)
|
||||
// __RADWIN__ means Windows code (Win16, Win386, Win32s)
|
||||
// __RADWINEXT__ means Windows 386 extender (Win386)
|
||||
// __RADNT__ means Win32s code
|
||||
// __RADMAC__ means Macintosh
|
||||
|
||||
// __RADX86__ means Intel x86
|
||||
// __RADMMX__ means Intel x86 MMX instructions are allowed
|
||||
// __RAD68K__ means 68K
|
||||
// __RADPPC__ means PowerPC
|
||||
|
||||
// __RADLITTLEENDIAN__ means processor is little-endian (x86)
|
||||
// __RADBIGENDIAN__ means processor is big-endian (680x0, PPC)
|
||||
|
||||
// __RADALLOWINLINES__ means this compiler allows inline function declarations
|
||||
// use RADINLINE for the appropriate keyword
|
||||
|
||||
|
||||
#if (defined(__MWERKS__) && !defined(__INTEL__)) || defined(__MRC__) || defined(THINK_C) || defined(powerc) || defined(macintosh) || defined(__powerc)
|
||||
|
||||
#define __RADMAC__
|
||||
#if defined(powerc) || defined(__powerc)
|
||||
#define __RADPPC__
|
||||
#else
|
||||
#define __RAD68K__
|
||||
#endif
|
||||
|
||||
#define __RAD32__
|
||||
|
||||
#define __RADBIGENDIAN__
|
||||
|
||||
#if defined(__MWERKS__)
|
||||
#if (defined(__cplusplus) || ! __option(only_std_keywords))
|
||||
#define __RADALLOWINLINES__
|
||||
#define RADINLINE inline
|
||||
#endif
|
||||
#elif defined(__MRC__)
|
||||
#if defined(__cplusplus)
|
||||
#define __RADALLOWINLINES__
|
||||
#define RADINLINE inline
|
||||
#endif
|
||||
#endif
|
||||
|
||||
#else
|
||||
|
||||
#define __RADX86__
|
||||
#define __RADMMX__
|
||||
|
||||
#ifdef __MWERKS__
|
||||
#define _WIN32
|
||||
#endif
|
||||
|
||||
#ifdef __DOS__
|
||||
#define __RADDOS__
|
||||
#endif
|
||||
|
||||
#ifdef __386__
|
||||
#define __RAD32__
|
||||
#endif
|
||||
|
||||
#ifdef _Windows //For Borland
|
||||
#ifdef __WIN32__
|
||||
#define WIN32
|
||||
#else
|
||||
#define __WINDOWS__
|
||||
#endif
|
||||
#endif
|
||||
|
||||
#ifdef _WINDOWS //For MS
|
||||
#ifndef _WIN32
|
||||
#define __WINDOWS__
|
||||
#endif
|
||||
#endif
|
||||
|
||||
#ifdef _WIN32
|
||||
#define __RADWIN__
|
||||
#define __RADNT__
|
||||
#define __RAD32__
|
||||
#else
|
||||
#ifdef __NT__
|
||||
#define __RADWIN__
|
||||
#define __RADNT__
|
||||
#define __RAD32__
|
||||
#else
|
||||
#ifdef __WINDOWS_386__
|
||||
#define __RADWIN__
|
||||
#define __RADWINEXT__
|
||||
#define __RAD32__
|
||||
#else
|
||||
#ifdef __WINDOWS__
|
||||
#define __RADWIN__
|
||||
#define __RAD16__
|
||||
#else
|
||||
#ifdef WIN32
|
||||
#define __RADWIN__
|
||||
#define __RADNT__
|
||||
#define __RAD32__
|
||||
#endif
|
||||
#endif
|
||||
#endif
|
||||
#endif
|
||||
#endif
|
||||
|
||||
#define __RADLITTLEENDIAN__
|
||||
|
||||
// TODO - make sure these are set correctly for non-Mac versions
|
||||
#define __RADALLOWINLINES__
|
||||
#define RADINLINE __inline
|
||||
|
||||
#endif
|
||||
|
||||
#ifndef __RADALLOWINLINES__
|
||||
#define RADINLINE
|
||||
#endif
|
||||
|
||||
#if (!defined(__RADDOS__) && !defined(__RADWIN__) && !defined(__RADMAC__))
|
||||
#error RAD.H did not detect your platform. Define __DOS__, __WINDOWS__, WIN32, macintosh, or powerc.
|
||||
#endif
|
||||
|
||||
#ifdef __RADMAC__
|
||||
|
||||
// this define is for CodeWarrior 11's stupid new libs (even though
|
||||
// we don't use longlong's).
|
||||
|
||||
#define __MSL_LONGLONG_SUPPORT__
|
||||
|
||||
#define RADLINK
|
||||
#define RADEXPLINK
|
||||
|
||||
#ifdef __CFM68K__
|
||||
#ifdef __RADINDLL__
|
||||
#define RADEXPFUNC RADDEFFUNC __declspec(export)
|
||||
#else
|
||||
#define RADEXPFUNC RADDEFFUNC __declspec(import)
|
||||
#endif
|
||||
#else
|
||||
#define RADEXPFUNC RADDEFFUNC
|
||||
#endif
|
||||
#define RADASMLINK
|
||||
|
||||
#else
|
||||
|
||||
#ifdef __RADNT__
|
||||
#ifndef _WIN32
|
||||
#define _WIN32
|
||||
#endif
|
||||
#ifndef WIN32
|
||||
#define WIN32
|
||||
#endif
|
||||
#endif
|
||||
|
||||
#ifdef __RADWIN__
|
||||
#ifdef __RAD32__
|
||||
#ifdef __RADNT__
|
||||
|
||||
#define RADLINK __stdcall
|
||||
#define RADEXPLINK __stdcall
|
||||
|
||||
#ifdef __RADINEXE__
|
||||
#define RADEXPFUNC RADDEFFUNC
|
||||
#else
|
||||
#ifndef __RADINDLL__
|
||||
#define RADEXPFUNC RADDEFFUNC __declspec(dllimport)
|
||||
#ifdef __BORLANDC__
|
||||
#if __BORLANDC__<=0x460
|
||||
#undef RADEXPFUNC
|
||||
#define RADEXPFUNC RADDEFFUNC
|
||||
#endif
|
||||
#endif
|
||||
#else
|
||||
#define RADEXPFUNC RADDEFFUNC __declspec(dllexport)
|
||||
#endif
|
||||
#endif
|
||||
#else
|
||||
#define RADLINK __pascal
|
||||
#define RADEXPLINK __far __pascal
|
||||
#define RADEXPFUNC RADDEFFUNC
|
||||
#endif
|
||||
#else
|
||||
#define RADLINK __pascal
|
||||
#define RADEXPLINK __far __pascal __export
|
||||
#define RADEXPFUNC RADDEFFUNC
|
||||
#endif
|
||||
#else
|
||||
#define RADLINK __pascal
|
||||
#define RADEXPLINK __pascal
|
||||
#define RADEXPFUNC RADDEFFUNC
|
||||
#endif
|
||||
|
||||
#define RADASMLINK __cdecl
|
||||
|
||||
#endif
|
||||
|
||||
#ifdef __RADWIN__
|
||||
#ifndef _WINDOWS
|
||||
#define _WINDOWS
|
||||
#endif
|
||||
#endif
|
||||
|
||||
#ifdef __cplusplus
|
||||
#define RADDEFFUNC extern "C"
|
||||
#define RADDEFSTART extern "C" {
|
||||
#define RADDEFEND }
|
||||
#else
|
||||
#define RADDEFFUNC
|
||||
#define RADDEFSTART
|
||||
#define RADDEFEND
|
||||
#endif
|
||||
|
||||
|
||||
RADDEFSTART
|
||||
|
||||
#define s8 signed char
|
||||
#define u8 unsigned char
|
||||
#define u32 unsigned long
|
||||
#define s32 signed long
|
||||
#define f32 float
|
||||
#define f64 double
|
||||
|
||||
#if defined(__MWERKS__) || defined(__MRC__)
|
||||
#define u64 unsigned long long
|
||||
#define s64 signed long long
|
||||
#else
|
||||
#define u64 unsigned __int64
|
||||
#define s64 signed __int64
|
||||
#endif
|
||||
|
||||
/* 32 bit implementations */
|
||||
|
||||
#ifdef __RAD32__
|
||||
#define PTR4
|
||||
|
||||
#define u16 unsigned short
|
||||
#define s16 signed short
|
||||
|
||||
#ifdef __RADMAC__
|
||||
|
||||
#include <string.h>
|
||||
#include <MacTypes.h>
|
||||
#include <Memory.h>
|
||||
#include <OSUtils.h>
|
||||
#ifdef __MRC__
|
||||
#include "intrinsics.h"
|
||||
#endif
|
||||
|
||||
void radconv32a(void* p, u32 n);
|
||||
|
||||
u32 radloadu32(u32 a);
|
||||
|
||||
u32 radloadu32ptr(u32* p);
|
||||
|
||||
#define radstrcpy strcpy
|
||||
|
||||
#define radstrcat strcat
|
||||
|
||||
#define radmemcpy(dest,source,size) BlockMoveData((Ptr)(source),(Ptr)(dest),size)
|
||||
|
||||
#define radmemcpydb(dest,source,size) BlockMoveData((Ptr)(source),(Ptr)(dest),size)
|
||||
|
||||
#define radmemcmp memcmp
|
||||
|
||||
#define radmemset memset
|
||||
|
||||
#define radstrlen strlen
|
||||
|
||||
#define radstrchr strchr
|
||||
|
||||
#define radtoupper toupper
|
||||
|
||||
#define radstru32(s) ((u32)atol(s))
|
||||
|
||||
//s8 radstricmp(const void* s1,const void* s2);
|
||||
|
||||
#define radstrcmp strcmp
|
||||
|
||||
//char* radstrupr(void* s1);
|
||||
|
||||
//char* radstrlwr(void* s1);
|
||||
|
||||
u32 radsqr(u32 a);
|
||||
|
||||
u32 mult64anddiv(u32 m1,u32 m2,u32 d);
|
||||
|
||||
s32 radabs(s32 ab);
|
||||
|
||||
#define radabs32 radabs
|
||||
|
||||
//char* radstpcpy(void* dest,const void* source);
|
||||
|
||||
//char* radstpcpyrs(void* dest,const void* source);
|
||||
|
||||
void radmemset16(void* dest,u16 value,u32 size);
|
||||
|
||||
//void radmemset32(void* dest,u32 value,u32 size);
|
||||
|
||||
#define BreakPoint() DebugStr("\pBreakPoint() was called")
|
||||
|
||||
//u8 radinp(u16 p);
|
||||
|
||||
//void radoutp(u16 p,u8 v);
|
||||
|
||||
//u32 RADsqrt(u32 sq);
|
||||
|
||||
u32 RADCycleTimerAvail(void);
|
||||
|
||||
void RADCycleTimerStartAddr(u32* addr);
|
||||
|
||||
u32 RADCycleTimerDeltaAddr(u32* addr);
|
||||
|
||||
void RADCycleTimerStartAddr64(u64* addr);
|
||||
|
||||
void RADCycleTimerDeltaAddr64(u64* addr);
|
||||
|
||||
#define RADCycleTimerStart(var) RADCycleTimerStartAddr(&var)
|
||||
|
||||
#define RADCycleTimerDelta(var) RADCycleTimerDeltaAddr(&var)
|
||||
|
||||
#define RADCycleTimerStart64(var) RADCycleTimerStartAddr64(&var)
|
||||
|
||||
#define RADCycleTimerDelta64(var) RADCycleTimerDeltaAddr64(&var)
|
||||
|
||||
|
||||
#ifdef __RAD68K__
|
||||
#pragma parameter radconv32a(__A0,__D0)
|
||||
void radconv32a(void* p,u32 n) ={0x4A80,0x600C,0x2210,0xE059,0x4841,0xE059,0x20C1,0x5380,0x6EF2};
|
||||
// tst.l d0 bra.s @loope @loop: move.l (a0),d1 ror.w #8,d1 swap d1 ror.w #8,d1 move.l d1,(a0)+ sub.l #1,d0 bgt.s @loop @loope:
|
||||
#endif
|
||||
|
||||
#ifdef __RADALLOWINLINES__
|
||||
#if defined __RADPPC__ && defined(__MWERKS__) && (__MWERKS__ >= 0x2301) && 0
|
||||
u32 RADINLINE radloadu32(register u32 x) {
|
||||
register u32 t1, t2;
|
||||
asm { // x = aa bb cc dd
|
||||
rlwinm t1,x,24,0,23 // t1 = dd aa bb 00
|
||||
rlwinm t2,x,8,24,31 // t2 = 00 00 00 aa
|
||||
rlwimi t1,x,8, 8,15 // t1 = dd cc bb 00
|
||||
or x,t1,t2 // x = dd cc bb aa
|
||||
}
|
||||
return x;
|
||||
}
|
||||
#else
|
||||
u32 RADINLINE radloadu32(register u32 x) {
|
||||
return (((x << 24) & 0xFF000000) |
|
||||
((x << 8) & 0x00FF0000) |
|
||||
((x >> 8) & 0x0000FF00) |
|
||||
((x >> 24) & 0x000000FF));
|
||||
}
|
||||
#endif
|
||||
#endif
|
||||
|
||||
#if defined(__RADPPC__) && (defined(__MWERKS__) || defined(__MRC__))
|
||||
#define radloadu32ptr(p) (u32) __lwbrx((p),0)
|
||||
#else
|
||||
#define radloadu32ptr(p) radloadu32(*(u32*)(p));
|
||||
#endif
|
||||
|
||||
#ifdef __RADALLOWINLINES__
|
||||
u32 RADINLINE radsqr(u32 a) { return(a*a); }
|
||||
#endif
|
||||
|
||||
#ifdef __RAD68K__
|
||||
#pragma parameter __D0 mult64anddiv(__D0,__D1,__D2)
|
||||
u32 mult64anddiv(u32 m1,u32 m2,u32 d) ={0x4C01,0x0C01,0x4C42,0x0C01};
|
||||
// muls.l d1,d1:d0 divs.l d2,d1:d0
|
||||
#endif
|
||||
|
||||
#if defined(__RADPPC__) && (defined(__MWERKS__) || defined(__MRC__))
|
||||
#define radabs(ab) __abs((s32)(ab))
|
||||
#elif defined(__RADALLOWINLINES__)
|
||||
s32 RADINLINE radabs(s32 ab) { return (ab < 0) ? -ab : ab; }
|
||||
#endif
|
||||
|
||||
#else
|
||||
|
||||
#define radconv32a(p,n) ((void)0)
|
||||
|
||||
#define radloadu32(a) ((u32)(a))
|
||||
|
||||
#define radloadu32ptr(p) *((u32*)(p))
|
||||
|
||||
#ifdef __WATCOMC__
|
||||
|
||||
u32 radsqr(s32 a);
|
||||
#pragma aux radsqr = "mul eax" parm [eax] modify [EDX eax];
|
||||
|
||||
u32 mult64anddiv(u32 m1,u32 m2,u32 d);
|
||||
#pragma aux mult64anddiv = "mul ecx" "div ebx" parm [eax] [ecx] [ebx] modify [EDX eax];
|
||||
|
||||
s32 radabs(s32 ab);
|
||||
#pragma aux radabs = "test eax,eax" "jge skip" "neg eax" "skip:" parm [eax];
|
||||
|
||||
#define radabs32 radabs
|
||||
|
||||
u32 DOSOut(const char* str);
|
||||
#pragma aux DOSOut = "cld" "mov ecx,0xffffffff" "xor eax,eax" "mov edx,edi" "repne scasb" "not ecx" "dec ecx" "mov ebx,1" "mov ah,0x40" "int 0x21" parm [EDI] modify [EAX EBX ECX EDX EDI] value [ecx];
|
||||
|
||||
void DOSOutNum(const char* str,u32 len);
|
||||
#pragma aux DOSOutNum = "mov ah,0x40" "mov ebx,1" "int 0x21" parm [edx] [ecx] modify [eax ebx];
|
||||
|
||||
u32 ErrOut(const char* str);
|
||||
#pragma aux ErrOut = "cld" "mov ecx,0xffffffff" "xor eax,eax" "mov edx,edi" "repne scasb" "not ecx" "dec ecx" "xor ebx,ebx" "mov ah,0x40" "int 0x21" parm [EDI] modify [EAX EBX ECX EDX EDI] value [ecx];
|
||||
|
||||
void ErrOutNum(const char* str,u32 len);
|
||||
#pragma aux ErrOutNum = "mov ah,0x40" "xor ebx,ebx" "int 0x21" parm [edx] [ecx] modify [eax ebx];
|
||||
|
||||
void radmemset16(void* dest,u16 value,u32 size);
|
||||
#pragma aux radmemset16 = "cld" "mov bx,ax" "shl eax,16" "mov ax,bx" "mov bl,cl" "shr ecx,1" "rep stosd" "mov cl,bl" "and cl,1" "rep stosw" parm [EDI] [EAX] [ECX] modify [EAX EDX EBX ECX EDI];
|
||||
|
||||
void radmemset(void* dest,u8 value,u32 size);
|
||||
#pragma aux radmemset = "cld" "mov ah,al" "mov bx,ax" "shl eax,16" "mov ax,bx" "mov bl,cl" "shr ecx,2" "and bl,3" "rep stosd" "mov cl,bl" "rep stosb" parm [EDI] [AL] [ECX] modify [EAX EDX EBX ECX EDI];
|
||||
|
||||
void radmemset32(void* dest,u32 value,u32 size);
|
||||
#pragma aux radmemset32 = "cld" "rep stosd" parm [EDI] [EAX] [ECX] modify [EAX EDX EBX ECX EDI];
|
||||
|
||||
void radmemcpy(void* dest,const void* source,u32 size);
|
||||
#pragma aux radmemcpy = "cld" "mov bl,cl" "shr ecx,2" "rep movsd" "mov cl,bl" "and cl,3" "rep movsb" parm [EDI] [ESI] [ECX] modify [EBX ECX EDI ESI];
|
||||
|
||||
void __far *radfmemcpy(void __far* dest,const void __far* source,u32 size);
|
||||
#pragma aux radfmemcpy = "cld" "push es" "push ds" "mov es,cx" "mov ds,dx" "mov ecx,eax" "shr ecx,2" "rep movsd" "mov cl,al" "and cl,3" "rep movsb" "pop ds" "pop es" parm [CX EDI] [DX ESI] [EAX] modify [ECX EDI ESI] value [CX EDI];
|
||||
|
||||
void radmemcpydb(void* dest,const void* source,u32 size); //Destination bigger
|
||||
#pragma aux radmemcpydb = "std" "mov bl,cl" "lea esi,[esi+ecx-4]" "lea edi,[edi+ecx-4]" "shr ecx,2" "rep movsd" "and bl,3" "jz dne" "add esi,3" "add edi,3" "mov cl,bl" "rep movsb" "dne:" "cld" parm [EDI] [ESI] [ECX] modify [EBX ECX EDI ESI];
|
||||
|
||||
char* radstrcpy(void* dest,const void* source);
|
||||
#pragma aux radstrcpy = "cld" "mov edx,edi" "lp:" "mov al,[esi]" "inc esi" "mov [edi],al" "inc edi" "cmp al,0" "jne lp" parm [EDI] [ESI] modify [EAX EDX EDI ESI] value [EDX];
|
||||
|
||||
char __far* radfstrcpy(void __far* dest,const void __far* source);
|
||||
#pragma aux radfstrcpy = "cld" "push es" "push ds" "mov es,cx" "mov ds,dx" "mov edx,edi" "lp:" "lodsb" "stosb" "test al,0xff" "jnz lp" "pop ds" "pop es" parm [CX EDI] [DX ESI] modify [EAX EDX EDI ESI] value [CX EDX];
|
||||
|
||||
char* radstpcpy(void* dest,const void* source);
|
||||
#pragma aux radstpcpy = "cld" "lp:" "mov al,[esi]" "inc esi" "mov [edi],al" "inc edi" "cmp al,0" "jne lp" "dec edi" parm [EDI] [ESI] modify [EAX EDI ESI] value [EDI];
|
||||
|
||||
char* radstpcpyrs(void* dest,const void* source);
|
||||
#pragma aux radstpcpyrs = "cld" "lp:" "mov al,[esi]" "inc esi" "mov [edi],al" "inc edi" "cmp al,0" "jne lp" "dec esi" parm [EDI] [ESI] modify [EAX EDI ESI] value [ESI];
|
||||
|
||||
u32 radstrlen(const void* dest);
|
||||
#pragma aux radstrlen = "cld" "mov ecx,0xffffffff" "xor eax,eax" "repne scasb" "not ecx" "dec ecx" parm [EDI] modify [EAX ECX EDI] value [ECX];
|
||||
|
||||
char* radstrcat(void* dest,const void* source);
|
||||
#pragma aux radstrcat = "cld" "mov ecx,0xffffffff" "mov edx,edi" "xor eax,eax" "repne scasb" "dec edi" "lp:" "lodsb" "stosb" "test al,0xff" "jnz lp" \
|
||||
parm [EDI] [ESI] modify [EAX ECX EDI ESI] value [EDX];
|
||||
|
||||
char* radstrchr(const void* dest,char chr);
|
||||
#pragma aux radstrchr = "cld" "lp:" "lodsb" "cmp al,dl" "je fnd" "cmp al,0" "jnz lp" "mov esi,1" "fnd:" "dec esi" parm [ESI] [DL] modify [EAX ESI] value [esi];
|
||||
|
||||
s8 radmemcmp(const void* s1,const void* s2,u32 len);
|
||||
#pragma aux radmemcmp = "cld" "rep cmpsb" "setne al" "jbe end" "neg al" "end:" parm [EDI] [ESI] [ECX] modify [ECX EDI ESI];
|
||||
|
||||
s8 radstrcmp(const void* s1,const void* s2);
|
||||
#pragma aux radstrcmp = "lp:" "mov al,[esi]" "mov ah,[edi]" "cmp al,ah" "jne set" "cmp al,0" "je set" "inc esi" "inc edi" "jmp lp" "set:" "setne al" "jbe end" "neg al" "end:" \
|
||||
parm [EDI] [ESI] modify [EAX EDI ESI];
|
||||
|
||||
s8 radstricmp(const void* s1,const void* s2);
|
||||
#pragma aux radstricmp = "lp:" "mov al,[esi]" "mov ah,[edi]" "cmp al,'a'" "jb c1" "cmp al,'z'" "ja c1" "sub al,32" "c1:" "cmp ah,'a'" "jb c2" "cmp ah,'z'" "ja c2" "sub ah,32" "c2:" "cmp al,ah" "jne set" "cmp al,0" "je set" \
|
||||
"inc esi" "inc edi" "jmp lp" "set:" "setne al" "jbe end" "neg al" "end:" \
|
||||
parm [EDI] [ESI] modify [EAX EDI ESI];
|
||||
|
||||
s8 radstrnicmp(const void* s1,const void* s2,u32 len);
|
||||
#pragma aux radstrnicmp = "lp:" "mov al,[esi]" "mov ah,[edi]" "cmp al,'a'" "jb c1" "cmp al,'z'" "ja c1" "sub al,32" "c1:" "cmp ah,'a'" "jb c2" "cmp ah,'z'" "ja c2" "sub ah,32" "c2:" "cmp al,ah" "jne set" "cmp al,0" "je set" \
|
||||
"dec ecx" "jz set" "inc esi" "inc edi" "jmp lp" "set:" "setne al" "jbe end" "neg al" "end:" \
|
||||
parm [EDI] [ESI] [ECX] modify [EAX ECX EDI ESI];
|
||||
|
||||
char* radstrupr(void* s1);
|
||||
#pragma aux radstrupr = "mov ecx,edi" "lp:" "mov al,[edi]" "cmp al,'a'" "jb c1" "cmp al,'z'" "ja c1" "sub [edi],32" "c1:" "inc edi" "cmp al,0" "jne lp" parm [EDI] modify [EAX EDI] value [ecx];
|
||||
|
||||
char* radstrlwr(void* s1);
|
||||
#pragma aux radstrlwr = "mov ecx,edi" "lp:" "mov al,[edi]" "cmp al,'A'" "jb c1" "cmp al,'Z'" "ja c1" "add [edi],32" "c1:" "inc edi" "cmp al,0" "jne lp" parm [EDI] modify [EAX EDI] value [ecx];
|
||||
|
||||
u32 radstru32(const void* dest);
|
||||
#pragma aux radstru32 = "cld" "xor ecx,ecx" "xor ebx,ebx" "xor edi,edi" "lodsb" "cmp al,45" "jne skip2" "mov edi,1" "jmp skip" "lp:" "mov eax,10" "mul ecx" "lea ecx,[eax+ebx]" \
|
||||
"skip:" "lodsb" "skip2:" "cmp al,0x39" "ja dne" "cmp al,0x30" "jb dne" "mov bl,al" "sub bl,0x30" "jmp lp" "dne:" "test edi,1" "jz pos" "neg ecx" "pos:" \
|
||||
parm [ESI] modify [EAX EBX EDX EDI ESI] value [ecx];
|
||||
|
||||
u16 GetDS();
|
||||
#pragma aux GetDS = "mov ax,ds" value [ax];
|
||||
|
||||
#ifdef __RADWINEXT__
|
||||
|
||||
#define _16To32(ptr16) ((void*)(((GetSelectorBase((u16)(((u32)(ptr16))>>16))+((u16)(u32)(ptr16)))-GetSelectorBase(GetDS()))))
|
||||
|
||||
#endif
|
||||
|
||||
#ifndef __RADWIN__
|
||||
#define int86 int386
|
||||
#define int86x int386x
|
||||
#endif
|
||||
|
||||
#define u32regs x
|
||||
#define u16regs w
|
||||
|
||||
#else
|
||||
|
||||
#define radstrcpy strcpy
|
||||
#define radstrcat strcat
|
||||
#define radmemcpy memcpy
|
||||
#define radmemcpydb memmove
|
||||
#define radmemcmp memcmp
|
||||
#define radmemset memset
|
||||
#define radstrlen strlen
|
||||
#define radstrchr strchr
|
||||
#define radtoupper toupper
|
||||
#define radstru32(s) ((u32)atol(s))
|
||||
#define radstricmp _stricmp
|
||||
#define radstrcmp strcmp
|
||||
#define radstrupr _strupr
|
||||
#define radstrlwr _strlwr
|
||||
#define BreakPoint() __asm {int 3}
|
||||
#define DOSOut(str)
|
||||
|
||||
#ifdef _MSC_VER
|
||||
|
||||
#pragma warning( disable : 4035)
|
||||
|
||||
typedef char* RADPCHAR;
|
||||
|
||||
u32 __inline radsqr(u32 m) {
|
||||
__asm {
|
||||
mov eax,[m]
|
||||
mul eax
|
||||
}
|
||||
}
|
||||
|
||||
u32 __inline mult64anddiv(u32 m1,u32 m2, u32 d) {
|
||||
__asm {
|
||||
mov eax,[m1]
|
||||
mov ecx,[m2]
|
||||
mul ecx
|
||||
mov ecx,[d]
|
||||
div ecx
|
||||
}
|
||||
}
|
||||
|
||||
s32 __inline radabs(s32 ab) {
|
||||
__asm {
|
||||
mov eax,[ab]
|
||||
test eax,eax
|
||||
jge skip
|
||||
neg eax
|
||||
skip:
|
||||
}
|
||||
}
|
||||
|
||||
u8 __inline radinp(u16 p) {
|
||||
__asm {
|
||||
mov dx,[p]
|
||||
in al,dx
|
||||
}
|
||||
}
|
||||
|
||||
void __inline radoutp(u16 p,u8 v) {
|
||||
__asm {
|
||||
mov dx,[p]
|
||||
mov al,[v]
|
||||
out dx,al
|
||||
}
|
||||
}
|
||||
|
||||
RADPCHAR __inline radstpcpy(char* p1, char* p2) {
|
||||
__asm {
|
||||
mov edx,[p1]
|
||||
mov ecx,[p2]
|
||||
cld
|
||||
lp:
|
||||
mov al,[ecx]
|
||||
inc ecx
|
||||
mov [edx],al
|
||||
inc edx
|
||||
cmp al,0
|
||||
jne lp
|
||||
dec edx
|
||||
mov eax,edx
|
||||
}
|
||||
}
|
||||
|
||||
RADPCHAR __inline radstpcpyrs(char* p1, char* p2) {
|
||||
__asm {
|
||||
mov edx,[p1]
|
||||
mov ecx,[p2]
|
||||
cld
|
||||
lp:
|
||||
mov al,[ecx]
|
||||
inc ecx
|
||||
mov [edx],al
|
||||
inc edx
|
||||
cmp al,0
|
||||
jne lp
|
||||
dec ecx
|
||||
mov eax,ecx
|
||||
}
|
||||
}
|
||||
|
||||
void __inline radmemset16(void* dest,u16 value,u32 sizeb) {
|
||||
__asm {
|
||||
mov edi,[dest]
|
||||
mov ax,[value]
|
||||
mov ecx,[sizeb]
|
||||
shl eax,16
|
||||
cld
|
||||
mov ax,[value]
|
||||
mov bl,cl
|
||||
shr ecx,1
|
||||
rep stosd
|
||||
mov cl,bl
|
||||
and cl,1
|
||||
rep stosw
|
||||
}
|
||||
}
|
||||
|
||||
void __inline radmemset32(void* dest,u32 value,u32 sizeb) {
|
||||
__asm {
|
||||
mov edi,[dest]
|
||||
mov eax,[value]
|
||||
mov ecx,[sizeb]
|
||||
cld
|
||||
rep stosd
|
||||
}
|
||||
}
|
||||
|
||||
u32 __inline __stdcall RADsqrt(u32 sq) {
|
||||
__asm {
|
||||
fild dword ptr [sq]
|
||||
fsqrt
|
||||
fistp word ptr [sq]
|
||||
movzx eax,word ptr [sq]
|
||||
}
|
||||
}
|
||||
|
||||
u32 __inline RADCycleTimerAvail(void)
|
||||
{
|
||||
u32 rdtscavail=(u32)-1;
|
||||
__try
|
||||
{
|
||||
__asm
|
||||
{
|
||||
#ifdef __MWERKS__
|
||||
rdtsc
|
||||
#else
|
||||
#if _MSC_VER<=1100
|
||||
__emit 0xf
|
||||
__emit 0x31
|
||||
#else
|
||||
rdtsc
|
||||
#endif
|
||||
#endif
|
||||
}
|
||||
rdtscavail=1;
|
||||
}
|
||||
__except (1)
|
||||
{
|
||||
rdtscavail=(u32)-1;
|
||||
}
|
||||
return rdtscavail;
|
||||
}
|
||||
|
||||
void __inline RADCycleTimerStartAddr(u32* addr)
|
||||
{
|
||||
__asm {
|
||||
mov ecx,[addr]
|
||||
#ifdef __MWERKS__
|
||||
rdtsc
|
||||
#else
|
||||
#if _MSC_VER<=1100
|
||||
__emit 0xf
|
||||
__emit 0x31
|
||||
#else
|
||||
rdtsc
|
||||
#endif
|
||||
#endif
|
||||
mov [ecx],eax
|
||||
}
|
||||
}
|
||||
|
||||
u32 __inline RADCycleTimerDeltaAddr(u32* addr)
|
||||
{
|
||||
__asm {
|
||||
#ifdef __MWERKS__
|
||||
rdtsc
|
||||
#else
|
||||
#if _MSC_VER<=1100
|
||||
__emit 0xf
|
||||
__emit 0x31
|
||||
#else
|
||||
rdtsc
|
||||
#endif
|
||||
#endif
|
||||
mov ecx,[addr]
|
||||
mov edx,eax
|
||||
sub eax,[ecx]
|
||||
mov [ecx],eax
|
||||
}
|
||||
}
|
||||
|
||||
void __inline RADCycleTimerStartAddr64(u64* addr)
|
||||
{
|
||||
__asm {
|
||||
mov ecx,[addr]
|
||||
#ifdef __MWERKS__
|
||||
rdtsc
|
||||
#else
|
||||
#if _MSC_VER<=1100
|
||||
__emit 0xf
|
||||
__emit 0x31
|
||||
#else
|
||||
rdtsc
|
||||
#endif
|
||||
#endif
|
||||
mov [ecx],eax
|
||||
mov [ecx+4],edx
|
||||
}
|
||||
}
|
||||
|
||||
void __inline RADCycleTimerDeltaAddr64(u64* addr)
|
||||
{
|
||||
__asm {
|
||||
#ifdef __MWERKS__
|
||||
rdtsc
|
||||
#else
|
||||
#if _MSC_VER<=1100
|
||||
__emit 0xf
|
||||
__emit 0x31
|
||||
#else
|
||||
rdtsc
|
||||
#endif
|
||||
#endif
|
||||
mov ecx,[addr]
|
||||
sub eax,[ecx]
|
||||
sbb edx,[ecx+4]
|
||||
mov [ecx],eax
|
||||
mov [ecx+4],edx
|
||||
}
|
||||
}
|
||||
|
||||
#define RADCycleTimerStart(var) RADCycleTimerStartAddr(&var)
|
||||
#define RADCycleTimerDelta(var) RADCycleTimerDeltaAddr(&var)
|
||||
|
||||
#define RADCycleTimerStart64(var) RADCycleTimerStartAddr64(&var)
|
||||
#define RADCycleTimerDelta64(var) RADCycleTimerDeltaAddr64(&var)
|
||||
|
||||
#pragma warning( default : 4035)
|
||||
|
||||
#endif
|
||||
|
||||
#endif
|
||||
|
||||
#endif
|
||||
|
||||
#else
|
||||
|
||||
#define PTR4 __far
|
||||
|
||||
#define u16 unsigned int
|
||||
#define s16 signed int
|
||||
|
||||
#ifdef __WATCOMC__
|
||||
|
||||
u32 radsqr(s32 a);
|
||||
#pragma aux radsqr = "shl edx,16" "mov dx,ax" "mov eax,edx" "xor edx,edx" "mul eax" "shld edx,eax,16" parm [dx ax] modify [DX ax] value [dx ax];
|
||||
|
||||
s16 radabs(s16 ab);
|
||||
#pragma aux radabs = "test ax,ax" "jge skip" "neg ax" "skip:" parm [ax] value [ax];
|
||||
|
||||
s32 radabs32(s32 ab);
|
||||
#pragma aux radabs32 = "test dx,dx" "jge skip" "neg dx" "neg ax" "sbb dx,0" "skip:" parm [dx ax] value [dx ax];
|
||||
|
||||
u32 DOSOut(const char far* dest);
|
||||
#pragma aux DOSOut = "cld" "and edi,0xffff" "mov dx,di" "mov ecx,0xffffffff" "xor eax,eax" 0x67 "repne scasb" "not ecx" "dec ecx" "mov bx,1" "push ds" "push es" "pop ds" "mov ah,0x40" "int 0x21" "pop ds" "movzx eax,cx" "shr ecx,16" \
|
||||
parm [ES DI] modify [AX BX CX DX DI ES] value [CX AX];
|
||||
|
||||
void DOSOutNum(const char far* str,u16 len);
|
||||
#pragma aux DOSOutNum = "push ds" "mov ds,cx" "mov cx,bx" "mov ah,0x40" "mov bx,1" "int 0x21" "pop ds" parm [cx dx] [bx] modify [ax bx cx];
|
||||
|
||||
u32 ErrOut(const char far* dest);
|
||||
#pragma aux ErrOut = "cld" "and edi,0xffff" "mov dx,di" "mov ecx,0xffffffff" "xor eax,eax" 0x67 "repne scasb" "not ecx" "dec ecx" "xor bx,bx" "push ds" "push es" "pop ds" "mov ah,0x40" "int 0x21" "pop ds" "movzx eax,cx" "shr ecx,16" \
|
||||
parm [ES DI] modify [AX BX CX DX DI ES] value [CX AX];
|
||||
|
||||
void ErrOutNum(const char far* str,u16 len);
|
||||
#pragma aux ErrOutNum = "push ds" "mov ds,cx" "mov cx,bx" "mov ah,0x40" "xor bx,bx" "int 0x21" "pop ds" parm [cx dx] [bx] modify [ax bx cx];
|
||||
|
||||
void radmemset(void far *dest,u8 value,u32 size);
|
||||
#pragma aux radmemset = "cld" "and edi,0ffffh" "shl ecx,16" "mov cx,bx" "mov ah,al" "mov bx,ax" "shl eax,16" "mov ax,bx" "mov bl,cl" "shr ecx,2" 0x67 "rep stosd" "mov cl,bl" "and cl,3" "rep stosb" parm [ES DI] [AL] [CX BX];
|
||||
|
||||
void radmemset16(void far* dest,u16 value,u32 size);
|
||||
#pragma aux radmemset16 = "cld" "and edi,0ffffh" "shl ecx,16" "mov cx,bx" "mov bx,ax" "shl eax,16" "mov ax,bx" "mov bl,cl" "shr ecx,1" "rep stosd" "mov cl,bl" "and cl,1" "rep stosw" parm [ES DI] [AX] [CX BX];
|
||||
|
||||
void radmemcpy(void far* dest,const void far* source,u32 size);
|
||||
#pragma aux radmemcpy = "cld" "push ds" "mov ds,dx" "and esi,0ffffh" "and edi,0ffffh" "shl ecx,16" "mov cx,bx" "shr ecx,2" 0x67 "rep movsd" "mov cl,bl" "and cl,3" "rep movsb" "pop ds" parm [ES DI] [DX SI] [CX BX] modify [CX SI DI ES];
|
||||
|
||||
s8 radmemcmp(const void far* s1,const void far* s2,u32 len);
|
||||
#pragma aux radmemcmp = "cld" "push ds" "mov ds,dx" "shl ecx,16" "mov cx,bx" "rep cmpsb" "setne al" "jbe end" "neg al" "end:" "pop ds" parm [ES DI] [DX SI] [CX BX] modify [CX SI DI ES];
|
||||
|
||||
char far* radstrcpy(void far* dest,const void far* source);
|
||||
#pragma aux radstrcpy = "cld" "push ds" "mov ds,dx" "and esi,0xffff" "and edi,0xffff" "mov dx,di" "lp:" "lodsb" "stosb" "test al,0xff" "jnz lp" "pop ds" parm [ES DI] [DX SI] modify [AX DX DI SI ES] value [es dx];
|
||||
|
||||
char far* radstpcpy(void far* dest,const void far* source);
|
||||
#pragma aux radstpcpy = "cld" "push ds" "mov ds,dx" "and esi,0xffff" "and edi,0xffff" "lp:" "lodsb" "stosb" "test al,0xff" "jnz lp" "dec di" "pop ds" parm [ES DI] [DX SI] modify [DI SI ES] value [es di];
|
||||
|
||||
u32 radstrlen(const void far* dest);
|
||||
#pragma aux radstrlen = "cld" "and edi,0xffff" "mov ecx,0xffffffff" "xor eax,eax" 0x67 "repne scasb" "not ecx" "dec ecx" "movzx eax,cx" "shr ecx,16" parm [ES DI] modify [AX CX DI ES] value [CX AX];
|
||||
|
||||
char far* radstrcat(void far* dest,const void far* source);
|
||||
#pragma aux radstrcat = "cld" "and edi,0xffff" "mov ecx,0xffffffff" "and esi,0xffff" "push ds" "mov ds,dx" "mov dx,di" "xor eax,eax" 0x67 "repne scasb" "dec edi" "lp:" "lodsb" "stosb" "test al,0xff" "jnz lp" "pop ds" \
|
||||
parm [ES DI] [DX SI] modify [AX CX DI SI ES] value [es dx];
|
||||
|
||||
char far* radstrchr(const void far* dest,char chr);
|
||||
#pragma aux radstrchr = "cld" "lp:" 0x26 "lodsb" "cmp al,dl" "je fnd" "cmp al,0" "jnz lp" "xor ax,ax" "mov es,ax" "mov si,1" "fnd:" "dec si" parm [ES SI] [DL] modify [AX SI ES] value [es si];
|
||||
|
||||
s8 radstricmp(const void far* s1,const void far* s2);
|
||||
#pragma aux radstricmp = "and edi,0xffff" "push ds" "mov ds,dx" "and esi,0xffff" "lp:" "mov al,[esi]" "mov ah,[edi]" "cmp al,'a'" "jb c1" "cmp al,'z'" "ja c1" "sub al,32" "c1:" \
|
||||
"cmp ah,'a'" "jb c2" "cmp ah,'z'" "ja c2" "sub ah,32" "c2:" "cmp al,ah" "jne set" "cmp al,0" "je set" \
|
||||
"inc esi" "inc edi" "jmp lp" "set:" "setne al" "jbe end" "neg al" "end:" "pop ds" \
|
||||
parm [ES DI] [DX SI] modify [AX DI SI];
|
||||
|
||||
u32 radstru32(const void far* dest);
|
||||
#pragma aux radstru32 = "cld" "xor ecx,ecx" "xor ebx,ebx" "xor edi,edi" 0x26 "lodsb" "cmp al,45" "jne skip2" "mov edi,1" "jmp skip" "lp:" "mov eax,10" "mul ecx" "lea ecx,[eax+ebx]" \
|
||||
"skip:" 0x26 "lodsb" "skip2:" "cmp al,0x39" "ja dne" "cmp al,0x30" "jb dne" "mov bl,al" "sub bl,0x30" "jmp lp" "dne:" "test edi,1" "jz pos" "neg ecx" "pos:" \
|
||||
"movzx eax,cx" "shr ecx,16" parm [ES SI] modify [AX BX DX DI SI] value [cx ax];
|
||||
|
||||
u32 mult64anddiv(u32 m1,u32 m2,u32 d);
|
||||
#pragma aux mult64anddiv = "shl ecx,16" "mov cx,ax" "shrd eax,edx,16" "mov ax,si" "mul ecx" "shl edi,16" "mov di,bx" "div edi" "shld edx,eax,16" "and edx,0xffff" "and eax,0xffff" parm [cx ax] [dx si] [di bx] \
|
||||
modify [ax bx cx dx si di] value [dx ax];
|
||||
|
||||
#endif
|
||||
|
||||
#endif
|
||||
|
||||
RADDEFEND
|
||||
|
||||
#define u32neg1 ((u32)(s32)-1)
|
||||
#define RAD_align(var) var; u8 junk##var[4-(sizeof(var)&3)];
|
||||
#define RAD_align_after(var) u8 junk##var[4-(sizeof(var)&3)]={0};
|
||||
#define RAD_align_init(var,val) var=val; u8 junk##var[4-(sizeof(var)&3)]={0};
|
||||
#define RAD_align_array(var,num) var[num]; u8 junk##var[4-(sizeof(var)&3)];
|
||||
#define RAD_align_string(var,str) char var[]=str; u8 junk##var[4-(sizeof(var)&3)]={0};
|
||||
|
||||
|
||||
typedef void PTR4* (RADLINK PTR4* RADMEMALLOC) (u32 bytes);
|
||||
typedef void (RADLINK PTR4* RADMEMFREE) (void PTR4* ptr);
|
||||
|
||||
#ifdef __RADMAC__
|
||||
#pragma export on
|
||||
#endif
|
||||
RADEXPFUNC void RADEXPLINK RADSetMemory(RADMEMALLOC a,RADMEMFREE f);
|
||||
#ifdef __RADMAC__
|
||||
#pragma export off
|
||||
#endif
|
||||
|
||||
RADEXPFUNC void PTR4* RADEXPLINK radmalloc(u32 numbytes);
|
||||
RADEXPFUNC void RADEXPLINK radfree(void PTR4* ptr);
|
||||
|
||||
#ifdef __RADDOS__
|
||||
|
||||
RADDEFSTART
|
||||
extern void* RADTimerSetupAddr;
|
||||
extern void* RADTimerReadAddr;
|
||||
extern void* RADTimerDoneAddr;
|
||||
RADDEFEND
|
||||
|
||||
typedef void RADEXPLINK (*RADTimerSetupType)(void);
|
||||
typedef u32 RADEXPLINK (*RADTimerReadType)(void);
|
||||
typedef void RADEXPLINK (*RADTimerDoneType)(void);
|
||||
|
||||
#define RADTimerSetup() ((RADTimerSetupType)(RADTimerSetupAddr))()
|
||||
#define RADTimerRead() ((RADTimerReadType)(RADTimerReadAddr))()
|
||||
#define RADTimerDone() ((RADTimerDoneType)(RADTimerDoneAddr))()
|
||||
|
||||
#else
|
||||
|
||||
#define RADTimerSetup()
|
||||
#define RADTimerDone()
|
||||
|
||||
#if (defined(__RAD16__) || defined(__RADWINEXT__))
|
||||
|
||||
#define RADTimerRead timeGetTime
|
||||
|
||||
#else
|
||||
|
||||
RADEXPFUNC u32 RADEXPLINK RADTimerRead(void);
|
||||
|
||||
#endif
|
||||
|
||||
#endif
|
||||
|
||||
|
||||
#ifdef __WATCOMC__
|
||||
|
||||
char bkbhit();
|
||||
#pragma aux bkbhit = "mov ah,1" "int 0x16" "lahf" "shr eax,14" "and eax,1" "xor al,1" ;
|
||||
|
||||
char bgetch();
|
||||
#pragma aux bgetch = "xor ah,ah" "int 0x16" "test al,0xff" "jnz done" "mov al,ah" "or al,0x80" "done:" modify [AX];
|
||||
|
||||
void BreakPoint();
|
||||
#pragma aux BreakPoint = "int 3";
|
||||
|
||||
u8 radinp(u16 p);
|
||||
#pragma aux radinp = "in al,dx" parm [DX];
|
||||
|
||||
u8 radtoupper(u8 p);
|
||||
#pragma aux radtoupper = "cmp al,'a'" "jb c1" "cmp al,'z'" "ja c1" "sub al,32" "c1:" parm [al] value [al];
|
||||
|
||||
void radoutp(u16 p,u8 v);
|
||||
#pragma aux radoutp = "out dx,al" parm [DX] [AL];
|
||||
|
||||
#else
|
||||
|
||||
// for multi-processor machines
|
||||
|
||||
#ifdef __RADNT__
|
||||
#define LockedIncrement(var) __asm { lock inc [var] }
|
||||
#define LockedDecrement(var) __asm { lock dec [var] }
|
||||
void __inline LockedIncrementFunc(void PTR4* var) {
|
||||
__asm {
|
||||
mov eax,[var]
|
||||
lock inc [eax]
|
||||
}
|
||||
}
|
||||
|
||||
void __inline LockedDecrementFunc(void PTR4* var) {
|
||||
__asm {
|
||||
mov eax,[var]
|
||||
lock dec [eax]
|
||||
}
|
||||
}
|
||||
|
||||
#else
|
||||
|
||||
#ifdef __RADMAC__
|
||||
|
||||
#define LockedIncrement(var) {++(var);}
|
||||
#define LockedDecrement(var) {--(var);}
|
||||
|
||||
#define LockedIncrementFunc(ptr) {++(*((u32*)(ptr)));}
|
||||
#define LockedDecrementFunc(ptr) {--(*((u32*)(ptr)));}
|
||||
|
||||
#else
|
||||
|
||||
#define LockedIncrement(var) __asm { inc [var] }
|
||||
#define LockedDecrement(var) __asm { dec [var] }
|
||||
void __inline LockedIncrementFunc(void PTR4* var) { __asm { mov eax,[var]
|
||||
inc [eax] } }
|
||||
void __inline LockedDecrementFunc(void PTR4* var) { __asm { mov eax,[var]
|
||||
dec [eax] } }
|
||||
#endif
|
||||
|
||||
#endif
|
||||
|
||||
#endif
|
||||
|
||||
#endif
|
||||
|
||||
#endif
|
||||
|
||||
Loading…
Reference in New Issue