| /sved/tags/2023.5/mdr/inc/mdr/bios.h |
|---|
| 0,0 → 1,39 |
| /* |
| * BIOS functions |
| * |
| * This file is part of the Mateusz' DOS Routines (MDR): http://mdr.osdn.io |
| * Published under the terms of the MIT License, as stated below. |
| * |
| * Copyright (C) 2014-2023 Mateusz Viste |
| * |
| * Permission is hereby granted, free of charge, to any person obtaining a copy |
| * of this software and associated documentation files (the "Software"), to |
| * deal in the Software without restriction, including without limitation the |
| * rights to use, copy, modify, merge, publish, distribute, sublicense, and/or |
| * sell copies of the Software, and to permit persons to whom the Software is |
| * furnished to do so, subject to the following conditions: |
| * |
| * The above copyright notice and this permission notice shall be included in |
| * all copies or substantial portions of the Software. |
| * |
| * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR |
| * IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY, |
| * FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE |
| * AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER |
| * LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING |
| * FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS |
| * IN THE SOFTWARE. |
| */ |
| #ifndef MDR_BIOS_H |
| #define MDR_BIOS_H |
| /* waits for ticks time (1 tick is roughly 55ms, an hour has 65543 ticks) |
| * works on IBM PC, XT, AT - ie. it's always safe */ |
| void mdr_bios_tickswait(unsigned short ticks); |
| /* returns the current BIOS tick counter (18.2 Hz, 1 tick is roughly 55ms, an |
| * hour has 65543 ticks). works on IBM PC, XT, AT - ie. it's always safe */ |
| unsigned short mdr_bios_ticks(void); |
| #endif |
| /sved/tags/2023.5/mdr/inc/mdr/cout.h |
|---|
| 0,0 → 1,83 |
| /* |
| * Console output |
| * |
| * This file is part of the Mateusz' DOS Routines (MDR): http://mdr.osdn.io |
| * Published under the terms of the MIT License, as stated below. |
| * |
| * Copyright (C) 2014-2023 Mateusz Viste |
| * |
| * Permission is hereby granted, free of charge, to any person obtaining a copy |
| * of this software and associated documentation files (the "Software"), to |
| * deal in the Software without restriction, including without limitation the |
| * rights to use, copy, modify, merge, publish, distribute, sublicense, and/or |
| * sell copies of the Software, and to permit persons to whom the Software is |
| * furnished to do so, subject to the following conditions: |
| * |
| * The above copyright notice and this permission notice shall be included in |
| * all copies or substantial portions of the Software. |
| * |
| * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR |
| * IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY, |
| * FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE |
| * AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER |
| * LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING |
| * FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS |
| * IN THE SOFTWARE. |
| */ |
| #ifndef MDR_COUT |
| #define MDR_COUT |
| /* inits the subsystem, fills arguments with: |
| * w = screen width |
| * h = screen height |
| * Any of these arguments may be passed as NULL |
| * Returns a color flag (0=mono, non-zero=color) */ |
| unsigned char mdr_cout_init(unsigned char *w, unsigned char *h); |
| /* get current attribute value under cursor and returns it */ |
| int mdr_cout_getcurattr(void); |
| void mdr_cout_close(void); |
| void mdr_cout_cursor_hide(void); |
| void mdr_cout_cursor_show(void); |
| /* gets cursor's position on screen (row, column) and shape */ |
| void mdr_cursor_getinfo(unsigned char *column, unsigned char *row, unsigned short *shape); |
| void mdr_cout_locate(unsigned char row, unsigned char column); |
| /* print a single character on screen */ |
| void mdr_cout_char(unsigned char y, unsigned char x, char c, unsigned char attr); |
| /* print a single character on screen, repeated count times */ |
| void mdr_cout_char_rep(unsigned char y, unsigned char x, char c, unsigned char attr, unsigned char count); |
| /* print a nul-terminated string on screen, up to maxlen characters |
| * returns the number of characters actually displayed */ |
| unsigned char mdr_cout_str(unsigned char y, unsigned char x, const char *s, unsigned char attr, unsigned char maxlen); |
| /* clears screen, filling it with a single color attribute */ |
| void mdr_cout_cls(unsigned char colattr); |
| void mdr_cout_getconprops(unsigned char *termwidth, unsigned char *termheight, unsigned char *colorflag); |
| /***************************************************************************** |
| * functions below do not need mdr_cout_init() initialization, they can be * |
| * used to output data to console right away, as they use DOS services. * |
| *****************************************************************************/ |
| /* output a single character to console */ |
| void mdr_coutraw_char(char c); |
| /* output a nul-terminated string */ |
| void mdr_coutraw_str(const char *s); |
| /* same as above, but followed with a CR/LF line terminator */ |
| void mdr_coutraw_puts(const char *s); |
| /* outputs a DOS-style (CR/LF) newline to console */ |
| void mdr_coutraw_crlf(void); |
| #endif |
| /sved/tags/2023.5/mdr/inc/mdr/dos.h |
|---|
| 0,0 → 1,114 |
| /* |
| * Functions interacting with DOS |
| * |
| * This file is part of the Mateusz' DOS Routines (MDR): http://mdr.osdn.io |
| * Published under the terms of the MIT License, as stated below. |
| * |
| * Copyright (C) 2014-2023 Mateusz Viste |
| * |
| * Permission is hereby granted, free of charge, to any person obtaining a copy |
| * of this software and associated documentation files (the "Software"), to |
| * deal in the Software without restriction, including without limitation the |
| * rights to use, copy, modify, merge, publish, distribute, sublicense, and/or |
| * sell copies of the Software, and to permit persons to whom the Software is |
| * furnished to do so, subject to the following conditions: |
| * |
| * The above copyright notice and this permission notice shall be included in |
| * all copies or substantial portions of the Software. |
| * |
| * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR |
| * IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY, |
| * FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE |
| * AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER |
| * LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING |
| * FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS |
| * IN THE SOFTWARE. |
| */ |
| #ifndef MDR_DOS_H |
| #define MDR_DOS_H |
| #include <time.h> /* time_t */ |
| /* returns a far pointer to the current process PSP structure */ |
| void far *mdr_dos_psp(void); |
| /* returns a far pointer to the environment block of the current process */ |
| char far *mdr_dos_env(void); |
| /* looks for varname in the DOS environment and fills result with its value if |
| * found. returns NULL if not found or if value is too big to fit in result |
| * (reslimit exceeded). returns result on success. |
| * NOTE: this function performs case-sensitive matches */ |
| char *mdr_dos_getenv(char *result, const char *varname, unsigned short reslimit); |
| /* fetches directory where the program was loaded from and return its length. |
| * path string is never longer than 128 (incl. the null terminator) and it is |
| * always terminated with a backslash separator, unless it is an empty string */ |
| unsigned char mdr_dos_exepath(char *path); |
| /* returns a far pointer to the full path and filename of the running program. |
| * returns NULL on error. */ |
| const char far *mdr_dos_selfexe(void); |
| /* waits for a keypress and returns it |
| * extended keys are returned ORed with 0x100 (example: PGUP is 0x149) */ |
| int mdr_dos_getkey(void); |
| /* Same as mdr_dos_getkey(), but this call cannot be aborted by CTRL+C */ |
| int mdr_dos_getkey2(void); |
| /* flush the keyboard buffer */ |
| void mdr_dos_flushkeyb(void); |
| /* poll stdin status, returns 0 if no character is pending in the keyboard |
| * buffer, non-zero otherwise */ |
| int mdr_dos_keypending(void); |
| /* sets up the CTRL+C handler for the running program to a no-op - in other |
| * words, after this call DOS will no longer abort the program on CTRL+C. |
| * this is only valid for the duration of the program because DOS will restore |
| * the original handler after the program exits. |
| * |
| * an alternative is mdr_dos_ctrlc_off(), but this does not inhibit the |
| * handler, it sets DOS to not react to CTRL+C in the first place, and this |
| * setting stays active after the program quits so the program should remember |
| * to restore the original setting before quitting. */ |
| void mdr_dos_ctrlc_inhibit(void); |
| /* sets the DOS BREAK control OFF, ie. instructs DOS not to check for CTRL+C |
| * during most input operations. returns the previous state of the break |
| * control flag (0=disabled 1=enabled). this changes a global DOS flag that can |
| * be checked on command line with the "BREAK" command, so the program should |
| * take care to restore the initial setting before quitting. */ |
| unsigned char mdr_dos_ctrlc_disable(void); |
| /* sets the DOS BREAK control ON. see mdr_dos_ctrlc_disable() for details. */ |
| void mdr_dos_ctrlc_enable(void); |
| /* converts a "DOS format" 16-bit packed date into a standard (time_t) |
| * unix timestamp. A DOS date is a 16-bit value: |
| * YYYYYYYM MMMDDDDD |
| * |
| * day of month is always within 1-31 range; |
| * month is always within 1-12 range; |
| * year starts at 1980 and continues for 127 years */ |
| time_t mdr_dos_date2unix(unsigned short d); |
| /* converts a "DOS format" 16-bit packed time into hours, minutes and seconds |
| * |
| * A DOS time is a 16-bit value: |
| * HHHHHMMM MMMSSSSS |
| * |
| * HHHHH = hours, always within 0-23 range |
| * MMMMMM = minutes, always within 0-59 range |
| * SSSSS = seconds/2 (always within 0-29 range) */ |
| void mdr_dos_time2hms(unsigned char *h, unsigned char *m, unsigned char *s, unsigned short t); |
| /* Determine the canonical name of the specified filename or path and writes |
| * the result into result. The input path does not need to actually exist. |
| * This function requires a 3.x+ DOS kernel. |
| * name is simply copied to result on error. */ |
| void mdr_dos_truename(char *result, const char *name); |
| #endif |
| /sved/tags/2023.5/mdr/inc/mdr/mouse.h |
|---|
| 0,0 → 1,60 |
| /* |
| * Mouse routines |
| * |
| * This file is part of the Mateusz' DOS Routines (MDR): http://mdr.osdn.io |
| * Published under the terms of the MIT License, as stated below. |
| * |
| * Copyright (C) 2014-2023 Mateusz Viste |
| * |
| * Permission is hereby granted, free of charge, to any person obtaining a copy |
| * of this software and associated documentation files (the "Software"), to |
| * deal in the Software without restriction, including without limitation the |
| * rights to use, copy, modify, merge, publish, distribute, sublicense, and/or |
| * sell copies of the Software, and to permit persons to whom the Software is |
| * furnished to do so, subject to the following conditions: |
| * |
| * The above copyright notice and this permission notice shall be included in |
| * all copies or substantial portions of the Software. |
| * |
| * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR |
| * IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY, |
| * FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE |
| * AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER |
| * LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING |
| * FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS |
| * IN THE SOFTWARE. |
| */ |
| #ifndef MDR_MOUSE_H |
| #define MDR_MOUSE_H |
| /* init the mouse driver (and checks for presence of mouse support at same time) |
| * returns 0 if no mouse is present, and the number of buttons otherwise. |
| * after initialization the mouse cursor is hidden, use mdr_mouse_show() to |
| * make it visible. */ |
| int mdr_mouse_init(void); |
| /* shows the mouse pointer */ |
| void mdr_mouse_show(void); |
| /* hides the mouse pointer */ |
| void mdr_mouse_hide(void); |
| /* get x/y coordinates of the mouse, and returns a bitfield with state of buttons */ |
| int mdr_mouse_getstate(int *x, int *y); |
| /* get x/y coordinates of the mouse when the last button release occured since last check. |
| returns the id of the button pressed (1 or 2), or 0 if no event occured. */ |
| int mdr_mouse_fetchrelease(int *x, int *y); |
| /* set graphic pointer shape. icon is 64-bytes long, two sets of 32. each set |
| * of 32 bytes is organized as a 16x16 bitmap, ie. 16 rows of 16-bit values. |
| * a) the first set of 16 shorts defines the background mask - that is, the |
| * background will show through wherever there is a 1-bit in that data. |
| * b) the second set defines the "XOR mask" - that is, the pixels matching the |
| * 1-bit in this data set are toggled. |
| * hotspotx and hotspoty define respectively the horizontal and vertical hot |
| * spot of the pointer (default being [0,0], that is the top left corner). */ |
| void mdr_mouse_setcursor(const unsigned short *icon, unsigned char hotspotx, unsigned char hotspoty); |
| #endif |
| /sved/tags/2023.5/mdr/inc/mdr/opl.h |
|---|
| 0,0 → 1,241 |
| /* |
| * Library to access OPL2/OPL3 hardware (YM3812 / YMF262) |
| * |
| * This file is part of the Mateusz' DOS Routines (MDR): http://mdr.osdn.io |
| * Published under the terms of the MIT License, as stated below. |
| * |
| * Copyright (C) 2015-2023 Mateusz Viste |
| * |
| * Permission is hereby granted, free of charge, to any person obtaining a copy |
| * of this software and associated documentation files (the "Software"), to |
| * deal in the Software without restriction, including without limitation the |
| * rights to use, copy, modify, merge, publish, distribute, sublicense, and/or |
| * sell copies of the Software, and to permit persons to whom the Software is |
| * furnished to do so, subject to the following conditions: |
| * |
| * The above copyright notice and this permission notice shall be included in |
| * all copies or substantial portions of the Software. |
| * |
| * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR |
| * IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY, |
| * FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE |
| * AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER |
| * LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING |
| * FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS |
| * IN THE SOFTWARE. |
| */ |
| #ifndef mdr_opl_h |
| #define mdr_opl_h |
| struct mdr_opl_timbre { |
| unsigned char mod_ws, car_ws; /* waveform select (0-4), reg Exh */ |
| unsigned char mod_sr, car_sr; /* sustain/release, reg 8xh */ |
| unsigned char mod_ad, car_ad; /* attack/decay, reg 6xh */ |
| unsigned char mod_20, car_20; /* tremolo/vibrato/sustain..., reg 2xh */ |
| unsigned char mod_40, car_40; /* reg 4xh */ |
| unsigned char feedconn; |
| }; |
| struct mdr_opl_timbretemplate { |
| struct { |
| unsigned char ws; /* waveform select 0..3 */ |
| unsigned char sustlev; /* sustain level 0..15 */ |
| unsigned char release; /* release level 0..15 */ |
| unsigned char attack; /* attack rate 0..15 */ |
| unsigned char decay; /* decay rate 0..15 */ |
| unsigned char tremolo; /* tremolo flag 0..1 */ |
| unsigned char vibrato; /* vibrato flag 0..1 */ |
| unsigned char sustain; /* sustain flag 0..1 */ |
| unsigned char ksr; /* KSR (envelope scaling) flag 0..1 */ |
| unsigned char mult; /* frequency multiplication factor 0..15 */ |
| unsigned char ksl; /* Key Scale Level 0..3 */ |
| unsigned char outlev; /* output level 0..63 */ |
| } carrier; |
| struct { |
| unsigned char ws; /* waveform select 0..3 */ |
| unsigned char sustlev; /* sustain level 0..15 */ |
| unsigned char release; /* release level 0..15 */ |
| unsigned char attack; /* attack rate 0..15 */ |
| unsigned char decay; /* decay rate 0..15 */ |
| unsigned char tremolo; /* tremolo flag 0..1 */ |
| unsigned char vibrato; /* vibrato flag 0..1 */ |
| unsigned char sustain; /* sustain flag 0..1 */ |
| unsigned char ksr; /* KSR (envelope scaling) flag 0..1 */ |
| unsigned char mult; /* frequency multiplication factor 0..15 */ |
| unsigned char ksl; /* Key Scale Level 0..3 */ |
| unsigned char outlev; /* output level 0..63 */ |
| } modultr; |
| unsigned char feedback;/* FeedBack Modulation Factor 0..7 */ |
| unsigned char conn; /* Synthesis type: 0=FM / 1=Additive */ |
| }; |
| enum MDR_OPL_TIMER { |
| MDR_OPL_TIMER_80US = 2, |
| MDR_OPL_TIMER_320US = 3 |
| }; |
| /* frequency groups, to be used with mdr_opl_noteon() and mdr_opl_notebend(). |
| * There are 7 frequency groups to choose from. Each group supports a different |
| * span of frequencies. Higher groups have wider spans, but at the cost of larger |
| * difference between adjacent notes: |
| * |
| * Block Note 0 Note 1023 Step gap between adjacent notes |
| * FGROUP0 0.047 Hz 48.503 Hz 0.048 Hz |
| * FGROUP1 0.094 Hz 97.006 Hz 0.095 Hz |
| * FGROUP2 0.189 Hz 194.013 Hz 0.190 Hz |
| * FGROUP3 0.379 Hz 388.026 Hz 0.379 Hz |
| * FGROUP4 0.758 Hz 776.053 Hz 0.759 Hz |
| * FGROUP5 1.517 Hz 1552.107 Hz 1.517 Hz |
| * FGROUP6 3.034 Hz 3104.215 Hz 3.034 Hz |
| * FGROUP7 6.068 Hz 6208.431 Hz 6.069 Hz |
| * |
| * This shows that block 7 is capable of reaching the highest note (6.2kHz) but |
| * since there are 6 Hz between notes the accuracy suffers. Example: note A-4 |
| * is 440Hz but in this block, the two closest frequency numbers are 72 and 73, |
| * which create tones at 437Hz and 443Hz respectively, neither of which is |
| * particularly accurate. Blocks 3 and below are unable to reach as high as |
| * 440Hz, but block 4 can. With block 4, frequency numbers 579 and 580 produce |
| * 439.4 Hz and 440.2 Hz, considerably closer to the intended frequency. |
| * |
| * In other words, when calculating notes, the best accuracy is achieved by |
| * selecting the lowest possible block number that can reach the desired note |
| * frequency. |
| * |
| * More details: https://moddingwiki.shikadi.net/wiki/OPL_chip#A0-A8:_Frequency_Number |
| */ |
| enum mdr_opl_fgroup_t { |
| MDR_OPL_FGROUP0 = 0, |
| MDR_OPL_FGROUP1 = 1 << 2, |
| MDR_OPL_FGROUP2 = 2 << 2, |
| MDR_OPL_FGROUP3 = 3 << 2, |
| MDR_OPL_FGROUP4 = 4 << 2, |
| MDR_OPL_FGROUP5 = 5 << 2, |
| MDR_OPL_FGROUP6 = 6 << 2, |
| MDR_OPL_FGROUP7 = 7 << 2 |
| }; |
| /* Hardware detection and initialization. Must be called before any other |
| * OPL function. Returns 0 on success, non-zero otherwise. */ |
| int mdr_opl_init(void); |
| /* close OPL device */ |
| void mdr_opl_close(void); |
| /* turns off all notes */ |
| void mdr_opl_clear(void); |
| /* loads an instrument described by properties in a timbre_t struct into |
| * the defined voice channel. The OPL2 chip supports up to 9 voice channels, |
| * from 0 to 8. The timbre struct can be freed right after this call. */ |
| void mdr_opl_loadinstrument(unsigned char voice, const struct mdr_opl_timbre *timbre); |
| /* generate a timbre structure based on a timbre template. this is a |
| * convenience function meant to provide a human-compatible (more readable) |
| * way of generating a timbre struct. */ |
| int mdr_opl_timbre_gen(struct mdr_opl_timbre *timbre, const struct mdr_opl_timbretemplate *tpl); |
| /* Triggers a note on selected voice channel. |
| * freqid is a value between 0 and 1023. The following formula can be used to |
| * determine the freq number for a given note frequency (Hz) and block: |
| * |
| * freqid = frequency * 2^(20 - block) / 49716 |
| * |
| * The note will be kept "pressed" until mdr_opl_noteoff() is called. */ |
| void mdr_opl_noteon(unsigned char voice, unsigned short freqid, enum mdr_opl_fgroup_t fgroup); |
| /* changes the frequency of the note currently playing on voice channel, this |
| * can be used for pitch bending. */ |
| void mdr_opl_notebend(unsigned char voice, unsigned short freqid, enum mdr_opl_fgroup_t fgroup); |
| /* releases a note on selected voice. */ |
| void mdr_opl_noteoff(unsigned char voice); |
| /* adjusts volume of a voice. volume goes from 63 (mute) to 0 (loudest) */ |
| void mdr_opl_voicevolume(unsigned char voice, unsigned char volume); |
| /* this is a LOW-LEVEL function that writes a data byte into the reg register |
| * of the OPL chip. Use this only if you know exactly what you are doing. */ |
| void mdr_opl_regwr(unsigned char reg, unsigned char data); |
| /***************************************************************************** |
| * IMF AUDIO FILES PLAYBACK * |
| * * |
| * It is possible to mix IMF playback calls with manual notes, but you must * |
| * take care to use only voices not used by your IMF audio. Typically games * |
| * tend to use the voice #0 for sound effects and voices #1 to #8 for music. * |
| * * |
| * The IMF API comes in two version: the normal one, or "imfeasy". The easy * |
| * version is easier to use, but requires to have the entire IMF audio file * |
| * loaded in memory, while the normal (non-easy) allows for more flexibility * |
| * in this regard, potentially allowing for playback of huge IMF files. * |
| *****************************************************************************/ |
| /*** EASY INTERFACE ***/ |
| /* playback initialization, easy interface. imf points to the start of the IMF |
| * file. The imf pointer must not be freed as long as playback is ongoing. |
| * imflength is the size (in bytes) of the IMF data. |
| * clock must be an incrementing value that wraps to 0 after 65535. The clock |
| * speed will control the playback's tempo. |
| * loopscount tells how many times the song will have to be looped (0 means |
| * "loop forever"). |
| * returns 0 on success, non-zero otherwise. */ |
| int mdr_opl_imfeasy_init(void *imf, unsigned short imflength, unsigned short clock, unsigned char loopscount); |
| /* Playback of an IMF file preloaded via mdr_opl_imfeasy_init(). This function |
| * must be called repeatedly at a high frequency for best playback quality. |
| * Returns 0 on success, 1 if playback ended, -1 on error. */ |
| int mdr_opl_imfeasy_play(unsigned short clock); |
| /*** ADVANCED INTERFACE ***/ |
| /* playback initialization, this function must be called immediately before |
| * playback. imf points to the start of the IMF file and must contain at least |
| * the first 6 bytes of the audio file. |
| * clock must be an incrementing value that wraps to 0 after 65535. |
| * the clock speed will control the playback's tempo. |
| * returns the amount of consumed bytes (0, 4 or 6) */ |
| unsigned short mdr_opl_imf_init(void *imf, unsigned short clock); |
| /* Playback, advanced version. Feeds the IMF playback routine with IMF data. |
| * Returns the amount of bytes that have been consumed, hence the next call |
| * should provide an imf pointer advanced by this many bytes (and imflen |
| * decreased accordingly). Such approach might not be the most intuitive, but |
| * it allows to load an imf song partially and provide only short chunks of |
| * data for playback instead of having to buffer the entire song in memory. |
| * For a simpler call that requires to buffer the entire IMF file in memory, |
| * see mdr_opl_imf_playeasy(). |
| * This function must be called repeatedly at a high frequency for best |
| * playback quality. */ |
| unsigned short mdr_opl_imf_play(void *imf, unsigned short imflen, unsigned short clock); |
| /***************************************************************************** |
| * OPL TIMER FUNCTIONS * |
| *****************************************************************************/ |
| /* configures and starts a timer given type so it emits a tick every count |
| * periods. Two timer types are available: |
| * MDR_OPL_TIMER_80US - with a period of 80us |
| * MDR_OPL_TIMER_320US - with a period of 320us |
| * count may range from 0 to 255, but 0 means "256 periods". |
| * |
| * You may use only one timer at a time. |
| * |
| * EXAMPLE: setting up MDR_OPL_TIMER_80US with a count of 25 would make the |
| * timer tick every 2ms (25 * 80us). */ |
| void mdr_opl_timer_set(enum MDR_OPL_TIMER timertype, unsigned char count); |
| /* returns 1 if timer tick occured, 0 otherwise. After a tick has been |
| * returned, this function will return 0 until next tick. |
| * |
| * it is important to note that there is no way to know whether one tick |
| * passed since last time, or more, so it is up to you to make sure you call |
| * this function fast enough. */ |
| unsigned char mdr_opl_timer_tick(void); |
| #endif |
| /sved/tags/2023.5/mdr/inc/mdr/pcx.h |
|---|
| 0,0 → 1,77 |
| /* |
| * PCX-loading routines |
| * |
| * This file is part of the Mateusz' DOS Routines (MDR): http://mdr.osdn.io |
| * Published under the terms of the MIT License, as stated below. |
| * |
| * Copyright (C) 2022-2023 Mateusz Viste |
| * |
| * Permission is hereby granted, free of charge, to any person obtaining a copy |
| * of this software and associated documentation files (the "Software"), to |
| * deal in the Software without restriction, including without limitation the |
| * rights to use, copy, modify, merge, publish, distribute, sublicense, and/or |
| * sell copies of the Software, and to permit persons to whom the Software is |
| * furnished to do so, subject to the following conditions: |
| * |
| * The above copyright notice and this permission notice shall be included in |
| * all copies or substantial portions of the Software. |
| * |
| * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR |
| * IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY, |
| * FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE |
| * AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER |
| * LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING |
| * FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS |
| * IN THE SOFTWARE. |
| */ |
| #ifndef MDR_PCX_H |
| #define MDR_PCX_H |
| #include <stdio.h> /* FILE */ |
| struct pcx_hdr { |
| unsigned char rle; |
| unsigned char bpp; |
| unsigned short max_x; |
| unsigned short max_y; |
| unsigned short bytes_per_scanline; |
| struct { |
| unsigned char r; |
| unsigned char g; |
| unsigned char b; |
| } pal[256]; |
| }; |
| /* analyzes the header of a PCX file and fills the pcx_hdr struct accordingly. |
| * fd must be a valid (open) file descriptor. |
| * offset is the address inside the file where the PCX data is located |
| * (usually 0, unless the file is some kind of container). |
| * len is the total length of the PCX data. len=0 means "same as file size" |
| * returns 0 on success, non-zero otherwise. */ |
| int mdr_pcx_anal(struct pcx_hdr *h, FILE *fd, unsigned long offset, unsigned long len); |
| /* this function should be called to load the next row of a PCX file into a |
| * buffer pointed at by bufptr. you will typically want to call this function |
| * h->max_y times. ptr must be at least (h->max_x + 1) bytes large for 8bpp. |
| * the pcx_hdr struct must have been produced by pcx_anal(). |
| * returns 0 on success, non-zero otherwise. */ |
| int mdr_pcx_loadrow(void *bufptr, const struct pcx_hdr *h, FILE *fd); |
| /* load an entire PCX file into a pixel buffer. the PCX data must have been |
| * previously analyzed by pcx_anal() and the fd file pointer must not have been |
| * modified since then. the destination buffer must be large enough to hold all |
| * pixels, ie. (h->max_x + 1) * (h->max_y + 1) for 8 bpp. |
| * returns 0 on success, non-zero otherwise. */ |
| int mdr_pcx_load(void *ptr, const struct pcx_hdr *h, FILE *fd); |
| /* convert img to 8bpp if needed (ie unpack 2 and 4bpp data to 8bpp). |
| * the conversion is performed in-place, make sure the img buffer is large |
| * enough to accomodate the size of the data after conversion (ie. twice as |
| * big on 4bpp source, 4x times as big on 2bpp source and 8x as big on 1bpp |
| * source). |
| * if rowflag is set to a non-zero value, then the routine assumes img |
| * contains only a single row of pixels */ |
| int mdr_pcx_to8bpp(void *img, const struct pcx_hdr *h, unsigned char rowflag); |
| #endif |
| /sved/tags/2023.5/mdr/inc/mdr/rs232.h |
|---|
| 0,0 → 1,47 |
| /* |
| * Reading from and writing to an RS-232 port |
| * |
| * This file is part of the Mateusz' DOS Routines (MDR): http://mdr.osdn.io |
| * Published under the terms of the MIT License, as stated below. |
| * |
| * Copyright (C) 2015-2022 Mateusz Viste |
| * |
| * Permission is hereby granted, free of charge, to any person obtaining a copy |
| * of this software and associated documentation files (the "Software"), to |
| * deal in the Software without restriction, including without limitation the |
| * rights to use, copy, modify, merge, publish, distribute, sublicense, and/or |
| * sell copies of the Software, and to permit persons to whom the Software is |
| * furnished to do so, subject to the following conditions: |
| * |
| * The above copyright notice and this permission notice shall be included in |
| * all copies or substantial portions of the Software. |
| * |
| * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR |
| * IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY, |
| * FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE |
| * AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER |
| * LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING |
| * FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS |
| * IN THE SOFTWARE. |
| */ |
| #ifndef MDR_RS232_H |
| #define MDR_RS232_H |
| /* get the I/O port for COMx (1..4) */ |
| unsigned short rs232_getport(int x); |
| /* check if the COM port is ready for write. loops for some time waiting. |
| * returns 0 if port seems ready eventually, non-zero otherwise. can be used |
| * to verify the rs232 presence */ |
| int rs232_check(unsigned short port); |
| /* write a byte to the COM port at 'port'. this function will block if the |
| * UART is not ready to transmit yet. */ |
| void rs232_write(unsigned short port, int data); |
| /* read a byte from COM port at 'port'. returns the read byte, or -1 if |
| * nothing was available to read. */ |
| int rs232_read(unsigned short port); |
| #endif |
| /sved/tags/2023.5/mdr/inc/mdr/sbdigi.h |
|---|
| 0,0 → 1,57 |
| /* |
| * SoundBlaster routines for DSP driving |
| * |
| * Copyright (C) 2022 Mateusz Viste |
| * |
| * Permission is hereby granted, free of charge, to any person obtaining a copy |
| * of this software and associated documentation files (the "Software"), to |
| * deal in the Software without restriction, including without limitation the |
| * rights to use, copy, modify, merge, publish, distribute, sublicense, and/or |
| * sell copies of the Software, and to permit persons to whom the Software is |
| * furnished to do so, subject to the following conditions: |
| * |
| * The above copyright notice and this permission notice shall be included in |
| * all copies or substantial portions of the Software. |
| * |
| * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR |
| * IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY, |
| * FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE |
| * AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER |
| * LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING |
| * FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS |
| * IN THE SOFTWARE. |
| */ |
| #ifndef MDR_SBDIGI_H |
| #define MDR_SBDIGI_H |
| struct sbdigi_ctx; |
| /* initializes the SoundBlaster DSP chip |
| * blaster must point to a BLASTER environment string (like "A220 I5 D1") |
| * returns a pointer to a context, NULL on error |
| * NOTE: DSP's state after initialization may or may not be muted, depending |
| * on the exact hardware revision. use sbdigi_spkoff() to make sure it is |
| * unmuted */ |
| struct sbdigi_ctx *sbdigi_init(const char *blaster); |
| /* unmutes the SoundBlaster DSP */ |
| void sbdigi_spkon(struct sbdigi_ctx *ctx); |
| /* mutes the SoundBlaster DSP */ |
| void sbdigi_spkoff(struct sbdigi_ctx *ctx); |
| /* plays a short sample |
| * ctx - DSP context, as returned by sbdigi_init() |
| * buf - pointer to sample data (must be PCM, 8000 Hz, mono, 8-bit unsigned |
| * len - length of the sample, in bytes |
| * NOTES: this routine uses DMA to transfer memory. This has two implications: |
| * 1. the routine will return almost immediately, while the sound is playing |
| * 2. sample data must be contained in a buffer that does NOT cross a 64K page |
| * because DMA transfers are unable to cross 64K boundaries */ |
| void sbdigi_playsample(struct sbdigi_ctx *ctx, void *buf, unsigned short len); |
| /* shuts down the DSP and frees context memory */ |
| void sbdigi_quit(struct sbdigi_ctx *ctx); |
| #endif |
| /sved/tags/2023.5/mdr/inc/mdr/timer.h |
|---|
| 0,0 → 1,51 |
| /* |
| * High-resolution timing routines (PIT reprogramming) |
| * |
| * This file is part of the Mateusz' DOS Routines (MDR): http://mdr.osdn.io |
| * Published under the terms of the MIT License, as stated below. |
| * |
| * Copyright (C) 2014-2023 Mateusz Viste |
| * |
| * Permission is hereby granted, free of charge, to any person obtaining a copy |
| * of this software and associated documentation files (the "Software"), to |
| * deal in the Software without restriction, including without limitation the |
| * rights to use, copy, modify, merge, publish, distribute, sublicense, and/or |
| * sell copies of the Software, and to permit persons to whom the Software is |
| * furnished to do so, subject to the following conditions: |
| * |
| * The above copyright notice and this permission notice shall be included in |
| * all copies or substantial portions of the Software. |
| * |
| * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR |
| * IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY, |
| * FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE |
| * AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER |
| * LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING |
| * FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS |
| * IN THE SOFTWARE. |
| */ |
| #ifndef MDR_TIMER_H |
| #define MDR_TIMER_H |
| /* Starts the timer by reprogramming the 8253 chip from its default 18.2 Hz |
| * frequency to about 1.1 kHz. It is mandatory to revert the timer to its |
| * original frequency via mdr_timer_stop() before your application quits. */ |
| void mdr_timer_init(void); |
| /* Fills res with the amount of microseconds that elapsed since either |
| * mdr_timer_init() or mdr_timer_reset(), whichever was called last. |
| * Note that the res counter wraps around approximately every 71 minutes if |
| * mdr_timer_reset() is not called. */ |
| void mdr_timer_read(unsigned long *res); |
| /* Reset the timer value, this can be used by the application to make sure |
| * no timer wrap occurs during critical parts of your code flow */ |
| void mdr_timer_reset(void); |
| /* Stops (uninstalls) the timer. This must be called before your application |
| * quits, otherwise the system will likely crash. This function has a void |
| * return value so that it can be registered as an atexit() procedure. */ |
| void mdr_timer_stop(void); |
| #endif |
| /sved/tags/2023.5/mdr/inc/mdr/trigint.h |
|---|
| 0,0 → 1,46 |
| /* |
| * Routines for computation of basic transcendental functions sin and cos. |
| * These routines use only integers, hence they do not require an FPU nor any |
| * kind of FPU emulation. Works reasonably fast even on an 8086 CPU. |
| * |
| * The results are computed using polynomial approximations. Their precision |
| * is not expected to be ideal, but "good enough" for common usage. |
| * |
| * This file is part of the Mateusz' DOS Routines (MDR): http://mdr.osdn.io |
| * Published under the terms of the MIT License, as stated below. |
| * |
| * Copyright (C) 2022 Mateusz Viste |
| * |
| * Permission is hereby granted, free of charge, to any person obtaining a copy |
| * of this software and associated documentation files (the "Software"), to |
| * deal in the Software without restriction, including without limitation the |
| * rights to use, copy, modify, merge, publish, distribute, sublicense, and/or |
| * sell copies of the Software, and to permit persons to whom the Software is |
| * furnished to do so, subject to the following conditions: |
| * |
| * The above copyright notice and this permission notice shall be included in |
| * all copies or substantial portions of the Software. |
| * |
| * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR |
| * IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY, |
| * FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE |
| * AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER |
| * LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING |
| * FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS |
| * IN THE SOFTWARE. |
| */ |
| #ifndef MDR_TRIGINT_H |
| #define MDR_TRIGINT_H |
| /* Computes the cosine value for the given radian. |
| * The radian argument must be provided multiplied by 1000. |
| * Returns the cosine value multiplied by 1000. */ |
| short trigint_cos(short rad1000); |
| /* Computes the sine value for the given radian angle. |
| * The radian argument must be provided multiplied by 1000. |
| * Returns the cosine value multiplied by 1000. */ |
| short trigint_sin(short rad1000); |
| #endif |
| /sved/tags/2023.5/mdr/inc/mdr/unzip.h |
|---|
| 0,0 → 1,58 |
| /* |
| * Function to iterate through files in a ZIP archive. |
| * |
| * This file is part of the Mateusz' DOS Routines (MDR): http://mdr.osdn.io |
| * Published under the terms of the MIT License, as stated below. |
| * |
| * Copyright (C) 2012-2022 Mateusz Viste |
| * |
| * Permission is hereby granted, free of charge, to any person obtaining a copy |
| * of this software and associated documentation files (the "Software"), to |
| * deal in the Software without restriction, including without limitation the |
| * rights to use, copy, modify, merge, publish, distribute, sublicense, and/or |
| * sell copies of the Software, and to permit persons to whom the Software is |
| * furnished to do so, subject to the following conditions: |
| * |
| * The above copyright notice and this permission notice shall be included in |
| * all copies or substantial portions of the Software. |
| * |
| * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR |
| * IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY, |
| * FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE |
| * AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER |
| * LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING |
| * FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS |
| * IN THE SOFTWARE. |
| */ |
| #ifndef MDR_UNZIP |
| #define MDR_UNZIP |
| #include <stdio.h> /* FILE * */ |
| #define ZIP_FLAG_ISADIR 1 |
| #define ZIP_FLAG_ENCRYPTED 2 |
| #define ZIP_METH_STORE 0 |
| #define ZIP_METH_DEFLATE 8 |
| struct mdr_zip_item { |
| unsigned long filelen; |
| unsigned long compressedfilelen; |
| unsigned long crc32; |
| unsigned long dataoffset; /* offset in the file where compressed data starts */ |
| unsigned long nextidxoffset; /* offset in the file of the next zip record, used by mdr_zip_iter() */ |
| unsigned short dosdate; /* datestamp of the file (DOS packed format) */ |
| unsigned short dostime; /* timestamp of the file (DOS packed format) */ |
| unsigned short compmethod; /* compression method (ZIP_METH_xxx) */ |
| unsigned char flags; /* see ZIP_FLAG_xxx above */ |
| char fname[256]; /* filename */ |
| }; |
| /* returns next item found in zip file. this is supposed to be called |
| * iteratively, passing the previous mdr_zipitem struct each time (z must be |
| * all zeroed out on first call). |
| * returns 0 on success, neg on error, 1 on end of archive */ |
| int mdr_zip_iter(struct mdr_zip_item *z, FILE *fd); |
| #endif |
| /sved/tags/2023.5/mdr/inc/mdr/ver.h |
|---|
| 0,0 → 1,33 |
| /* |
| * MDR version |
| * |
| * This file is part of the Mateusz' DOS Routines (MDR): http://mdr.osdn.io |
| * Published under the terms of the MIT License, as stated below. |
| * |
| * Copyright (C) 2014-2023 Mateusz Viste |
| * |
| * Permission is hereby granted, free of charge, to any person obtaining a copy |
| * of this software and associated documentation files (the "Software"), to |
| * deal in the Software without restriction, including without limitation the |
| * rights to use, copy, modify, merge, publish, distribute, sublicense, and/or |
| * sell copies of the Software, and to permit persons to whom the Software is |
| * furnished to do so, subject to the following conditions: |
| * |
| * The above copyright notice and this permission notice shall be included in |
| * all copies or substantial portions of the Software. |
| * |
| * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR |
| * IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY, |
| * FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE |
| * AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER |
| * LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING |
| * FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS |
| * IN THE SOFTWARE. |
| */ |
| #ifndef MDR_VER_H |
| #define MDR_VER_MAJOR 2023 |
| #define MDR_VER_MINOR 0 |
| #endif |
| /sved/tags/2023.5/mdr/inc/mdr/vid12.h |
|---|
| 0,0 → 1,87 |
| /* |
| * a few functions for mode 12h programming (640x480 4bpp) |
| * |
| * This file is part of the Mateusz' DOS Routines (MDR): http://mdr.osdn.io |
| * Published under the terms of the MIT License, as stated below. |
| * |
| * Copyright (C) 2022-2023 Mateusz Viste |
| * |
| * Permission is hereby granted, free of charge, to any person obtaining a copy |
| * of this software and associated documentation files (the "Software"), to |
| * deal in the Software without restriction, including without limitation the |
| * rights to use, copy, modify, merge, publish, distribute, sublicense, and/or |
| * sell copies of the Software, and to permit persons to whom the Software is |
| * furnished to do so, subject to the following conditions: |
| * |
| * The above copyright notice and this permission notice shall be included in |
| * all copies or substantial portions of the Software. |
| * |
| * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR |
| * IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY, |
| * FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE |
| * AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER |
| * LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING |
| * FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS |
| * IN THE SOFTWARE. |
| */ |
| #ifndef MDR_VID12_H |
| #define MDR_VID12_H |
| /* init video mode 12h (640x480x16c) |
| * remember to call vid12_close() at exit time */ |
| void vid12_init(void); |
| /* wait until VBLANK */ |
| void vid12_waitvblank(void); |
| /* wait until ANY blank: either VBLANK or HBLANK */ |
| void vid12_waitblank(void); |
| /* clear screen using color |
| * this function is fastest when color is 0 or 15 */ |
| void vid12_cls(unsigned char color); |
| /* clear a single scanline (0..479) with a solid color (0..15) |
| * this function is fastest when color is 0 or 15 */ |
| void vid12_clrline(unsigned short line, unsigned char color); |
| /* fill lines from linefirst to linelast with an 8 pixels pattern |
| * linelast must be equal to or greater than linelast |
| * pattern must be 8 bytes long */ |
| void vid12_linepat(unsigned short linefirst, unsigned short linelast, const unsigned char *pattern); |
| /* deinit video mode 12h and resets to previous mode */ |
| void vid12_close(void); |
| /* puts a pixel on screen */ |
| void vid12_putpixel(unsigned short x, unsigned short y, unsigned char col); |
| /* draws a horizonatal line from [x1,y] to [x2,y] */ |
| void vid12_hline(unsigned short y, unsigned short x1, unsigned short x2, unsigned char color); |
| /* write an entire scanline (640 pixels) to screen. the pixels data must be |
| * a serie of 640 bytes having values in the range [0..15] */ |
| void vid12_putscanline(unsigned short scanline, const unsigned char *pixels); |
| /* set index palette color to given R,G,B value. each R,G,B component must be |
| * a 6 bit value in the range [0..63] (where 63 is the maximum luminosity) */ |
| void vid12_setpalette(unsigned char index, unsigned char r, unsigned char g, unsigned char b); |
| /***************************** |
| * VRAM TO VRAM operations * |
| *****************************/ |
| /* prepares VGA for a VRAM-to-VRAM copy operation */ |
| void vid12_vramcpy_prep(void); |
| /* fast (VRAM-to-VRAM) copy of a scanline (0..479) to another scanline. |
| * vid12_vramcpy_prep() must be called before and vid12_vramcpy_done must be |
| * called after one or more vid12_vramcpy_scanline() calls. */ |
| void vid12_vramcpy_scanline(unsigned short dst, unsigned short src); |
| /* sets VGA back to its normal state after VRAM-to-VRAM operations */ |
| void vid12_vramcpy_done(void); |
| #endif |
| /sved/tags/2023.5/mdr/inc/mdr/video.h |
|---|
| 0,0 → 1,94 |
| /* |
| * video library - provides a few functions for mode 4 and 13h programming. |
| * |
| * This file is part of the Mateusz' DOS Routines (MDR): http://mdr.osdn.io |
| * Published under the terms of the MIT License, as stated below. |
| * |
| * Copyright (C) 2014-2023 Mateusz Viste |
| * |
| * Permission is hereby granted, free of charge, to any person obtaining a copy |
| * of this software and associated documentation files (the "Software"), to |
| * deal in the Software without restriction, including without limitation the |
| * rights to use, copy, modify, merge, publish, distribute, sublicense, and/or |
| * sell copies of the Software, and to permit persons to whom the Software is |
| * furnished to do so, subject to the following conditions: |
| * |
| * The above copyright notice and this permission notice shall be included in |
| * all copies or substantial portions of the Software. |
| * |
| * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR |
| * IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY, |
| * FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE |
| * AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER |
| * LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING |
| * FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS |
| * IN THE SOFTWARE. |
| */ |
| #ifndef MDR_VIDEO_H |
| #define MDR_VIDEO_H |
| #define VIDEO_DBUF 1 |
| struct video_handler { |
| unsigned char far *dbuf; |
| int flags; |
| int mode; |
| unsigned char lastmode; |
| }; |
| /* returns 0 if no VGA has been detected, non-zero otherwise */ |
| int video_detectvga(void); |
| /* returns 0 if no EGA has been detected, non-zero otherwise */ |
| int video_detectega(void); |
| /* init video mode. either 0x04 for CGA or 0x13 for VGA */ |
| struct video_handler *video_open(int mode, int flags); |
| /* reads a screen dump from file and puts it to the screen buffer */ |
| void video_file2screen(struct video_handler *handler, char *file); |
| /* load count colors of palette from array of rgb triplets */ |
| void video_loadpal(const unsigned char *pal, int count, int offset); |
| /* Wait until VBLANK */ |
| void video_waitvblank(void); |
| void video_flip(struct video_handler *handler); |
| /* copies line ysrc over ydst in CGA mode memory */ |
| void video_cgalinecopy(struct video_handler *handler, int ydst, int ysrc); |
| /* clear screen using color */ |
| void video_cls(struct video_handler *handler, unsigned char color); |
| /* renders a sprite of width and height dimensions onscreen, starting at specified x/y location |
| coloffset is an offset to add to color indexes, while transp is the index of the transparent color (set to -1 if none) */ |
| void video_putsprite(struct video_handler *handler, unsigned char *sprite, int x, int y, int width, int height, int coloffset, int transp, int maxcol); |
| /* same as video_putsprite(), but reads the sprite from a file */ |
| void video_putspritefromfile(struct video_handler *handler, char *file, long foffset, int x, int y, int width, int height, int coloffset, int transp, int maxcol); |
| void video_close(struct video_handler *handler); |
| void video_rputpixel(struct video_handler *handler, int x, int y, unsigned char col, int repeat); |
| /* render a horizontal line of length len starting at x/y */ |
| void video_hline(struct video_handler *handler, int x, int y, int len, unsigned char color); |
| /* render a vertical line of length len starting at x/y */ |
| void video_vline(struct video_handler *handler, int x, int y, int len, unsigned char color); |
| void video_line(struct video_handler *handler, int x1, int y1, int x2, int y2, unsigned char color); |
| void video_rect(struct video_handler *handler, int x, int y, int width, int height, unsigned char color); |
| /* renders a rectangle on screen, at position x/y, filled with color */ |
| void video_rectfill(struct video_handler *handler, int x, int y, int width, int height, unsigned char color); |
| void video_setpalette(unsigned char index, unsigned char r, unsigned char g, unsigned char b); |
| void video_getpalette(unsigned char index, unsigned char *r, unsigned char *g, unsigned char *b); |
| #endif |
| /sved/tags/2023.5/mdr/inc/mdr/wave.h |
|---|
| 0,0 → 1,42 |
| /* |
| * WAVE-loading routines |
| * |
| * Copyright (C) 2022 Mateusz Viste |
| * |
| * Permission is hereby granted, free of charge, to any person obtaining a copy |
| * of this software and associated documentation files (the "Software"), to |
| * deal in the Software without restriction, including without limitation the |
| * rights to use, copy, modify, merge, publish, distribute, sublicense, and/or |
| * sell copies of the Software, and to permit persons to whom the Software is |
| * furnished to do so, subject to the following conditions: |
| * |
| * The above copyright notice and this permission notice shall be included in |
| * all copies or substantial portions of the Software. |
| * |
| * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR |
| * IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY, |
| * FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE |
| * AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER |
| * LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING |
| * FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS |
| * IN THE SOFTWARE. |
| */ |
| #ifndef MDR_WAVE_H |
| #define MDR_WAVE_H |
| struct wave_t { |
| unsigned short format; |
| unsigned short channels; |
| unsigned short rate; |
| unsigned short bitdepth; |
| unsigned long dataoffset; |
| unsigned long len; |
| }; |
| /* looks at an open WAVE file and fills the wav structure with related |
| * information (format, number of channels, bit depth, data rate, etc) |
| * returns 0 on success */ |
| int wave_anal(struct wave_t *wav, FILE *fd); |
| #endif |
| /sved/tags/2023.5/mdr/inc/mdr/xms.h |
|---|
| 0,0 → 1,51 |
| /* |
| * XMS driver |
| * |
| * This file is part of the Mateusz' DOS Routines (MDR): http://mdr.osdn.io |
| * Published under the terms of the MIT License, as stated below. |
| * |
| * Copyright (C) 2014-2022 Mateusz Viste |
| * |
| * Permission is hereby granted, free of charge, to any person obtaining a copy |
| * of this software and associated documentation files (the "Software"), to |
| * deal in the Software without restriction, including without limitation the |
| * rights to use, copy, modify, merge, publish, distribute, sublicense, and/or |
| * sell copies of the Software, and to permit persons to whom the Software is |
| * furnished to do so, subject to the following conditions: |
| * |
| * The above copyright notice and this permission notice shall be included in |
| * all copies or substantial portions of the Software. |
| * |
| * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR |
| * IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY, |
| * FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE |
| * AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER |
| * LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING |
| * FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS |
| * IN THE SOFTWARE. |
| */ |
| #ifndef MDR_XMS_H |
| #define MDR_XMS_H |
| struct xms_struct { |
| unsigned int handle; |
| long memsize; /* allocated memory size, in bytes */ |
| }; |
| /* checks if a XMS driver is installed, inits it and allocates a memory block of memsize K-bytes. |
| * if memsize is 0, then the maximum possible block will be allocated. |
| * returns the amount of allocated memory (in K-bytes) on success, 0 otherwise. */ |
| unsigned int xms_init(struct xms_struct *xms, unsigned int memsize); |
| /* free XMS memory */ |
| void xms_close(struct xms_struct *xms); |
| /* copies a chunk of memory from conventional memory into the XMS block. |
| returns 0 on sucess, non-zero otherwise. */ |
| int xms_push(struct xms_struct *xms, void far *src, unsigned int len, long xmsoffset); |
| /* copies a chunk of memory from the XMS block into conventional memory */ |
| int xms_pull(struct xms_struct *xms, long xmsoffset, void far *dst, unsigned int len); |
| #endif |