/*  _______         ____    __         ___    ___ * \    _  \       \    /  \  /       \   \  /   /       '   '  ' *  |  | \  \       |  |    ||         |   \/   |         .      . *  |  |  |  |      |  |    ||         ||\  /|  | *  |  |  |  |      |  |    ||         || \/ |  |         '  '  ' *  |  |  |  |      |  |    ||         ||    |  |         .      . *  |  |_/  /        \  \__//          ||    |  | * /_______/ynamic    \____/niversal  /__\  /____\usic   /|  .  . ibliotheque *                                                      /  \ *                                                     / .  \ * dumb.h - The user header file for DUMB.            / / \  \ *                                                   | <  /   \_ * Include this file in any of your files in         |  \/ /\   / * which you wish to use the DUMB functions           \_  /  > / * and variables.                                       | \ / / *                                                      |  ' / * Allegro users, you will probably want aldumb.h.       \__/ */ #ifndef DUMB_H#define DUMB_H #if !defined(__plan9__) && !defined(USED)#define USED(x) (void)(x)#endif #include <stdlib.h>#include <stdio.h> #ifdef _DEBUG#ifdef _MSC_VER#define _CRTDBG_MAP_ALLOC#include <crtdbg.h>#endif#endif #ifdef __cplusplusextern "C" {#endif /* * When you bump major, minor, or patch, bump both the number and the string. * When you bump major or minor version, bump them in CMakeLists.txt, too. */#define DUMB_MAJOR_VERSION 2#define DUMB_MINOR_VERSION 0#define DUMB_REVISION_VERSION 2#define DUMB_VERSION_STR "2.0.2" #define DUMB_VERSION                                                           \    (DUMB_MAJOR_VERSION * 10000 + DUMB_MINOR_VERSION * 100 +                   \     DUMB_REVISION_VERSION)#define DUMB_NAME "DUMB v" DUMB_VERSION_STR #ifdef DEBUGMODE #ifndef ASSERT#include <assert.h>#define ASSERT(n) assert(n)#endif#ifndef TRACE// it would be nice if this did actually trace ...#define TRACE 1 ? (void)0 : (void)printf#endif #else #ifndef ASSERT#define ASSERT(n)#endif#ifndef TRACE#define TRACE 1 ? (void)0 : (void)printf#endif #endif // DEBUGMODE #define DUMB_ID(a, b, c, d)                                                    \    (((unsigned int)(a) << 24) | ((unsigned int)(b) << 16) |                   \     ((unsigned int)(c) << 8) | ((unsigned int)(d))) #if __GNUC__ * 100 + __GNUC_MINOR__ >= 301 /* GCC 3.1+ */#ifndef DUMB_DECLARE_DEPRECATED#define DUMB_DECLARE_DEPRECATED#endif#define DUMB_DEPRECATED __attribute__((__deprecated__))#else#define DUMB_DEPRECATED#endif /* Basic Sample Type. Normal range is -0x800000 to 0x7FFFFF. */ typedef int sample_t; /* Library Clean-up Management */ int dumb_atexit(void (*proc)(void)); void dumb_exit(void); /* File Input Functions */#ifdef DUMB_OFF_T_CUSTOMtypedef DUMB_OFF_T_CUSTOM dumb_off_t;#elif defined _MSC_VER || defined __WATCOMC__typedef __int64 dumb_off_t;#elif defined __DJGPP__ || defined __MINGW32__/* MingW-W64 does not have off64_t and supports _FILE_OFFSET_BITS, * DJGPP and old MinGW do have off64_t, but don't support _FILE_OFFSET_BITS. */#include <sys/types.h>#if defined(__MINGW64_VERSION_MAJOR)typedef off_t dumb_off_t;#elsetypedef off64_t dumb_off_t;#endif#elif defined __ANDROID__/* Android NDK does not support _FILE_OFFSET_BITS before API level 24 * and off_t is is always 32-bit regardless of _FILE_OFFSET_BITS. */#include <sys/types.h>typedef off64_t dumb_off_t;#elif defined __EMSCRIPTEN__#include <sys/types.h>typedef int64_t dumb_off_t;#elif _POSIX_C_SOURCE >= 200112L || _XOPEN_SOURCE >= 500#include <sys/types.h>typedef off_t dumb_off_t;#elsetypedef long long dumb_off_t;#endif /* * If the build fails here, it does so, because we need a 64-bit-type for * defining offsets. To fix this do either of the following: * * 1. Compile your code with -D_FILE_OFFSET_BITS=64, so that off_t is 64-bit *    (recommended, but make sure the rest of your code can handle it) * 2. Supply your own definition of a signed 64-bit integer *    such as off64_t or int64_t before including dumb.h as follows: *    #define DUMB_OFF_T_CUSTOM int64_t */#if (__GNUC__ > 4 || (__GNUC__ == 4 && __GNUC_MINOR__ >= 6)) &&                \    !defined __cplusplus_Static_assert(sizeof(dumb_off_t) >= 8, "dumb: off_t must be 64bit");#elsestruct dumb_off_t_needs_to_be_at_least_8_bytes {    unsigned int dumb_off_t_needs_to_be_at_least_8_bytes_        : ((sizeof(dumb_off_t) >= 8) ? 1 : -42);};#endif /* * ssize_t is defined in POSIX to hold either a size_t or an error. * We will use dumb_ssize_t on all platforms for (either size_t or error) in * all getnc-type functions. See DUMBFILE_SYSTEM.md for that function's spec. */#if defined(_MSC_VER)#include <BaseTsd.h>typedef SSIZE_T dumb_ssize_t;#else#include <sys/types.h>typedef ssize_t dumb_ssize_t;#endif /* * DUMB provides an abstraction over files, to work with memory-mapped files, * files on disk, files read into memory by other libraries in their own * custom formats, ... * * Register your own file-handling functions as callbacks via this struct. * DUMB 2.0 doesn't use long anymore. The 64-bit dumb_*_t are defined above. * * See DUMBFILE_SYSTEM.md in project's root for a complete spec. */typedef struct DUMBFILE_SYSTEM {    /* open */    /* Open filename. Returned file may be of any custom type. */    void *(*open)(const char *filename);     /* skip */    /* Ignore the next n bytes in file f. Returns 0 on succes, -1 on error. */    int (*skip)(void *f, dumb_off_t n);     /* getc */    /* Read the next byte. Returns byte as unsigned, or -1 on error. */    int (*getc)(void *f);     /* getnc */    /* Read n bytes into buffer ptr. Returns number of bytes read or -1. */    dumb_ssize_t (*getnc)(char *ptr, size_t n, void *f);     /* close */    /* Called when DUMB is done with the file. User code may do anything. */    void (*close)(void *f);     /* seek */    /* Jump to offset in bytes from beginning. Returns 0 if OK, -1 on error. */    int (*seek)(void *f, dumb_off_t offset);     /* get_size */    /* Returns the size in bytes of the file. */    dumb_off_t (*get_size)(void *f);} DUMBFILE_SYSTEM; typedef struct DUMBFILE DUMBFILE;#ifdef __plan9__#pragma incomplete DUMBFILE#endif void register_dumbfile_system(const DUMBFILE_SYSTEM *dfs); DUMBFILE *dumbfile_open(const char *filename);DUMBFILE *dumbfile_open_ex(void *file, const DUMBFILE_SYSTEM *dfs); dumb_off_t dumbfile_pos(DUMBFILE *f);int dumbfile_skip(DUMBFILE *f, dumb_off_t n); #define DFS_SEEK_SET 0#define DFS_SEEK_CUR 1#define DFS_SEEK_END 2 int dumbfile_seek(DUMBFILE *f, dumb_off_t n, int origin); dumb_off_t dumbfile_get_size(DUMBFILE *f); int dumbfile_getc(DUMBFILE *f); int dumbfile_igetw(DUMBFILE *f);int dumbfile_mgetw(DUMBFILE *f); long dumbfile_igetl(DUMBFILE *f);long dumbfile_mgetl(DUMBFILE *f); unsigned long dumbfile_cgetul(DUMBFILE *f);signed long dumbfile_cgetsl(DUMBFILE *f); dumb_ssize_t dumbfile_getnc(char *ptr, size_t n, DUMBFILE *f); int dumbfile_error(DUMBFILE *f);int dumbfile_close(DUMBFILE *f); /* stdio File Input Module */ void dumb_register_stdfiles(void); DUMBFILE *dumbfile_open_stdfile(FILE *p); /* Memory File Input Module */ DUMBFILE *dumbfile_open_memory(const char *data, size_t size); /* DUH Management */ typedef struct DUH DUH;#ifdef __plan9__#pragma incomplete DUH#endif #define DUH_SIGNATURE DUMB_ID('D', 'U', 'H', '!') void unload_duh(DUH *duh); DUH *load_duh(const char *filename);DUH *read_duh(DUMBFILE *f); dumb_off_t duh_get_length(DUH *duh); const char *duh_get_tag(DUH *duh, const char *key);int duh_get_tag_iterator_size(DUH *duh);int duh_get_tag_iterator_get(DUH *duh, const char **key, const char **tag,                             int i); /* Signal Rendering Functions */ typedef struct DUH_SIGRENDERER DUH_SIGRENDERER;#ifdef __plan9__#pragma incomplete DUH_SIGRENDERER#endif DUH_SIGRENDERER *duh_start_sigrenderer(DUH *duh, int sig, int n_channels,                                       long pos); typedef void (*DUH_SIGRENDERER_SAMPLE_ANALYSER_CALLBACK)(    void *data, const sample_t *const *samples, int n_channels, long length); void duh_sigrenderer_set_sample_analyser_callback(    DUH_SIGRENDERER *sigrenderer,    DUH_SIGRENDERER_SAMPLE_ANALYSER_CALLBACK callback, void *data); int duh_sigrenderer_get_n_channels(DUH_SIGRENDERER *sigrenderer);long duh_sigrenderer_get_position(DUH_SIGRENDERER *sigrenderer); void duh_sigrenderer_set_sigparam(DUH_SIGRENDERER *sigrenderer,                                  unsigned char id, long value); long duh_sigrenderer_generate_samples(DUH_SIGRENDERER *sigrenderer,                                      float volume, float delta, long size,                                      sample_t **samples); void duh_sigrenderer_get_current_sample(DUH_SIGRENDERER *sigrenderer,                                        float volume, sample_t *samples); void duh_end_sigrenderer(DUH_SIGRENDERER *sigrenderer); /* DUH Rendering Functions */ /* For packed integers: 8, 16, 24-bit wide. * Intermediary buffer sig_samples must be freed with destroy_sample_buffer() * in the end of the rendering loop. */long duh_render_int(DUH_SIGRENDERER *sigrenderer, sample_t ***sig_samples,                    long *sig_samples_size, int bits, int unsign, float volume,                    float delta, long size, void *sptr); /* For floats: 32, 64-bit wide. * Intermediary buffer sig_samples must be freed with destroy_sample_buffer() * in the end of the rendering loop. */long duh_render_float(DUH_SIGRENDERER *sigrenderer, sample_t ***sig_samples,                      long *sig_samples_size, int bits, float volume,                      float delta, long size, void *sptr); #ifdef DUMB_DECLARE_DEPRECATED /* DEPRECATED since 2.0.0. Please use duh_render_int or duh_render_float. */long duh_render(DUH_SIGRENDERER *sigrenderer, int bits, int unsign,                float volume, float delta, long size,                void *sptr) DUMB_DEPRECATED; #endif /* Impulse Tracker Support */ extern int dumb_it_max_to_mix; typedef struct DUMB_IT_SIGDATA DUMB_IT_SIGDATA;typedef struct DUMB_IT_SIGRENDERER DUMB_IT_SIGRENDERER;#ifdef __plan9__#pragma incomplete DUMB_IT_SIGDATA#pragma incomplete DUMB_IT_SIGRENDERER#endif DUMB_IT_SIGDATA *duh_get_it_sigdata(DUH *duh);DUH_SIGRENDERER *duh_encapsulate_it_sigrenderer(DUMB_IT_SIGRENDERER *it_sigrenderer,                               int n_channels, long pos);DUMB_IT_SIGRENDERER *duh_get_it_sigrenderer(DUH_SIGRENDERER *sigrenderer); int dumb_it_trim_silent_patterns(DUH *duh); typedef int (*dumb_scan_callback)(void *, int, long);int dumb_it_scan_for_playable_orders(DUMB_IT_SIGDATA *sigdata,                                     dumb_scan_callback callback,                                     void *callback_data); DUH_SIGRENDERER *dumb_it_start_at_order(DUH *duh, int n_channels,                                        int startorder); enum {    DUMB_IT_RAMP_NONE = 0,    DUMB_IT_RAMP_ONOFF_ONLY = 1,    DUMB_IT_RAMP_FULL = 2}; void dumb_it_set_ramp_style(DUMB_IT_SIGRENDERER *sigrenderer, int ramp_style); void dumb_it_set_loop_callback(DUMB_IT_SIGRENDERER *sigrenderer,                               int (*callback)(void *data), void *data);void dumb_it_set_xm_speed_zero_callback(DUMB_IT_SIGRENDERER *sigrenderer,                                        int (*callback)(void *data),                                        void *data);void dumb_it_set_midi_callback(DUMB_IT_SIGRENDERER *sigrenderer,                               int (*callback)(void *data, int channel,                                               unsigned char midi_byte),                               void *data);void dumb_it_set_global_volume_zero_callback(DUMB_IT_SIGRENDERER *sigrenderer,                                             int (*callback)(void *data),                                             void *data); int dumb_it_callback_terminate(void *data);int dumb_it_callback_midi_block(void *data, int channel,                                unsigned char midi_byte); /* dumb_*_mod*: restrict_ - OR these together */enum {    DUMB_MOD_RESTRICT_NO_15_SAMPLE = (1 << 0), /* Don't load 15 sample files,                                                  which have no identifying                                                  signature */    DUMB_MOD_RESTRICT_OLD_PATTERN_COUNT =        (1 << 1) /* Use old pattern counting method */}; DUH *dumb_load_it(const char *filename);DUH *dumb_load_xm(const char *filename);DUH *dumb_load_s3m(const char *filename);DUH *dumb_load_stm(const char *filename);DUH *dumb_load_mod(const char *filename, int restrict_);DUH *dumb_load_ptm(const char *filename);DUH *dumb_load_669(const char *filename);DUH *dumb_load_psm(const char *filename, int subsong);DUH *dumb_load_old_psm(const char *filename);DUH *dumb_load_mtm(const char *filename);DUH *dumb_load_riff(const char *filename);DUH *dumb_load_asy(const char *filename);DUH *dumb_load_amf(const char *filename);DUH *dumb_load_okt(const char *filename); DUH *dumb_read_it(DUMBFILE *f);DUH *dumb_read_xm(DUMBFILE *f);DUH *dumb_read_s3m(DUMBFILE *f);DUH *dumb_read_stm(DUMBFILE *f);DUH *dumb_read_mod(DUMBFILE *f, int restrict_);DUH *dumb_read_ptm(DUMBFILE *f);DUH *dumb_read_669(DUMBFILE *f);DUH *dumb_read_psm(DUMBFILE *f, int subsong);DUH *dumb_read_old_psm(DUMBFILE *f);DUH *dumb_read_mtm(DUMBFILE *f);DUH *dumb_read_riff(DUMBFILE *f);DUH *dumb_read_asy(DUMBFILE *f);DUH *dumb_read_amf(DUMBFILE *f);DUH *dumb_read_okt(DUMBFILE *f); DUH *dumb_load_it_quick(const char *filename);DUH *dumb_load_xm_quick(const char *filename);DUH *dumb_load_s3m_quick(const char *filename);DUH *dumb_load_stm_quick(const char *filename);DUH *dumb_load_mod_quick(const char *filename, int restrict_);DUH *dumb_load_ptm_quick(const char *filename);DUH *dumb_load_669_quick(const char *filename);DUH *dumb_load_psm_quick(const char *filename, int subsong);DUH *dumb_load_old_psm_quick(const char *filename);DUH *dumb_load_mtm_quick(const char *filename);DUH *dumb_load_riff_quick(const char *filename);DUH *dumb_load_asy_quick(const char *filename);DUH *dumb_load_amf_quick(const char *filename);DUH *dumb_load_okt_quick(const char *filename); DUH *dumb_read_it_quick(DUMBFILE *f);DUH *dumb_read_xm_quick(DUMBFILE *f);DUH *dumb_read_s3m_quick(DUMBFILE *f);DUH *dumb_read_stm_quick(DUMBFILE *f);DUH *dumb_read_mod_quick(DUMBFILE *f, int restrict_);DUH *dumb_read_ptm_quick(DUMBFILE *f);DUH *dumb_read_669_quick(DUMBFILE *f);DUH *dumb_read_psm_quick(DUMBFILE *f, int subsong);DUH *dumb_read_old_psm_quick(DUMBFILE *f);DUH *dumb_read_mtm_quick(DUMBFILE *f);DUH *dumb_read_riff_quick(DUMBFILE *f);DUH *dumb_read_asy_quick(DUMBFILE *f);DUH *dumb_read_amf_quick(DUMBFILE *f);DUH *dumb_read_okt_quick(DUMBFILE *f); DUH *dumb_read_any_quick(DUMBFILE *f, int restrict_, int subsong);DUH *dumb_read_any(DUMBFILE *f, int restrict_, int subsong); DUH *dumb_load_any_quick(const char *filename, int restrict_, int subsong);DUH *dumb_load_any(const char *filename, int restrict_, int subsong); long dumb_it_build_checkpoints(DUMB_IT_SIGDATA *sigdata, int startorder);void dumb_it_do_initial_runthrough(DUH *duh); int dumb_get_psm_subsong_count(DUMBFILE *f); const unsigned char *dumb_it_sd_get_song_message(DUMB_IT_SIGDATA *sd); int dumb_it_sd_get_n_orders(DUMB_IT_SIGDATA *sd);int dumb_it_sd_get_n_samples(DUMB_IT_SIGDATA *sd);int dumb_it_sd_get_n_instruments(DUMB_IT_SIGDATA *sd); const unsigned char *dumb_it_sd_get_sample_name(DUMB_IT_SIGDATA *sd, int i);const unsigned char *dumb_it_sd_get_sample_filename(DUMB_IT_SIGDATA *sd, int i);const unsigned char *dumb_it_sd_get_instrument_name(DUMB_IT_SIGDATA *sd, int i);const unsigned char *dumb_it_sd_get_instrument_filename(DUMB_IT_SIGDATA *sd,                                                        int i); int dumb_it_sd_get_initial_global_volume(DUMB_IT_SIGDATA *sd);void dumb_it_sd_set_initial_global_volume(DUMB_IT_SIGDATA *sd, int gv); int dumb_it_sd_get_mixing_volume(DUMB_IT_SIGDATA *sd);void dumb_it_sd_set_mixing_volume(DUMB_IT_SIGDATA *sd, int mv); int dumb_it_sd_get_initial_speed(DUMB_IT_SIGDATA *sd);void dumb_it_sd_set_initial_speed(DUMB_IT_SIGDATA *sd, int speed); int dumb_it_sd_get_initial_tempo(DUMB_IT_SIGDATA *sd);void dumb_it_sd_set_initial_tempo(DUMB_IT_SIGDATA *sd, int tempo); int dumb_it_sd_get_initial_channel_volume(DUMB_IT_SIGDATA *sd, int channel);void dumb_it_sd_set_initial_channel_volume(DUMB_IT_SIGDATA *sd, int channel,                                           int volume); int dumb_it_sr_get_current_order(DUMB_IT_SIGRENDERER *sr);int dumb_it_sr_get_current_row(DUMB_IT_SIGRENDERER *sr); int dumb_it_sr_get_global_volume(DUMB_IT_SIGRENDERER *sr);void dumb_it_sr_set_global_volume(DUMB_IT_SIGRENDERER *sr, int gv); int dumb_it_sr_get_tempo(DUMB_IT_SIGRENDERER *sr);void dumb_it_sr_set_tempo(DUMB_IT_SIGRENDERER *sr, int tempo); int dumb_it_sr_get_speed(DUMB_IT_SIGRENDERER *sr);

Lines 1–500 of 848. Load more