WIP

game_re/third_party/bink/bink.h

@@ -0,0 +1,714 @@
+#ifndef __BINKH__
+#define __BINKH__
+
+#define BINKMAJORVERSION 1
+#define BINKMINORVERSION 5
+#define BINKSUBVERSION 21
+#define BINKVERSION "1.5y"
+#define BINKDATE    "2003-09-23"
+
+#ifndef __RADRES__
+
+#ifndef __RADBASEH__
+#include "radbase.h"
+#endif
+
+RADDEFSTART
+
+typedef struct BINK PTR4* HBINK;
+
+struct BINKIO;
+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 void (RADLINK PTR4* BINKCBSUSPEND)    (struct BINKIO PTR4* Bnkio);
+typedef S32  (RADLINK PTR4* BINKCBTRYSUSPEND) (struct BINKIO PTR4* Bnkio);
+typedef void (RADLINK PTR4* BINKCBRESUME)     (struct BINKIO PTR4* Bnkio);
+typedef void (RADLINK PTR4* BINKCBIDLE)       (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+32];
+
+  // filled in by the caller
+  BINKCBSUSPEND suspend_callback;
+  BINKCBTRYSUSPEND try_suspend_callback;
+  BINKCBRESUME resume_callback;
+  BINKCBIDLE idle_on_callback;
+  volatile U32 callback_control[16];  // buffer for background IO callback
+} BINKIO;
+
+struct BINKSND;
+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 void (RADLINK PTR4* BINKSNDMIXBINS)    (struct BINKSND PTR4* BnkSnd, U32 PTR4* mix_bins, U32 total);
+typedef void (RADLINK PTR4* BINKSNDMIXBINVOLS) (struct BINKSND PTR4* BnkSnd, U32 PTR4* vol_mix_bins, S32 PTR4* volumes, U32 total );
+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;
+  BINKSNDMIXBINS MixBins;
+  BINKSNDMIXBINVOLS MixBinVols;
+
+  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
+  U32 sndconvert8;            // convert back to 8-bit sound at runtime
+  U32 sndendframe;            // frame number that the sound ends on
+  U32 sndprime;               // amount of data to prime the playahead
+  U32 sndpad;                 // padded this much audio
+
+  U32 BestSizeIn16;
+  U32 BestSizeMask;
+  U32 SoundDroppedOut;
+  S32 NoThreadService;
+  S32 OnOff;
+  U32 Latency;
+  U32 VideoScale;
+  U32 freq;
+  S32 bits,chans;
+  U8 snddata[256];
+} 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 PTR4* trackindexes;     // track indexes
+  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;
+
+  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 lastresynctime;         // last loop point that we did a resync on
+  U32 doresync;               // should we do a resync in the next doframe?
+
+  U32 playingtracks;          // how many tracks are playing
+  U32 soundskips;             // number of sound stops
+  BINKSND PTR4* bsnd;         // SND structures
+  U32 skippedlastblit;        // skipped last frame?
+  U32 skipped_this_frame;     // skipped the current frame?
+  U32 skippedblits;           // how many blits were skipped
+
+  BUNDLEPOINTERS bunp;        // pointers to internal temporary memory
+  U32 skipped_in_a_row;       // how many frames have we skipped in a row
+  U32 big_sound_skip_adj;     // adjustment for large skips
+  U32 big_sound_skip_reduce;  // amount to reduce large skips by each frame
+  U32 last_time_almost_empty; // time of last almost empty IO buffer
+  U32 last_read_count;        // counter to keep track of the last bink IO
+  U32 last_sound_count;       // counter to keep track of the last bink sound
+  U32 snd_callback_buffer[16]; // buffer for background sound callback
+} 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 BINKYAINVERT          0x00000800L // Reverse Y and A planes when blitting (for debugging)
+#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
+
+#ifdef __RADXBOX__
+
+#define BINKSURFACESALL        32
+#define BINKCONVERTERSMONO     64
+#define BINKCONVERTERS2X      256
+
+#define BINKCONVERTERSALL (BINKSURFACESALL|BINKCONVERTERSMONO|BINKCONVERTERS2X)
+
+#define BinkLoad() BinkLoadUnload(1)
+#define BinkUnload() BinkLoadUnload(0)
+
+#define BinkLoadConverter(val) BinkLoadUnloadConverter(val,1)
+#define BinkUnloadConverter(val) BinkLoadUnloadConverter(val,0)
+
+RADEXPFUNC void RADEXPLINK BinkLoadUnload( S32 inout );
+RADEXPFUNC void RADEXPLINK BinkLoadUnloadConverter( U32 surfaces, S32 inout );
+
+#endif
+
+#define BINKGOTOQUICK          1
+#define BINKGOTOQUICKSOUND     2
+
+#define BINKGETKEYPREVIOUS     0
+#define BINKGETKEYNEXT         1
+#define BINKGETKEYCLOSEST      2
+#define BINKGETKEYNOTEQUAL   128
+
+//=======================================================================
+
+#ifdef __RADMAC__
+  #pragma export on
+
+  RADEXPFUNC HBINK RADEXPLINK BinkMacOpen(void /*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 BinkCopyToBufferRect(HBINK bnk,void* dest,S32 destpitch,U32 destheight,U32 destx,U32 desty,U32 srcx, U32 srcy, U32 srcw, U32 srch, 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 BinkFreeGlocalMemory( void );
+RADEXPFUNC void RADEXPLINK BinkSetVolume(HBINK bnk, U32 trackid, S32 volume);
+RADEXPFUNC void RADEXPLINK BinkSetPan(HBINK bnk,U32 trackid, S32 pan);
+RADEXPFUNC void RADEXPLINK BinkSetMixBins(HBINK bnk,U32 trackid, U32 PTR4* mix_bins, U32 total);
+RADEXPFUNC void RADEXPLINK BinkSetMixBinVolumes(HBINK bnk,U32 trackid, U32 PTR4* vol_mix_bins, S32 PTR4* volumes, U32 total);
+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 void RADEXPLINK BinkGetSummary(HBINK bnk,BINKSUMMARY PTR4* sum);
+RADEXPFUNC void RADEXPLINK BinkGetRealtime(HBINK bink,BINKREALTIME PTR4* run,U32 frames);
+
+RADEXPFUNC void RADEXPLINK BinkSetSoundTrack(U32 total_tracks, U32 PTR4* tracks);
+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)
+
+#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
+
+#ifdef __RADLINUX__
+
+  RADEXPFUNC BINKSNDOPEN RADEXPLINK BinkOpenSDLMixer(U32 param); // don't call directly
+  #define BinkSoundUseSDLMixer() BinkSetSoundSystem(BinkOpenSDLMixer,0)
+
+#endif
+
+#ifdef __RADNGC__
+
+  typedef void PTR4 * (RADLINK PTR4* RADARAMALLOC) ( U32 num_bytes );
+  typedef void (RADLINK PTR4* RADARAMFREE)   ( void PTR4 * ptr );
+
+  typedef struct RADARAMCALLBACKS
+  {
+    RADARAMALLOC aram_malloc;
+    RADARAMFREE aram_free;
+  } RADARAMCALLBACKS;
+
+  RADEXPFUNC BINKSNDOPEN RADEXPLINK BinkOpenAX(U32 param); // don't call directly
+  #define BinkSoundUseAX( functions ) BinkSetSoundSystem(BinkOpenAX,(U32)functions) // takes a pointer to RADARAMCALLBACKS
+
+  RADEXPFUNC BINKSNDOPEN RADEXPLINK BinkOpenMusyXSound(U32 param); // don't call directly
+  #define BinkSoundUseMusyX( ) BinkSetSoundSystem(BinkOpenMusyXSound,0)
+
+#endif
+
+#if defined(__RADXBOX__) || defined(__RADWIN__)
+
+RADEXPFUNC S32 RADEXPLINK BinkDX8SurfaceType(void* lpD3Ds);
+
+#endif
+
+#if defined(__RADWIN__)
+
+RADEXPFUNC S32 RADEXPLINK BinkDX9SurfaceType(void* lpD3Ds);
+
+#endif
+
+
+// The BinkBuffer API isn't implemented on DOS, Xbox or GameCube
+#if !defined(__RADDOS__) && !defined(__RADXBOX__) && !defined(__RADNGC__)
+
+//=========================================================================
+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( void* /*WindowPtr*/ wnd, U32 width, U32 height, U32 bufferflags);
+RADEXPFUNC S32 RADEXPLINK BinkGDSurfaceType( void* /*GDHandle*/ gd );
+RADEXPFUNC S32 RADEXPLINK BinkIsSoftwareCursor(void* /*GDHandle*/ gd);
+RADEXPFUNC S32 RADEXPLINK BinkCheckCursor(void* /*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 minimized;
+  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( void* /*HWND*/ wnd, U32 width, U32 height, U32 bufferflags);
+RADEXPFUNC S32 RADEXPLINK BinkBufferSetHWND( HBINKBUFFER buf, void* /*HWND*/ newwnd);
+RADEXPFUNC S32 RADEXPLINK BinkDDSurfaceType(void PTR4* lpDDS);
+RADEXPFUNC S32 RADEXPLINK BinkIsSoftwareCursor(void PTR4* lpDDSP, void* /*HCURSOR*/ cur);
+RADEXPFUNC S32 RADEXPLINK BinkCheckCursor(void* /*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 void RADEXPLINK BinkRestoreCursor(S32 checkcount);
+RADEXPFUNC S32 RADEXPLINK BinkBufferClear(HBINKBUFFER buf, U32 RGB);
+
+#endif
+
+typedef void PTR4* (RADLINK PTR4* BINKMEMALLOC) (U32 bytes);
+typedef void       (RADLINK PTR4* BINKMEMFREE)  (void PTR4* ptr);
+
+RADEXPFUNC void RADEXPLINK BinkSetMemory(BINKMEMALLOC a,BINKMEMFREE f);
+
+#ifdef __RADMAC__
+
+#pragma export off
+
+#endif
+
+RADDEFEND
+
+#endif
+
+// @cdep pre $set(INCs,$INCs -I$clipfilename($file)) $ignore(TakeCPP)
+
+#endif
+

game_re/third_party/bink/radbase.h

@@ -0,0 +1,389 @@
+//  __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
+//  __RADCARBON__ means Carbon
+//  __RADMACH__ means MachO
+//  __RADXBOX__ means the XBox console
+//  __RADNGC__ means the Nintendo GameCube
+//  __RADNTBUILDLINUX__ means building Linux on NT 
+//  __RADLINUX__ means actually building on Linux (most likely with GCC)
+
+//  __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)
+
+#ifndef __RADBASEH__
+  #define __RADBASEH__
+
+  #define RADCOPYRIGHT "Copyright (C) 1994-2003, RAD Game Tools, Inc."
+
+  #ifndef __RADRES__
+
+    #if defined(GEKKO)
+
+      #define __RADNGC__
+      #define __RAD32__
+      #define __RADPPC__
+      #define __RADBIGENDIAN__
+      #define RADINLINE inline
+
+    #elif (defined(__MWERKS__) && !defined(__INTEL__)) || defined(__MRC__) || defined(THINK_C) || defined(powerc) || defined(macintosh) || defined(__powerc) || defined(__APPLE__) || defined(__MACH__)
+      #define __RADMAC__
+      #if defined(powerc) || defined(__powerc) || defined(__ppc__)
+        #define __RADPPC__
+      #else
+        #define __RAD68K__
+      #endif
+
+      #define __RAD32__
+      #define __RADBIGENDIAN__
+
+      #if defined(__MWERKS__)
+        #if (defined(__cplusplus) || ! __option(only_std_keywords))
+          #define RADINLINE inline
+        #endif
+      #elif defined(__MRC__)
+        #if defined(__cplusplus)
+          #define RADINLINE inline
+        #endif
+      #elif defined(__GNUC__) || defined(__GNUG__)
+        #define RADINLINE inline
+        #define __RADMACH__
+      #endif
+
+      #ifdef __MACH__
+        #define __RADMACH__
+      #endif
+      
+      #ifdef TARGET_API_MAC_CARBON
+        #if TARGET_API_MAC_CARBON
+          #ifndef __RADCARBON__
+            #define __RADCARBON__
+          #endif
+        #endif
+      #endif
+
+    #elif defined(linux)
+      
+      #define __RADLINUX__
+      #define __RADX86__
+      #define __RADMMX__
+      #define __RAD32__
+      #define __RADLITTLEENDIAN__
+      #define RADINLINE inline
+
+    #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
+        #ifdef _XBOX
+          #define __RADXBOX__
+        #else
+          #define __RADNT__
+        #endif
+        #define __RADWIN__
+        #define __RAD32__
+      #else
+        #ifdef __NT__
+          #ifdef _XBOX
+            #define __RADXBOX__
+          #else
+            #define __RADNT__
+          #endif
+          #define __RADWIN__
+          #define __RAD32__
+        #else
+          #ifdef __WINDOWS_386__
+            #define __RADWIN__
+            #define __RADWINEXT__
+            #define __RAD32__
+          #else
+            #ifdef __WINDOWS__
+              #define __RADWIN__
+              #define __RAD16__
+            #else
+              #ifdef WIN32
+                #ifdef _XBOX
+                  #define __RADXBOX__
+                #else
+                  #define __RADNT__
+                #endif
+                #define __RADWIN__
+                #define __RAD32__
+              #endif
+            #endif
+          #endif
+        #endif
+      #endif
+
+      #define __RADLITTLEENDIAN__
+      #ifdef __WATCOMC__
+        #define RADINLINE
+      #else
+        #define RADINLINE __inline
+      #endif
+    #endif
+
+    #if (!defined(__RADDOS__) && !defined(__RADWIN__) && !defined(__RADMAC__) && !defined(__RADNGC__) && !defined(__RADXBOX__) && !defined(__RADLINUX__))
+      #error "RAD.H did not detect your platform.  Define __DOS__, __WINDOWS__, WIN32, macintosh, or powerc."
+    #endif
+
+    #ifdef __RADFINAL__
+      #define RADTODO(str) { char __str[0]=str; }
+    #else
+      #define RADTODO(str)
+    #endif
+
+    #ifdef __RADNGC__
+
+      #define RADLINK
+      #define RADEXPLINK
+      #define RADEXPFUNC RADDEFFUNC
+      #define RADASMLINK
+      #define PTR4
+
+    #elif defined(__RADLINUX__)
+      
+      #define RADLINK __attribute__((cdecl))
+      #define RADEXPLINK __attribute__((cdecl))
+      #define RADEXPFUNC RADDEFFUNC
+      #define RADASMLINK
+      #define PTR4
+
+    #elif defined(__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 __RADXBOX__
+
+             #define RADLINK __stdcall
+             #define RADEXPLINK __stdcall
+             #define RADEXPFUNC RADDEFFUNC
+
+          #elif defined(__RADNTBUILDLINUX__)
+            
+            #define RADLINK __cdecl
+            #define RADEXPLINK __cdecl
+            #define RADEXPFUNC RADDEFFUNC
+
+          #else
+            #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
+          #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
+
+    #ifndef __RADXBOX__
+      #ifdef __RADWIN__
+        #ifndef _WINDOWS
+          #define _WINDOWS
+        #endif
+      #endif
+    #endif
+
+    #ifndef RADDEFFUNC
+
+      #ifdef __cplusplus
+        #define RADDEFFUNC extern "C"
+        #define RADDEFSTART extern "C" {
+        #define RADDEFEND }
+        #define RADDEFINEDATA extern "C"
+        #define RADDECLAREDATA extern "C"
+        #define RADDEFAULT( val ) =val
+      #else
+        #define RADDEFFUNC
+        #define RADDEFSTART
+        #define RADDEFEND
+        #define RADDEFINEDATA
+        #define RADDECLAREDATA extern
+        #define RADDEFAULT( val )
+      #endif
+
+    #endif
+
+    #ifdef __RADNGC__
+      #define RAD_ATTRIBUTE_ALIGN(num) __attribute__ ((aligned (num)))
+    #else
+      #ifdef __RADX86__
+        #ifdef __WATCOMC__
+          #define RAD_ATTRIBUTE_ALIGN(num) 
+        #else
+          #define RAD_ATTRIBUTE_ALIGN(num) __declspec(align(num))
+        #endif
+      #else
+        #define RAD_ATTRIBUTE_ALIGN(num) 
+      #endif
+    #endif
+
+    #ifdef __RADX86__
+      #ifdef __WATCOMC__
+        #define RAD_ALIGN_TYPE double
+        #define RAD_ALIGN_DEF 0.0
+      #else
+        #define RAD_ALIGN_TYPE double __declspec(align(8))
+        #define RAD_ALIGN_DEF 0.0
+      #endif
+    #else
+      #define RAD_ALIGN_TYPE double
+      #define RAD_ALIGN_DEF 0.0
+    #endif
+
+    #define RAD_ALIGN_ADD_TYPE(var) RAD_ALIGN_TYPE var##align = RAD_ALIGN_DEF
+
+    #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__) || defined( GEKKO )
+      #define U64 unsigned long long
+      #define S64 signed long long
+    #else
+      #define U64 unsigned __int64
+      #define S64 signed __int64
+    #endif
+
+    #ifdef __RAD32__
+      #define PTR4
+      #define U16 unsigned short
+      #define S16 signed short
+    #else
+      #define PTR4 __far
+      #define U16 unsigned int
+      #define S16 signed int
+    #endif
+
+    #ifndef RAD_NO_LOWERCASE_TYPES
+
+      #ifdef __RADNGC__
+
+        // Unfortunately dolphin\types.h typedefs the
+        // same types that we use.
+        // So we use the typedefs for this platform.
+
+        #include <dolphin\types.h>
+
+      #else
+
+        #define u8 U8
+        #define s8 S8
+        #define u16 U16
+        #define s16 S16
+        #define u32 U32
+        #define s32 S32
+        #define u64 U64
+        #define s64 S64
+        #define f32 F32
+        #define f64 F64
+
+      #endif
+
+    #endif
+
+  #endif
+
+#endif