diff --git a/Frameworks/Dumb/dumb/release.txt b/Frameworks/Dumb/dumb/CHANGELOG.md similarity index 96% rename from Frameworks/Dumb/dumb/release.txt rename to Frameworks/Dumb/dumb/CHANGELOG.md index 527d44933..1849aed6b 100644 --- a/Frameworks/Dumb/dumb/release.txt +++ b/Frameworks/Dumb/dumb/CHANGELOG.md @@ -1,3 +1,4 @@ +``` /* _______ ____ __ ___ ___ * \ _ \ \ / \ / \ \ / / ' ' ' * | | \ \ | | || | \/ | . . @@ -8,7 +9,7 @@ * /_______/ynamic \____/niversal /__\ /____\usic /| . . ibliotheque * / \ * / . \ - * release.txt - Release notes for DUMB. / / \ \ + * CHANGELOG.md - Release notes for DUMB. / / \ \ * | < / \_ * | \/ /\ / * \_ / > / @@ -16,11 +17,35 @@ * | ' / * \__/ */ + ``` +# DUMB Changelog -******************************************* -*** DUMB v0.9.3, released 7 August 2005 *** -******************************************* +## v2.0.0, released 26 September 2017 + +* Memory leak and bug fixes +* Audio playback quality improvements for STM +* Added support for FEST MOD files +* Default resampling quality is now cubic +* Allegro 4 support +* New dumbplay, dumbout examples +* Multiple cmake fixes +* Deprecated `duh_render()`, use `duh_render_float()` and `duh_render_int()` +* Removed API deprecated since 0.9.3, see the + [DUMB 0.9.3 deprecation reference](http://dumb.sourceforge.net/index.php?page=docs&doc=deprec) + +## v1.0.0, released 17 January 2015 + +* Support newer compilers +* Better audio playback quality +* More supported formats +* SSE optimizations support +* CMake support +* New resamplers +* Seek support +* Fixes, cleanups, speedups. + +## v0.9.3, released 7 August 2005 Hello! Welcome to a long-awaited-or-probably-just-given-up-on-by-everybody release! New to this release are lower memory usage, faster mixing loops, @@ -173,9 +198,7 @@ That's it! I hope you enjoy this long-awaited-or-probably-just-given-up-on- by-everybody release of DUMB! -****************************************** -*** DUMB v0.9.2, released 2 April 2003 *** -****************************************** +## v0.9.2, released 2 April 2003 Yes, there really has been a release. This is not a day-late April fools' joke. @@ -272,9 +295,7 @@ explained in licence.txt. However, the request is still there ... As usual, enjoy! -********************************************** -*** DUMB v0.9.1, released 19 December 2002 *** -********************************************** +## v0.9.1, released 19 December 2002 Hi again! Lots to say this time, so I shall cut right to the chase. @@ -355,9 +376,7 @@ the last release; they are relevant for this release too. That's all folks! Until next time. -******************************************* -*** DUMB v0.9, released 16 October 2002 *** -******************************************* +## v0.9, released 16 October 2002 MOD support is here! DUMB now supports all four of the common module formats. As usual, there have also been some improvements to the way modules are @@ -431,9 +450,7 @@ Off you go. Bye. -******************************************** -*** DUMB v0.8.1, released 11 August 2002 *** -******************************************** +## v0.8.1, released 11 August 2002 This is a minor release that fixes a few bugs. One of these bugs, however, was pretty serious. dumb_register_dat_xm() was never coded! It was prototyped @@ -487,9 +504,7 @@ The point about length not being calculated also applies to XM files. Enjoy :) -**************************************** -*** DUMB v0.8, released 14 June 2002 *** -**************************************** +## v0.8, released 14 June 2002 Welcome to the second release of DUMB! @@ -530,9 +545,7 @@ going myself (72 GBP, and I'd have to wear a suit, ugh), but with all the noise outside I shall enjoy pumping up the speakers tonight! -**************************************** -*** DUMB v0.7, released 2 March 2002 *** -**************************************** +## DUMB v0.7, released 2 March 2002 This is the first release of DUMB, and parts of the library are not crystallised. Don't let this put you off! Provided you don't try to use any diff --git a/Frameworks/Dumb/dumb/COMPILING.md b/Frameworks/Dumb/dumb/COMPILING.md new file mode 100644 index 000000000..a784f480c --- /dev/null +++ b/Frameworks/Dumb/dumb/COMPILING.md @@ -0,0 +1,35 @@ +# Compiling + +## 1. CMake + +### 1.1. Example + +In libdumb project root, run: +``` +mkdir -p build +cd build +cmake -DCMAKE_BUILD_TYPE=Release -DCMAKE_INSTALL_PREFIX=/usr/local -DBUILD_SHARED_LIBS:BOOL=ON -DBUILD_ALLEGRO4:BOOL=ON .. +make +make install +``` + +### 1.2. Steps + +1. Create a new temporary build directory and cd into it +2. Run libdumb cmake file with cmake (eg. `cmake -DCMAKE_INSTALL_PREFIX=/install/dir -DBUILD_SHARED_LIBS:BOOL=ON -DCMAKE_BUILD_TYPE=Release path/to/dumb/cmake/dir`). +3. Run make (eg. just `make` or `mingw32-make` or something). +4. If needed, run make install. + +### 1.3. Flags + +* `CMAKE_INSTALL_PREFIX` sets the installation path prefix. +* `CMAKE_BUILD_TYPE` chooses the build type: `Release`, `Debug`, `RelWithDebInfo`, or `MinSizeRel`. Debug libraries will be named `libdumbd`, release libraries `libdumb`. Default is `Release`. +* `BUILD_SHARED_LIBS` selects whether cmake should build a dynamic (`ON`) or static (`OFF`) library. Default is `OFF`. +* `BUILD_ALLEGRO4` enables (`ON`) or disables (`OFF`) the optional Allegro 4 support. This requires Allegro 4 installed on the system. Default is `ON`. +* `BUILD_EXAMPLES` selects example binaries. These example binaries require argtable2 and SDL2 libraries. Default is `ON`. +* `USE_SSE` enables or disables SSE support. Default is `ON`. +* You may also need to tell cmake what kind of makefiles to create with the "-G" flag. Eg. for MSYS one would say something like `cmake -G "MSYS Makefiles" .`. + +## 2. Visual Studio + +TODO diff --git a/Frameworks/Dumb/dumb/DUMBFILE_SYSTEM.md b/Frameworks/Dumb/dumb/DUMBFILE_SYSTEM.md new file mode 100644 index 000000000..085b7c0b1 --- /dev/null +++ b/Frameworks/Dumb/dumb/DUMBFILE_SYSTEM.md @@ -0,0 +1,226 @@ +Specification of DUMBFILE_SYSTEM +================================ + +DUMB is designed filesystem-agnostic, even though the C standard library +already defines an abstraction over files on a disk. This is useful because +Allegro 4 and 5 define their own abstractions. + +To register your own filesystem abstraction with DUMB, you must create an +instance of struct `DUMBFILE_SYSTEM`, fill in your own function pointers +according to the specification below, and call `register_dumbfile_system` on +your instance. + +The header `dumb.h` defines `DUMBFILE_SYSTEM` as a struct of function pointers: + +``` +typedef struct DUMBFILE_SYSTEM +{ + void *(*open)(const char *filename); + int (*skip)(void *f, dumb_off_t n); + int (*getc)(void *f); + dumb_ssize_t (*getnc)(char *ptr, size_t n, void *f); + void (*close)(void *f); + int (*seek)(void *f, dumb_off_t n); + dumb_off_t (*get_size)(void *f); +} +DUMBFILE_SYSTEM; +``` + +Here, `dumb_off_t` is a signed integer at least 64 bits wide, it is intended +to measure file offsets. The return type `dumb_ssize_t` is a signed integer +exactly as wide as `size_t`, it is intended to store either a `size_t` or a +negative error code. Both `dumb_*_t` are defined in `dumb.h`. + +The function pointers `skip` and `getnc` are optional, i.e., you may set +some of these to `NULL` in your struct instance. DUMB will then try to +mimick the missing functions' behavior by calling your `getc` several times. +If DUMB is built with debugging flags, it will assert that all other +functions are not `NULL`. In release mode, DUMB will silently fail. + +Your non-`NULL` function pointers must conform to the following specification. + + + +open +---- + +``` +void *(*open)(const char *filename); +``` + +Open a file for reading. + +Arguments: + +* `const char *filename`: A normal filename as understood by the operating + system. Will be opened for reading. + +Returns as `void *`: + +* the address of a file handle on successfully opening the file. + DUMB will pass this file handle as argument to other functions of + the `DUMBFILE_SYSTEM`. + +* `NULL` on error during opening the file. + +Each file has a *position* internally managed by DUMB. A newly opened file +has a position of 0. Other functions from the `DUMBFILE_SYSTEM` can move +this position around. + +DUMB allocates memory for the successfully opened file, and will store opaque +information in that memory, e.g., the DUMB-internal file position. This memory +be freed when DUMB calls `close` on the file's handle. The memory is separate +from your own filesystem implementation: You are responsible for supplying the +data, and DUMB is responsible for storing anything about interpreting that +data. + + + +skip +---- + +``` +int (*skip)(void *f, dumb_off_t n); +``` + +Advance the position in the file. + +Arguments: + +* `void *f`: A file handle that `open` returned. Guaranteed non-`NULL`. + +* `dumb_off_t n`: Number of bytes to advance in the file. DUMB will only +call this with `n >= 0`. For `n < 0`, the behavior of `skip` is undefined. + +Returns as `int`: + +* `0` on successfully skipping ahead by `n` bytes. + +* `-1` on error. + +It is legal to set `skip = NULL` in a `DUMBFILE_SYSTEM`. DUMB will then call +`getc` a total of `n` times to skip ahead in a file. For speed, it is +advisable to supply a proper `skip` implementation. + + + +getc +---- + +``` +int (*getc)(void *f); +``` + +Read a byte from the file. + +Arguments: + +* `void *f`: A file handle that `open` returned. Guaranteed non-`NULL`. + +Returns as `int`: + +* the value of the byte read, on successfully reading one byte. + +* `-1` on error. + +After a succesful read, DUMB will treat the file as advanced by one byte. + + + +getnc +----- + +``` +dumb_ssize_t (*getnc)(char *ptr, size_t n, void *f); +``` + +Read up to the given number of bytes from the file into a given buffer. + +* `char *ptr`: The start of a buffer provided by DUMB. + +* `size_t n`: The length of the number of bytes to be read. + +* `void *f`: A file handle that `open` returned. Guaranteed non-`NULL`. + +Returns as `dumb_ssize_t`: + +* the number of bytes successfully read, if it was possible to read at least +one byte. + +* `-1` on error. + +This function shall bytes from the file `f` and store them in sequence in the +buffer beginning at `ptr`. It shall read fewer than `n` bytes if end of file +is encountered before `n` bytes could have been read, otherwise it should read +`n` bytes. + +It is legal to set `skip = NULL` in a `DUMBFILE_SYSTEM`. DUMB will then call +`getc` a total of `n` times and store the results in its buffer. + + + +close +----- + +``` +void (*close)(void *f); +``` + +Closes a file that has been opened before with `open`. + +Arguments: + +* `void *f`: A file handle that `open` returned. Guaranteed non-`NULL`. + +DUMB will deallocate the memory that it used to interpret the file. You are +free to treat your resource however you would like: You may deallocate it, or +keep it around for other things. For example, Allegro 5's implementation +of `close` takes a void pointer and does nothing with it at all. + + + +seek +---- + +``` +int (*seek)(void *f, dumb_off_t n); +``` + +Jump to an arbitrary position in the file. + +Arguments: + +* `void *f`: A file handle that `open` returned. Guaranteed non-`NULL`. + +* `dumb_off_t n`: The position in the file, relative to the beginning. + There is no guarantee whether `n >= 0`. + +Returns as `int`: + +* `0` on successfully seeking in the file. + +* `-1` on error. + +DUMB will modify its internal position of the file accordingly. + +A value of `n < 0` shall set the file into an erroneous state from which no +bytes can be read. + + + +get_size +-------- + +``` +dumb_off_t (*get_size)(void *f); +``` + +Get the length in bytes, i.e., the position after the final byte, of a file. + +Arguments: + +* `void *f`: A file handle that `open` returned. Guaranteed non-`NULL`. + +Returns as `dumb_off_t`: + +* the length of the file in bytes. diff --git a/Frameworks/Dumb/dumb/README.md b/Frameworks/Dumb/dumb/README.md new file mode 100644 index 000000000..cf69a7fe1 --- /dev/null +++ b/Frameworks/Dumb/dumb/README.md @@ -0,0 +1,96 @@ +# Dynamic Universal Music Bibliotheque (libdumb) + + _______ ____ __ ___ ___ + \ _ \ \ / \ / \ \ / / ' ' ' + | | \ \ | | || | \/ | . . + | | | | | | || ||\ /| | + | | | | | | || || \/ | | ' ' ' + | | | | | | || || | | . . + | |_/ / \ \__// || | | + /_______/ynamic \____/niversal /__\ /____\usic /| . . ibliotheque + / \ + / . \ + / / \ \ + | < / \_ + | \/ /\ / + \_ / > / + | \ / / + | ' / + \__/ + + + +## Introduction + +DUMB is a module audio renderer library. It reads module files and +outputs audio that can be dumped to the actual audio playback library. + +This is a fork of the original dumb (http://dumb.sf.net/) by Ben Davis. + +## Features + +- Supports playback of the following module formats. The tracker software or + library the format is known for is given in parentheses. This does not mean + that DUMB does not support files created by other trackers provided that they + output files in one of those formats. + + * IT (Impulse Tracker) + * XM (Fasttracker II) + * MOD (Ultimate SoundTracker, ProTracker) + * STM (Scream Tracker) + * S3M (Scream Tracker 3) + * 669 (Composer 669) + * AMF Asylum Music Format + * AMF Digital Sound and Music Interface Advanced Music Format + * DSM Digital Sound Interface Kit module format + * MTM (MultiTracker) + * OKT (Oktalyzer) + * PSM (Protracker Studio) + Both the older PSM16 and the newer PSM format is supported. + * PTM (PolyTracker) + * RIFF AM/AMFF (Galaxy Music System internal format) + +- Audio generated can be used in any way; DUMB does not necessarily send it + straight to a sound output system + +- Portable + +- Faithful to the original trackers, especially IT; if it plays a module + wrongly, it is considered a bug + +- Accurate support for low-pass resonant filters for IT files + +- Very accurate timing and pitching; completely deterministic playback + +- Click removal + +- Six resampling quality settings: aliasing, aliasing with bandwidth limiting, + linear interpolation, linear interpolation with bandwidth limiting, cubic + interpolation, and a compile-time-configurable fast sinc resampler + +- Number of samples playing at once can be limited to reduce processor usage, + but samples will come back in when other louder ones stop + +- Option to take longer loading but seek fast to any point before the music + first loops (seeking time increases beyond this point) + +- All notes will be present and correct even if a module's playback is started + in the middle + +- Optional Allegro 4 or Allegro 5 integration support + +- Facility to embed music files in other files (e.g. Allegro datafiles) + + +## Installation + +Currently you need to compile libdumb yourself. For more details, please see +the file [COMPILING.md](COMPILING.md). + +## License + +See [LICENSE](LICENSE) for license details. + +## Contributing + +Bugs, feature requests and patches can be submitted at https://github.com/kode54/dumb/. diff --git a/Frameworks/Dumb/dumb/include/dumb.h b/Frameworks/Dumb/dumb/include/dumb.h index 3f1144b06..8914f232a 100644 --- a/Frameworks/Dumb/dumb/include/dumb.h +++ b/Frameworks/Dumb/dumb/include/dumb.h @@ -20,7 +20,6 @@ #ifndef DUMB_H #define DUMB_H - #include #include @@ -32,50 +31,22 @@ #endif #ifdef __cplusplus - extern "C" { +extern "C" { #endif - -#define DUMB_MAJOR_VERSION 1 -#define DUMB_MINOR_VERSION 0 -#define DUMB_REVISION_VERSION 0 - -#define DUMB_VERSION (DUMB_MAJOR_VERSION*10000 + DUMB_MINOR_VERSION*100 + DUMB_REVISION_VERSION) - -#define DUMB_VERSION_STR "1.0.0" - -#define DUMB_NAME "DUMB v" DUMB_VERSION_STR - -#define DUMB_YEAR 2015 -#define DUMB_MONTH 1 -#define DUMB_DAY 17 - -#define DUMB_YEAR_STR2 "15" -#define DUMB_YEAR_STR4 "2015" -#define DUMB_MONTH_STR1 "1" -#define DUMB_DAY_STR1 "17" - -#if DUMB_MONTH < 10 -#define DUMB_MONTH_STR2 "0" DUMB_MONTH_STR1 -#else -#define DUMB_MONTH_STR2 DUMB_MONTH_STR1 -#endif - -#if DUMB_DAY < 10 -#define DUMB_DAY_STR2 "0" DUMB_DAY_STR1 -#else -#define DUMB_DAY_STR2 DUMB_DAY_STR1 -#endif - - -/* WARNING: The month and day were inadvertently swapped in the v0.8 release. - * Please do not compare this constant against any date in 2002. In - * any case, DUMB_VERSION is probably more useful for this purpose. +/* + * 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_DATE (DUMB_YEAR*10000 + DUMB_MONTH*100 + DUMB_DAY) - -#define DUMB_DATE_STR DUMB_DAY_STR1 "." DUMB_MONTH_STR1 "." DUMB_YEAR_STR4 +#define DUMB_MAJOR_VERSION 2 +#define DUMB_MINOR_VERSION 0 +#define DUMB_REVISION_VERSION 0 +#define DUMB_VERSION_STR "2.0.0" +#define DUMB_VERSION \ + (DUMB_MAJOR_VERSION * 10000 + DUMB_MINOR_VERSION * 100 + \ + DUMB_REVISION_VERSION) +#define DUMB_NAME "DUMB v" DUMB_VERSION_STR #ifdef DEBUGMODE @@ -97,27 +68,11 @@ #define TRACE 1 ? (void)0 : (void)printf #endif -#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) )) - - - -#ifndef LONG_LONG -#if defined __GNUC__ || defined __INTEL_COMPILER || defined __MWERKS__ -#define LONG_LONG long long -#elif defined _MSC_VER || defined __WATCOMC__ -#define LONG_LONG __int64 -#elif defined __sgi -#define LONG_LONG long long -#else -#error 64-bit integer type unknown -#endif -#endif +#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 @@ -128,32 +83,101 @@ #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_CUSTOM +typedef dumb_off_t DUMB_OFF_T_CUSTOM; +#elif defined _MSC_VER || defined __WATCOMC__ +typedef __int64 dumb_off_t; +#elif defined __DJGPP__ +typedef off64_t dumb_off_t; +#elif _POSIX_C_SOURCE >= 200112L || _XOPEN_SOURCE >= 500 || defined __MINGW32__ +typedef off_t dumb_off_t; +#else +typedef long long dumb_off_t; +#endif -typedef struct DUMBFILE_SYSTEM -{ - void *(*open)(const char *filename); - int (*skip)(void *f, long n); - int (*getc)(void *f); - long (*getnc)(char *ptr, long n, void *f); - void (*close)(void *f); - int (*seek)(void *f, long n); - long (*get_size)(void *f); -} -DUMBFILE_SYSTEM; +/* + * 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, "fuse: off_t must be 64bit"); +#else +struct 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 +typedef SSIZE_T dumb_ssize_t; +#else +#include +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; @@ -162,16 +186,16 @@ void register_dumbfile_system(const DUMBFILE_SYSTEM *dfs); DUMBFILE *dumbfile_open(const char *filename); DUMBFILE *dumbfile_open_ex(void *file, const DUMBFILE_SYSTEM *dfs); -long dumbfile_pos(DUMBFILE *f); -int dumbfile_skip(DUMBFILE *f, long n); +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, long n, int origin); +int dumbfile_seek(DUMBFILE *f, dumb_off_t n, int origin); -long dumbfile_get_size(DUMBFILE *f); +dumb_off_t dumbfile_get_size(DUMBFILE *f); int dumbfile_getc(DUMBFILE *f); @@ -184,199 +208,95 @@ long dumbfile_mgetl(DUMBFILE *f); unsigned long dumbfile_cgetul(DUMBFILE *f); signed long dumbfile_cgetsl(DUMBFILE *f); -long dumbfile_getnc(char *ptr, long n, 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, long size); - +DUMBFILE *dumbfile_open_memory(const char *data, size_t size); /* DUH Management */ typedef struct DUH DUH; -#define DUH_SIGNATURE DUMB_ID('D','U','H','!') +#define DUH_SIGNATURE DUMB_ID('D', 'U', 'H', '!') void unload_duh(DUH *duh); DUH *load_duh(const char *filename); DUH *read_duh(DUMBFILE *f); -long duh_get_length(DUH *duh); +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); +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; -DUH_SIGRENDERER *duh_start_sigrenderer(DUH *duh, int sig, int n_channels, long pos); +DUH_SIGRENDERER *duh_start_sigrenderer(DUH *duh, int sig, int n_channels, + long pos); -#ifdef DUMB_DECLARE_DEPRECATED -typedef void (*DUH_SIGRENDERER_CALLBACK)(void *data, sample_t **samples, int n_channels, long length); -/* This is deprecated, but is not marked as such because GCC tends to - * complain spuriously when the typedef is used later. See comments below. - */ - -void duh_sigrenderer_set_callback( - DUH_SIGRENDERER *sigrenderer, - DUH_SIGRENDERER_CALLBACK callback, void *data -) DUMB_DEPRECATED; -/* The 'callback' argument's type has changed for const-correctness. See the - * DUH_SIGRENDERER_CALLBACK definition just above. Also note that the samples - * in the buffer are now 256 times as large; the normal range is -0x800000 to - * 0x7FFFFF. The function has been renamed partly because its functionality - * has changed slightly and partly so that its name is more meaningful. The - * new one is duh_sigrenderer_set_analyser_callback(), and the typedef for - * the function pointer has also changed, from DUH_SIGRENDERER_CALLBACK to - * DUH_SIGRENDERER_ANALYSER_CALLBACK. (If you wanted to use this callback to - * apply a DSP effect, don't worry; there is a better way of doing this. It - * is undocumented, so contact me and I shall try to help. Contact details - * are in readme.txt.) - */ - -typedef void (*DUH_SIGRENDERER_ANALYSER_CALLBACK)(void *data, const sample_t *const *samples, int n_channels, long length); -/* This is deprecated, but is not marked as such because GCC tends to - * complain spuriously when the typedef is used later. See comments below. - */ - -void duh_sigrenderer_set_analyser_callback( - DUH_SIGRENDERER *sigrenderer, - DUH_SIGRENDERER_ANALYSER_CALLBACK callback, void *data -) DUMB_DEPRECATED; -/* This is deprecated because the meaning of the 'samples' parameter in the - * callback needed to change. For stereo applications, the array used to be - * indexed with samples[channel][pos]. It is now indexed with - * samples[0][pos*2+channel]. Mono sample data are still indexed with - * samples[0][pos]. The array is still 2D because samples will probably only - * ever be interleaved in twos. In order to fix your code, adapt it to the - * new sample layout and then call - * duh_sigrenderer_set_sample_analyser_callback below instead of this - * function. - */ -#endif - -typedef void (*DUH_SIGRENDERER_SAMPLE_ANALYSER_CALLBACK)(void *data, const sample_t *const *samples, int n_channels, long length); +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 -); + 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); +void duh_sigrenderer_set_sigparam(DUH_SIGRENDERER *sigrenderer, + unsigned char id, long value); -#ifdef DUMB_DECLARE_DEPRECATED -long duh_sigrenderer_get_samples( - DUH_SIGRENDERER *sigrenderer, - float volume, float delta, - long size, sample_t **samples -) DUMB_DEPRECATED; -/* The sample format has changed, so if you were using this function, - * you should switch to duh_sigrenderer_generate_samples() and change - * how you interpret the samples array. See the comments for - * duh_sigrenderer_set_analyser_callback(). - */ -#endif +long duh_sigrenderer_generate_samples(DUH_SIGRENDERER *sigrenderer, + float volume, float delta, long size, + sample_t **samples); -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_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. +/* 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 -); +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 -); +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 -long duh_render( - DUH_SIGRENDERER *sigrenderer, - int bits, int unsign, - float volume, float delta, - long size, void *sptr -) DUMB_DEPRECATED; - -long duh_render_signal( - DUH_SIGRENDERER *sigrenderer, - float volume, float delta, - long size, sample_t **samples -) DUMB_DEPRECATED; -/* Please use duh_sigrenderer_generate_samples(), and see the - * comments for the deprecated duh_sigrenderer_get_samples() too. - */ - -typedef DUH_SIGRENDERER DUH_RENDERER DUMB_DEPRECATED; -/* Please use DUH_SIGRENDERER instead of DUH_RENDERER. */ - -DUH_SIGRENDERER *duh_start_renderer(DUH *duh, int n_channels, long pos) DUMB_DEPRECATED; -/* Please use duh_start_sigrenderer() instead. Pass 0 for 'sig'. */ - -int duh_renderer_get_n_channels(DUH_SIGRENDERER *dr) DUMB_DEPRECATED; -long duh_renderer_get_position(DUH_SIGRENDERER *dr) DUMB_DEPRECATED; -/* Please use the duh_sigrenderer_*() equivalents of these two functions. */ - -void duh_end_renderer(DUH_SIGRENDERER *dr) DUMB_DEPRECATED; -/* Please use duh_end_sigrenderer() instead. */ - -DUH_SIGRENDERER *duh_renderer_encapsulate_sigrenderer(DUH_SIGRENDERER *sigrenderer) DUMB_DEPRECATED; -DUH_SIGRENDERER *duh_renderer_get_sigrenderer(DUH_SIGRENDERER *dr) DUMB_DEPRECATED; -DUH_SIGRENDERER *duh_renderer_decompose_to_sigrenderer(DUH_SIGRENDERER *dr) DUMB_DEPRECATED; -/* These functions have become no-ops that just return the parameter. - * So, for instance, replace - * duh_renderer_encapsulate_sigrenderer(my_sigrenderer) - * with - * my_sigrenderer - */ +/* 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; @@ -385,34 +305,54 @@ typedef struct DUMB_IT_SIGDATA DUMB_IT_SIGDATA; typedef struct DUMB_IT_SIGRENDERER DUMB_IT_SIGRENDERER; 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); +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); +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); +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); +DUH_SIGRENDERER *dumb_it_start_at_order(DUH *duh, int n_channels, + int startorder); -enum -{ +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_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); +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); +int dumb_it_callback_midi_block(void *data, int channel, + unsigned char midi_byte); -/* dumb_*_mod*: restrict_ |= 1-Don't read 15 sample files / 2-Use old pattern counting method */ +/* 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); @@ -422,7 +362,7 @@ 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_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); @@ -452,7 +392,7 @@ 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_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); @@ -494,7 +434,8 @@ 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); +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); @@ -509,7 +450,8 @@ 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); +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); @@ -529,34 +471,35 @@ void dumb_it_sr_set_speed(DUMB_IT_SIGRENDERER *sr, int speed); /* Channels passed to any of these functions are 0-based */ int dumb_it_sr_get_channel_volume(DUMB_IT_SIGRENDERER *sr, int channel); -void dumb_it_sr_set_channel_volume(DUMB_IT_SIGRENDERER *sr, int channel, int volume); +void dumb_it_sr_set_channel_volume(DUMB_IT_SIGRENDERER *sr, int channel, + int volume); int dumb_it_sr_get_channel_muted(DUMB_IT_SIGRENDERER *sr, int channel); -void dumb_it_sr_set_channel_muted(DUMB_IT_SIGRENDERER *sr, int channel, int muted); +void dumb_it_sr_set_channel_muted(DUMB_IT_SIGRENDERER *sr, int channel, + int muted); typedef struct DUMB_IT_CHANNEL_STATE DUMB_IT_CHANNEL_STATE; -struct DUMB_IT_CHANNEL_STATE -{ - int channel; /* 0-based; meaningful for NNA channels */ - int sample; /* 1-based; 0 if nothing playing, then other fields undef */ - int freq; /* in Hz */ - float volume; /* 1.0 maximum; affected by ALL factors, inc. mixing vol */ - unsigned char pan; /* 0-64, 100 for surround */ - signed char subpan; /* use (pan + subpan/256.0f) or ((pan<<8)+subpan) */ - unsigned char filter_cutoff; /* 0-127 cutoff=127 AND resonance=0 */ - unsigned char filter_subcutoff; /* 0-255 -> no filters (subcutoff */ - unsigned char filter_resonance; /* 0-127 always 0 in this case) */ - /* subcutoff only changes from zero if filter envelopes are in use. The - * calculation (filter_cutoff + filter_subcutoff/256.0f) gives a more - * accurate filter cutoff measurement as a float. It would often be more - * useful to use a scaled int such as ((cutoff<<8) + subcutoff). - */ +struct DUMB_IT_CHANNEL_STATE { + int channel; /* 0-based; meaningful for NNA channels */ + int sample; /* 1-based; 0 if nothing playing, then other fields undef */ + int freq; /* in Hz */ + float volume; /* 1.0 maximum; affected by ALL factors, inc. mixing vol */ + unsigned char pan; /* 0-64, 100 for surround */ + signed char subpan; /* use (pan + subpan/256.0f) or ((pan<<8)+subpan) */ + unsigned char filter_cutoff; /* 0-127 cutoff=127 AND resonance=0 */ + unsigned char filter_subcutoff; /* 0-255 -> no filters (subcutoff */ + unsigned char filter_resonance; /* 0-127 always 0 in this case) */ + /* subcutoff only changes from zero if filter envelopes are in use. The + * calculation (filter_cutoff + filter_subcutoff/256.0f) gives a more + * accurate filter cutoff measurement as a float. It would often be more + * useful to use a scaled int such as ((cutoff<<8) + subcutoff). + */ }; /* Values of 64 or more will access NNA channels here. */ -void dumb_it_sr_get_channel_state(DUMB_IT_SIGRENDERER *sr, int channel, DUMB_IT_CHANNEL_STATE *state); - +void dumb_it_sr_get_channel_state(DUMB_IT_SIGRENDERER *sr, int channel, + DUMB_IT_CHANNEL_STATE *state); /* Signal Design Helper Values */ @@ -576,7 +519,6 @@ void dumb_it_sr_get_channel_state(DUMB_IT_SIGRENDERER *sr, int channel, DUMB_IT_ */ #define DUMB_PITCH_BASE 1.000225659305069791926712241547647863626 - /* Signal Design Function Types */ typedef void sigdata_t; @@ -584,121 +526,101 @@ typedef void sigrenderer_t; typedef sigdata_t *(*DUH_LOAD_SIGDATA)(DUH *duh, DUMBFILE *file); -typedef sigrenderer_t *(*DUH_START_SIGRENDERER)( - DUH *duh, - sigdata_t *sigdata, - int n_channels, - long pos -); +typedef sigrenderer_t *(*DUH_START_SIGRENDERER)(DUH *duh, sigdata_t *sigdata, + int n_channels, long pos); -typedef void (*DUH_SIGRENDERER_SET_SIGPARAM)( - sigrenderer_t *sigrenderer, - unsigned char id, long value -); +typedef void (*DUH_SIGRENDERER_SET_SIGPARAM)(sigrenderer_t *sigrenderer, + unsigned char id, long value); -typedef long (*DUH_SIGRENDERER_GENERATE_SAMPLES)( - sigrenderer_t *sigrenderer, - float volume, float delta, - long size, sample_t **samples -); +typedef long (*DUH_SIGRENDERER_GENERATE_SAMPLES)(sigrenderer_t *sigrenderer, + float volume, float delta, + long size, sample_t **samples); -typedef void (*DUH_SIGRENDERER_GET_CURRENT_SAMPLE)( - sigrenderer_t *sigrenderer, - float volume, - sample_t *samples -); +typedef void (*DUH_SIGRENDERER_GET_CURRENT_SAMPLE)(sigrenderer_t *sigrenderer, + float volume, + sample_t *samples); -typedef long (*DUH_SIGRENDERER_GET_POSITION)( - sigrenderer_t *sigrenderer -); +typedef long (*DUH_SIGRENDERER_GET_POSITION)(sigrenderer_t *sigrenderer); typedef void (*DUH_END_SIGRENDERER)(sigrenderer_t *sigrenderer); typedef void (*DUH_UNLOAD_SIGDATA)(sigdata_t *sigdata); - /* Signal Design Function Registration */ -typedef struct DUH_SIGTYPE_DESC -{ - long type; - DUH_LOAD_SIGDATA load_sigdata; - DUH_START_SIGRENDERER start_sigrenderer; - DUH_SIGRENDERER_SET_SIGPARAM sigrenderer_set_sigparam; - DUH_SIGRENDERER_GENERATE_SAMPLES sigrenderer_generate_samples; - DUH_SIGRENDERER_GET_CURRENT_SAMPLE sigrenderer_get_current_sample; - DUH_SIGRENDERER_GET_POSITION sigrenderer_get_position; - DUH_END_SIGRENDERER end_sigrenderer; - DUH_UNLOAD_SIGDATA unload_sigdata; -} -DUH_SIGTYPE_DESC; +typedef struct DUH_SIGTYPE_DESC { + long type; + DUH_LOAD_SIGDATA load_sigdata; + DUH_START_SIGRENDERER start_sigrenderer; + DUH_SIGRENDERER_SET_SIGPARAM sigrenderer_set_sigparam; + DUH_SIGRENDERER_GENERATE_SAMPLES sigrenderer_generate_samples; + DUH_SIGRENDERER_GET_CURRENT_SAMPLE sigrenderer_get_current_sample; + DUH_SIGRENDERER_GET_POSITION sigrenderer_get_position; + DUH_END_SIGRENDERER end_sigrenderer; + DUH_UNLOAD_SIGDATA unload_sigdata; +} DUH_SIGTYPE_DESC; void dumb_register_sigtype(DUH_SIGTYPE_DESC *desc); int duh_add_signal(DUH *duh, DUH_SIGTYPE_DESC *desc, sigdata_t *sigdata); - // Decide where to put these functions; new heading? sigdata_t *duh_get_raw_sigdata(DUH *duh, int sig, long type); -DUH_SIGRENDERER *duh_encapsulate_raw_sigrenderer(sigrenderer_t *vsigrenderer, DUH_SIGTYPE_DESC *desc, int n_channels, long pos); +DUH_SIGRENDERER *duh_encapsulate_raw_sigrenderer(sigrenderer_t *vsigrenderer, + DUH_SIGTYPE_DESC *desc, + int n_channels, long pos); sigrenderer_t *duh_get_raw_sigrenderer(DUH_SIGRENDERER *sigrenderer, long type); - /* Standard Signal Types */ -//void dumb_register_sigtype_sample(void); - +// void dumb_register_sigtype_sample(void); /* Sample Buffer Allocation Helpers */ -#ifdef DUMB_DECLARE_DEPRECATED -sample_t **create_sample_buffer(int n_channels, long length) DUMB_DEPRECATED; -/* DUMB has been changed to interleave stereo samples. Use - * allocate_sample_buffer() instead, and see the comments for - * duh_sigrenderer_set_analyser_callback(). - */ -#endif sample_t **allocate_sample_buffer(int n_channels, long length); void destroy_sample_buffer(sample_t **samples); - /* Silencing Helper */ void dumb_silence(sample_t *samples, long length); - /* Click Removal Helpers */ typedef struct DUMB_CLICK_REMOVER DUMB_CLICK_REMOVER; DUMB_CLICK_REMOVER *dumb_create_click_remover(void); void dumb_record_click(DUMB_CLICK_REMOVER *cr, long pos, sample_t step); -void dumb_remove_clicks(DUMB_CLICK_REMOVER *cr, sample_t *samples, long length, int step, float halflife); +void dumb_remove_clicks(DUMB_CLICK_REMOVER *cr, sample_t *samples, long length, + int step, float halflife); sample_t dumb_click_remover_get_offset(DUMB_CLICK_REMOVER *cr); void dumb_destroy_click_remover(DUMB_CLICK_REMOVER *cr); DUMB_CLICK_REMOVER **dumb_create_click_remover_array(int n); -void dumb_record_click_array(int n, DUMB_CLICK_REMOVER **cr, long pos, sample_t *step); -void dumb_record_click_negative_array(int n, DUMB_CLICK_REMOVER **cr, long pos, sample_t *step); -void dumb_remove_clicks_array(int n, DUMB_CLICK_REMOVER **cr, sample_t **samples, long length, float halflife); -void dumb_click_remover_get_offset_array(int n, DUMB_CLICK_REMOVER **cr, sample_t *offset); +void dumb_record_click_array(int n, DUMB_CLICK_REMOVER **cr, long pos, + sample_t *step); +void dumb_record_click_negative_array(int n, DUMB_CLICK_REMOVER **cr, long pos, + sample_t *step); +void dumb_remove_clicks_array(int n, DUMB_CLICK_REMOVER **cr, + sample_t **samples, long length, float halflife); +void dumb_click_remover_get_offset_array(int n, DUMB_CLICK_REMOVER **cr, + sample_t *offset); void dumb_destroy_click_remover_array(int n, DUMB_CLICK_REMOVER **cr); - /* Resampling Helpers */ #define DUMB_RQ_ALIASING 0 -#define DUMB_RQ_BLEP 1 -#define DUMB_RQ_LINEAR 2 -#define DUMB_RQ_BLAM 3 -#define DUMB_RQ_CUBIC 4 -#define DUMB_RQ_FIR 5 +#define DUMB_RQ_BLEP 1 +#define DUMB_RQ_LINEAR 2 +#define DUMB_RQ_BLAM 3 +#define DUMB_RQ_CUBIC 4 +#define DUMB_RQ_FIR 5 #define DUMB_RQ_N_LEVELS 6 extern int dumb_resampling_quality; /* This specifies the default */ -void dumb_it_set_resampling_quality(DUMB_IT_SIGRENDERER * sigrenderer, int quality); /* This overrides it */ +void dumb_it_set_resampling_quality(DUMB_IT_SIGRENDERER *sigrenderer, + int quality); /* This overrides it */ typedef struct DUMB_RESAMPLER DUMB_RESAMPLER; @@ -706,82 +628,166 @@ typedef struct DUMB_VOLUME_RAMP_INFO DUMB_VOLUME_RAMP_INFO; typedef void (*DUMB_RESAMPLE_PICKUP)(DUMB_RESAMPLER *resampler, void *data); -struct DUMB_RESAMPLER -{ - void *src; - long pos; - int subpos; - long start, end; - int dir; - DUMB_RESAMPLE_PICKUP pickup; - void *pickup_data; - int quality; - /* Everything below this point is internal: do not use. */ - union { - sample_t x24[3*2]; - short x16[3*2]; - signed char x8[3*2]; - } x; - int overshot; +struct DUMB_RESAMPLER { + void *src; + long pos; + int subpos; + long start, end; + int dir; + DUMB_RESAMPLE_PICKUP pickup; + void *pickup_data; + int quality; + /* Everything below this point is internal: do not use. */ + union { + sample_t x24[3 * 2]; + short x16[3 * 2]; + signed char x8[3 * 2]; + } x; + int overshot; double fir_resampler_ratio; - void* fir_resampler[2]; + void *fir_resampler[2]; }; -struct DUMB_VOLUME_RAMP_INFO -{ - float volume; - float delta; - float target; - float mix; +struct DUMB_VOLUME_RAMP_INFO { + float volume; + float delta; + float target; + float mix; unsigned char declick_stage; }; -void dumb_reset_resampler(DUMB_RESAMPLER *resampler, sample_t *src, int src_channels, long pos, long start, long end, int quality); -DUMB_RESAMPLER *dumb_start_resampler(sample_t *src, int src_channels, long pos, long start, long end, int quality); -long dumb_resample_1_1(DUMB_RESAMPLER *resampler, sample_t *dst, long dst_size, DUMB_VOLUME_RAMP_INFO * volume, float delta); -long dumb_resample_1_2(DUMB_RESAMPLER *resampler, sample_t *dst, long dst_size, DUMB_VOLUME_RAMP_INFO * volume_left, DUMB_VOLUME_RAMP_INFO * volume_right, float delta); -long dumb_resample_2_1(DUMB_RESAMPLER *resampler, sample_t *dst, long dst_size, DUMB_VOLUME_RAMP_INFO * volume_left, DUMB_VOLUME_RAMP_INFO * volume_right, float delta); -long dumb_resample_2_2(DUMB_RESAMPLER *resampler, sample_t *dst, long dst_size, DUMB_VOLUME_RAMP_INFO * volume_left, DUMB_VOLUME_RAMP_INFO * volume_right, float delta); -void dumb_resample_get_current_sample_1_1(DUMB_RESAMPLER *resampler, DUMB_VOLUME_RAMP_INFO * volume, sample_t *dst); -void dumb_resample_get_current_sample_1_2(DUMB_RESAMPLER *resampler, DUMB_VOLUME_RAMP_INFO * volume_left, DUMB_VOLUME_RAMP_INFO * volume_right, sample_t *dst); -void dumb_resample_get_current_sample_2_1(DUMB_RESAMPLER *resampler, DUMB_VOLUME_RAMP_INFO * volume_left, DUMB_VOLUME_RAMP_INFO * volume_right, sample_t *dst); -void dumb_resample_get_current_sample_2_2(DUMB_RESAMPLER *resampler, DUMB_VOLUME_RAMP_INFO * volume_left, DUMB_VOLUME_RAMP_INFO * volume_right, sample_t *dst); +void dumb_reset_resampler(DUMB_RESAMPLER *resampler, sample_t *src, + int src_channels, long pos, long start, long end, + int quality); +DUMB_RESAMPLER *dumb_start_resampler(sample_t *src, int src_channels, long pos, + long start, long end, int quality); +long dumb_resample_1_1(DUMB_RESAMPLER *resampler, sample_t *dst, long dst_size, + DUMB_VOLUME_RAMP_INFO *volume, float delta); +long dumb_resample_1_2(DUMB_RESAMPLER *resampler, sample_t *dst, long dst_size, + DUMB_VOLUME_RAMP_INFO *volume_left, + DUMB_VOLUME_RAMP_INFO *volume_right, float delta); +long dumb_resample_2_1(DUMB_RESAMPLER *resampler, sample_t *dst, long dst_size, + DUMB_VOLUME_RAMP_INFO *volume_left, + DUMB_VOLUME_RAMP_INFO *volume_right, float delta); +long dumb_resample_2_2(DUMB_RESAMPLER *resampler, sample_t *dst, long dst_size, + DUMB_VOLUME_RAMP_INFO *volume_left, + DUMB_VOLUME_RAMP_INFO *volume_right, float delta); +void dumb_resample_get_current_sample_1_1(DUMB_RESAMPLER *resampler, + DUMB_VOLUME_RAMP_INFO *volume, + sample_t *dst); +void dumb_resample_get_current_sample_1_2(DUMB_RESAMPLER *resampler, + DUMB_VOLUME_RAMP_INFO *volume_left, + DUMB_VOLUME_RAMP_INFO *volume_right, + sample_t *dst); +void dumb_resample_get_current_sample_2_1(DUMB_RESAMPLER *resampler, + DUMB_VOLUME_RAMP_INFO *volume_left, + DUMB_VOLUME_RAMP_INFO *volume_right, + sample_t *dst); +void dumb_resample_get_current_sample_2_2(DUMB_RESAMPLER *resampler, + DUMB_VOLUME_RAMP_INFO *volume_left, + DUMB_VOLUME_RAMP_INFO *volume_right, + sample_t *dst); void dumb_end_resampler(DUMB_RESAMPLER *resampler); -void dumb_reset_resampler_16(DUMB_RESAMPLER *resampler, short *src, int src_channels, long pos, long start, long end, int quality); -DUMB_RESAMPLER *dumb_start_resampler_16(short *src, int src_channels, long pos, long start, long end, int quality); -long dumb_resample_16_1_1(DUMB_RESAMPLER *resampler, sample_t *dst, long dst_size, DUMB_VOLUME_RAMP_INFO * volume, float delta); -long dumb_resample_16_1_2(DUMB_RESAMPLER *resampler, sample_t *dst, long dst_size, DUMB_VOLUME_RAMP_INFO * volume_left, DUMB_VOLUME_RAMP_INFO * volume_right, float delta); -long dumb_resample_16_2_1(DUMB_RESAMPLER *resampler, sample_t *dst, long dst_size, DUMB_VOLUME_RAMP_INFO * volume_left, DUMB_VOLUME_RAMP_INFO * volume_right, float delta); -long dumb_resample_16_2_2(DUMB_RESAMPLER *resampler, sample_t *dst, long dst_size, DUMB_VOLUME_RAMP_INFO * volume_left, DUMB_VOLUME_RAMP_INFO * volume_right, float delta); -void dumb_resample_get_current_sample_16_1_1(DUMB_RESAMPLER *resampler, DUMB_VOLUME_RAMP_INFO * volume, sample_t *dst); -void dumb_resample_get_current_sample_16_1_2(DUMB_RESAMPLER *resampler, DUMB_VOLUME_RAMP_INFO * volume_left, DUMB_VOLUME_RAMP_INFO * volume_right, sample_t *dst); -void dumb_resample_get_current_sample_16_2_1(DUMB_RESAMPLER *resampler, DUMB_VOLUME_RAMP_INFO * volume_left, DUMB_VOLUME_RAMP_INFO * volume_right, sample_t *dst); -void dumb_resample_get_current_sample_16_2_2(DUMB_RESAMPLER *resampler, DUMB_VOLUME_RAMP_INFO * volume_left, DUMB_VOLUME_RAMP_INFO * volume_right, sample_t *dst); +void dumb_reset_resampler_16(DUMB_RESAMPLER *resampler, short *src, + int src_channels, long pos, long start, long end, + int quality); +DUMB_RESAMPLER *dumb_start_resampler_16(short *src, int src_channels, long pos, + long start, long end, int quality); +long dumb_resample_16_1_1(DUMB_RESAMPLER *resampler, sample_t *dst, + long dst_size, DUMB_VOLUME_RAMP_INFO *volume, + float delta); +long dumb_resample_16_1_2(DUMB_RESAMPLER *resampler, sample_t *dst, + long dst_size, DUMB_VOLUME_RAMP_INFO *volume_left, + DUMB_VOLUME_RAMP_INFO *volume_right, float delta); +long dumb_resample_16_2_1(DUMB_RESAMPLER *resampler, sample_t *dst, + long dst_size, DUMB_VOLUME_RAMP_INFO *volume_left, + DUMB_VOLUME_RAMP_INFO *volume_right, float delta); +long dumb_resample_16_2_2(DUMB_RESAMPLER *resampler, sample_t *dst, + long dst_size, DUMB_VOLUME_RAMP_INFO *volume_left, + DUMB_VOLUME_RAMP_INFO *volume_right, float delta); +void dumb_resample_get_current_sample_16_1_1(DUMB_RESAMPLER *resampler, + DUMB_VOLUME_RAMP_INFO *volume, + sample_t *dst); +void dumb_resample_get_current_sample_16_1_2( + DUMB_RESAMPLER *resampler, DUMB_VOLUME_RAMP_INFO *volume_left, + DUMB_VOLUME_RAMP_INFO *volume_right, sample_t *dst); +void dumb_resample_get_current_sample_16_2_1( + DUMB_RESAMPLER *resampler, DUMB_VOLUME_RAMP_INFO *volume_left, + DUMB_VOLUME_RAMP_INFO *volume_right, sample_t *dst); +void dumb_resample_get_current_sample_16_2_2( + DUMB_RESAMPLER *resampler, DUMB_VOLUME_RAMP_INFO *volume_left, + DUMB_VOLUME_RAMP_INFO *volume_right, sample_t *dst); void dumb_end_resampler_16(DUMB_RESAMPLER *resampler); -void dumb_reset_resampler_8(DUMB_RESAMPLER *resampler, signed char *src, int src_channels, long pos, long start, long end, int quality); -DUMB_RESAMPLER *dumb_start_resampler_8(signed char *src, int src_channels, long pos, long start, long end, int quality); -long dumb_resample_8_1_1(DUMB_RESAMPLER *resampler, sample_t *dst, long dst_size, DUMB_VOLUME_RAMP_INFO * volume, float delta); -long dumb_resample_8_1_2(DUMB_RESAMPLER *resampler, sample_t *dst, long dst_size, DUMB_VOLUME_RAMP_INFO * volume_left, DUMB_VOLUME_RAMP_INFO * volume_right, float delta); -long dumb_resample_8_2_1(DUMB_RESAMPLER *resampler, sample_t *dst, long dst_size, DUMB_VOLUME_RAMP_INFO * volume_left, DUMB_VOLUME_RAMP_INFO * volume_right, float delta); -long dumb_resample_8_2_2(DUMB_RESAMPLER *resampler, sample_t *dst, long dst_size, DUMB_VOLUME_RAMP_INFO * volume_left, DUMB_VOLUME_RAMP_INFO * volume_right, float delta); -void dumb_resample_get_current_sample_8_1_1(DUMB_RESAMPLER *resampler, DUMB_VOLUME_RAMP_INFO * volume, sample_t *dst); -void dumb_resample_get_current_sample_8_1_2(DUMB_RESAMPLER *resampler, DUMB_VOLUME_RAMP_INFO * volume_left, DUMB_VOLUME_RAMP_INFO * volume_right, sample_t *dst); -void dumb_resample_get_current_sample_8_2_1(DUMB_RESAMPLER *resampler, DUMB_VOLUME_RAMP_INFO * volume_left, DUMB_VOLUME_RAMP_INFO * volume_right, sample_t *dst); -void dumb_resample_get_current_sample_8_2_2(DUMB_RESAMPLER *resampler, DUMB_VOLUME_RAMP_INFO * volume_left, DUMB_VOLUME_RAMP_INFO * volume_right, sample_t *dst); +void dumb_reset_resampler_8(DUMB_RESAMPLER *resampler, signed char *src, + int src_channels, long pos, long start, long end, + int quality); +DUMB_RESAMPLER *dumb_start_resampler_8(signed char *src, int src_channels, + long pos, long start, long end, + int quality); +long dumb_resample_8_1_1(DUMB_RESAMPLER *resampler, sample_t *dst, + long dst_size, DUMB_VOLUME_RAMP_INFO *volume, + float delta); +long dumb_resample_8_1_2(DUMB_RESAMPLER *resampler, sample_t *dst, + long dst_size, DUMB_VOLUME_RAMP_INFO *volume_left, + DUMB_VOLUME_RAMP_INFO *volume_right, float delta); +long dumb_resample_8_2_1(DUMB_RESAMPLER *resampler, sample_t *dst, + long dst_size, DUMB_VOLUME_RAMP_INFO *volume_left, + DUMB_VOLUME_RAMP_INFO *volume_right, float delta); +long dumb_resample_8_2_2(DUMB_RESAMPLER *resampler, sample_t *dst, + long dst_size, DUMB_VOLUME_RAMP_INFO *volume_left, + DUMB_VOLUME_RAMP_INFO *volume_right, float delta); +void dumb_resample_get_current_sample_8_1_1(DUMB_RESAMPLER *resampler, + DUMB_VOLUME_RAMP_INFO *volume, + sample_t *dst); +void dumb_resample_get_current_sample_8_1_2(DUMB_RESAMPLER *resampler, + DUMB_VOLUME_RAMP_INFO *volume_left, + DUMB_VOLUME_RAMP_INFO *volume_right, + sample_t *dst); +void dumb_resample_get_current_sample_8_2_1(DUMB_RESAMPLER *resampler, + DUMB_VOLUME_RAMP_INFO *volume_left, + DUMB_VOLUME_RAMP_INFO *volume_right, + sample_t *dst); +void dumb_resample_get_current_sample_8_2_2(DUMB_RESAMPLER *resampler, + DUMB_VOLUME_RAMP_INFO *volume_left, + DUMB_VOLUME_RAMP_INFO *volume_right, + sample_t *dst); void dumb_end_resampler_8(DUMB_RESAMPLER *resampler); -void dumb_reset_resampler_n(int n, DUMB_RESAMPLER *resampler, void *src, int src_channels, long pos, long start, long end, int quality); -DUMB_RESAMPLER *dumb_start_resampler_n(int n, void *src, int src_channels, long pos, long start, long end, int quality); -long dumb_resample_n_1_1(int n, DUMB_RESAMPLER *resampler, sample_t *dst, long dst_size, DUMB_VOLUME_RAMP_INFO * volume, float delta); -long dumb_resample_n_1_2(int n, DUMB_RESAMPLER *resampler, sample_t *dst, long dst_size, DUMB_VOLUME_RAMP_INFO * volume_left, DUMB_VOLUME_RAMP_INFO * volume_right, float delta); -long dumb_resample_n_2_1(int n, DUMB_RESAMPLER *resampler, sample_t *dst, long dst_size, DUMB_VOLUME_RAMP_INFO * volume_left, DUMB_VOLUME_RAMP_INFO * volume_right, float delta); -long dumb_resample_n_2_2(int n, DUMB_RESAMPLER *resampler, sample_t *dst, long dst_size, DUMB_VOLUME_RAMP_INFO * volume_left, DUMB_VOLUME_RAMP_INFO * volume_right, float delta); -void dumb_resample_get_current_sample_n_1_1(int n, DUMB_RESAMPLER *resampler, DUMB_VOLUME_RAMP_INFO * volume, sample_t *dst); -void dumb_resample_get_current_sample_n_1_2(int n, DUMB_RESAMPLER *resampler, DUMB_VOLUME_RAMP_INFO * volume_left, DUMB_VOLUME_RAMP_INFO * volume_right, sample_t *dst); -void dumb_resample_get_current_sample_n_2_1(int n, DUMB_RESAMPLER *resampler, DUMB_VOLUME_RAMP_INFO * volume_left, DUMB_VOLUME_RAMP_INFO * volume_right, sample_t *dst); -void dumb_resample_get_current_sample_n_2_2(int n, DUMB_RESAMPLER *resampler, DUMB_VOLUME_RAMP_INFO * volume_left, DUMB_VOLUME_RAMP_INFO * volume_right, sample_t *dst); +void dumb_reset_resampler_n(int n, DUMB_RESAMPLER *resampler, void *src, + int src_channels, long pos, long start, long end, + int quality); +DUMB_RESAMPLER *dumb_start_resampler_n(int n, void *src, int src_channels, + long pos, long start, long end, + int quality); +long dumb_resample_n_1_1(int n, DUMB_RESAMPLER *resampler, sample_t *dst, + long dst_size, DUMB_VOLUME_RAMP_INFO *volume, + float delta); +long dumb_resample_n_1_2(int n, DUMB_RESAMPLER *resampler, sample_t *dst, + long dst_size, DUMB_VOLUME_RAMP_INFO *volume_left, + DUMB_VOLUME_RAMP_INFO *volume_right, float delta); +long dumb_resample_n_2_1(int n, DUMB_RESAMPLER *resampler, sample_t *dst, + long dst_size, DUMB_VOLUME_RAMP_INFO *volume_left, + DUMB_VOLUME_RAMP_INFO *volume_right, float delta); +long dumb_resample_n_2_2(int n, DUMB_RESAMPLER *resampler, sample_t *dst, + long dst_size, DUMB_VOLUME_RAMP_INFO *volume_left, + DUMB_VOLUME_RAMP_INFO *volume_right, float delta); +void dumb_resample_get_current_sample_n_1_1(int n, DUMB_RESAMPLER *resampler, + DUMB_VOLUME_RAMP_INFO *volume, + sample_t *dst); +void dumb_resample_get_current_sample_n_1_2(int n, DUMB_RESAMPLER *resampler, + DUMB_VOLUME_RAMP_INFO *volume_left, + DUMB_VOLUME_RAMP_INFO *volume_right, + sample_t *dst); +void dumb_resample_get_current_sample_n_2_1(int n, DUMB_RESAMPLER *resampler, + DUMB_VOLUME_RAMP_INFO *volume_left, + DUMB_VOLUME_RAMP_INFO *volume_right, + sample_t *dst); +void dumb_resample_get_current_sample_n_2_2(int n, DUMB_RESAMPLER *resampler, + DUMB_VOLUME_RAMP_INFO *volume_left, + DUMB_VOLUME_RAMP_INFO *volume_right, + sample_t *dst); void dumb_end_resampler_n(int n, DUMB_RESAMPLER *resampler); /* This sets the default panning separation for hard panned formats, @@ -792,21 +798,13 @@ extern int dumb_it_default_panning_separation; /* in percent, default 25 */ /* DUH Construction */ -DUH *make_duh( - long length, - int n_tags, - const char *const tag[][2], - int n_signals, - DUH_SIGTYPE_DESC *desc[], - sigdata_t *sigdata[] -); - -void duh_set_length(DUH *duh, long length); +DUH *make_duh(dumb_off_t length, int n_tags, const char *const tag[][2], + int n_signals, DUH_SIGTYPE_DESC *desc[], sigdata_t *sigdata[]); +void duh_set_length(DUH *duh, dumb_off_t length); #ifdef __cplusplus - } +} #endif - #endif /* DUMB_H */ diff --git a/Frameworks/Dumb/dumb/include/internal/aldumb.h b/Frameworks/Dumb/dumb/include/internal/aldumb.h index 9c02c01ff..520bc9eaa 100644 --- a/Frameworks/Dumb/dumb/include/internal/aldumb.h +++ b/Frameworks/Dumb/dumb/include/internal/aldumb.h @@ -20,8 +20,6 @@ #ifndef INTERNAL_ALDUMB_H #define INTERNAL_ALDUMB_H - void _dat_unload_duh(void *duh); - #endif /* INTERNAL_DUMB_H */ diff --git a/Frameworks/Dumb/dumb/include/internal/barray.h b/Frameworks/Dumb/dumb/include/internal/barray.h index 5570d58ec..51584046e 100644 --- a/Frameworks/Dumb/dumb/include/internal/barray.h +++ b/Frameworks/Dumb/dumb/include/internal/barray.h @@ -6,38 +6,38 @@ #ifdef BARRAY_DECORATE #undef PASTE #undef EVALUATE -#define PASTE(a,b) a ## b -#define EVALUATE(a,b) PASTE(a,b) -#define bit_array_create EVALUATE(BARRAY_DECORATE,_bit_array_create) -#define bit_array_destroy EVALUATE(BARRAY_DECORATE,_bit_array_destroy) -#define bit_array_dup EVALUATE(BARRAY_DECORATE,_bit_array_dup) -#define bit_array_reset EVALUATE(BARRAY_DECORATE,_bit_array_reset) -#define bit_array_set EVALUATE(BARRAY_DECORATE,_bit_array_set) -#define bit_array_set_range EVALUATE(BARRAY_DECORATE,_bit_array_set_range) -#define bit_array_test EVALUATE(BARRAY_DECORATE,_bit_array_test) -#define bit_array_test_range EVALUATE(BARRAY_DECORATE,_bit_array_test_range) -#define bit_array_clear EVALUATE(BARRAY_DECORATE,_bit_array_clear) -#define bit_array_clear_range EVALUATE(BARRAY_DECORATE,_bit_array_clear_range) -#define bit_array_merge EVALUATE(BARRAY_DECORATE,_bit_array_merge) -#define bit_array_mask EVALUATE(BARRAY_DECORATE,_bit_array_mask) +#define PASTE(a, b) a##b +#define EVALUATE(a, b) PASTE(a, b) +#define bit_array_create EVALUATE(BARRAY_DECORATE, _bit_array_create) +#define bit_array_destroy EVALUATE(BARRAY_DECORATE, _bit_array_destroy) +#define bit_array_dup EVALUATE(BARRAY_DECORATE, _bit_array_dup) +#define bit_array_reset EVALUATE(BARRAY_DECORATE, _bit_array_reset) +#define bit_array_set EVALUATE(BARRAY_DECORATE, _bit_array_set) +#define bit_array_set_range EVALUATE(BARRAY_DECORATE, _bit_array_set_range) +#define bit_array_test EVALUATE(BARRAY_DECORATE, _bit_array_test) +#define bit_array_test_range EVALUATE(BARRAY_DECORATE, _bit_array_test_range) +#define bit_array_clear EVALUATE(BARRAY_DECORATE, _bit_array_clear) +#define bit_array_clear_range EVALUATE(BARRAY_DECORATE, _bit_array_clear_range) +#define bit_array_merge EVALUATE(BARRAY_DECORATE, _bit_array_merge) +#define bit_array_mask EVALUATE(BARRAY_DECORATE, _bit_array_mask) #endif -void * bit_array_create(size_t size); -void bit_array_destroy(void * array); -void * bit_array_dup(void * array); +void *bit_array_create(size_t size); +void bit_array_destroy(void *array); +void *bit_array_dup(void *array); -void bit_array_reset(void * array); +void bit_array_reset(void *array); -void bit_array_set(void * array, size_t bit); -void bit_array_set_range(void * array, size_t bit, size_t count); +void bit_array_set(void *array, size_t bit); +void bit_array_set_range(void *array, size_t bit, size_t count); -int bit_array_test(void * array, size_t bit); -int bit_array_test_range(void * array, size_t bit, size_t count); +int bit_array_test(void *array, size_t bit); +int bit_array_test_range(void *array, size_t bit, size_t count); -void bit_array_clear(void * array, size_t bit); -void bit_array_clear_range(void * array, size_t bit, size_t count); +void bit_array_clear(void *array, size_t bit); +void bit_array_clear_range(void *array, size_t bit, size_t count); -void bit_array_merge(void * array, void * source, size_t offset); -void bit_array_mask(void * array, void * source, size_t offset); +void bit_array_merge(void *array, void *source, size_t offset); +void bit_array_mask(void *array, void *source, size_t offset); #endif diff --git a/Frameworks/Dumb/dumb/include/internal/dumb.h b/Frameworks/Dumb/dumb/include/internal/dumb.h index c725e8610..b17c64393 100644 --- a/Frameworks/Dumb/dumb/include/internal/dumb.h +++ b/Frameworks/Dumb/dumb/include/internal/dumb.h @@ -26,47 +26,50 @@ #ifndef INTERNAL_DUMB_H #define INTERNAL_DUMB_H +#include "../dumb.h" #undef MIN #undef MAX #undef MID -#define MIN(x,y) (((x) < (y)) ? (x) : (y)) -#define MAX(x,y) (((x) > (y)) ? (x) : (y)) -#define MID(x,y,z) MAX((x), MIN((y), (z))) +#define MIN(x, y) (((x) < (y)) ? (x) : (y)) +#define MAX(x, y) (((x) > (y)) ? (x) : (y)) +#define MID(x, y, z) MAX((x), MIN((y), (z))) #undef ABS #define ABS(x) (((x) >= 0) ? (x) : (-(x))) -typedef struct DUH_SIGTYPE_DESC_LINK -{ - struct DUH_SIGTYPE_DESC_LINK *next; - DUH_SIGTYPE_DESC *desc; -} -DUH_SIGTYPE_DESC_LINK; +#ifndef LONG_LONG +#if defined __GNUC__ || defined __INTEL_COMPILER || defined __MWERKS__ || \ + defined __sgi +#define LONG_LONG long long +#elif defined _MSC_VER || defined __WATCOMC__ +#define LONG_LONG __int64 +#else +#error 64-bit integer type unknown +#endif +#endif +typedef struct DUH_SIGTYPE_DESC_LINK { + struct DUH_SIGTYPE_DESC_LINK *next; + DUH_SIGTYPE_DESC *desc; +} DUH_SIGTYPE_DESC_LINK; -typedef struct DUH_SIGNAL -{ - sigdata_t *sigdata; - DUH_SIGTYPE_DESC *desc; -} -DUH_SIGNAL; +typedef struct DUH_SIGNAL { + sigdata_t *sigdata; + DUH_SIGTYPE_DESC *desc; +} DUH_SIGNAL; +struct DUH { + dumb_off_t length; -struct DUH -{ - long length; + int n_tags; + char *(*tag)[2]; - int n_tags; - char *(*tag)[2]; - - int n_signals; - DUH_SIGNAL **signal; + int n_signals; + DUH_SIGNAL **signal; }; - DUH_SIGTYPE_DESC *_dumb_get_sigtype_desc(long type); - #endif /* INTERNAL_DUMB_H */ diff --git a/Frameworks/Dumb/dumb/include/internal/dumbfile.h b/Frameworks/Dumb/dumb/include/internal/dumbfile.h index c83cc9a00..fd774eacd 100644 --- a/Frameworks/Dumb/dumb/include/internal/dumbfile.h +++ b/Frameworks/Dumb/dumb/include/internal/dumbfile.h @@ -1,13 +1,12 @@ -#ifndef DUMBFILE_H -#define DUMBFILE_H - -#include "../dumb.h" - -struct DUMBFILE -{ - const DUMBFILE_SYSTEM *dfs; - void *file; - long pos; -}; - -#endif // DUMBFILE_H +#ifndef DUMBFILE_H +#define DUMBFILE_H + +#include "../dumb.h" + +struct DUMBFILE { + const DUMBFILE_SYSTEM *dfs; + void *file; + long pos; +}; + +#endif // DUMBFILE_H diff --git a/Frameworks/Dumb/dumb/include/internal/fir_resampler.h b/Frameworks/Dumb/dumb/include/internal/fir_resampler.h deleted file mode 100644 index 140eefb39..000000000 --- a/Frameworks/Dumb/dumb/include/internal/fir_resampler.h +++ /dev/null @@ -1,18 +0,0 @@ -#ifndef _FIR_RESAMPLER_H_ -#define _FIR_RESAMPLER_H_ - -void fir_init(); - -void * fir_resampler_create(); -void fir_resampler_delete(void *); -void * fir_resampler_dup(void *); - -int fir_resampler_get_free_count(void *); -void fir_resampler_write_sample(void *, short sample); -void fir_resampler_set_rate( void *, double new_factor ); -int fir_resampler_ready(void *); -void fir_resampler_clear(void *); -int fir_resampler_get_sample(void *); -void fir_resampler_remove_sample(void *); - -#endif diff --git a/Frameworks/Dumb/dumb/include/internal/it.h b/Frameworks/Dumb/dumb/include/internal/it.h index a50d07d3f..226d80fe0 100644 --- a/Frameworks/Dumb/dumb/include/internal/it.h +++ b/Frameworks/Dumb/dumb/include/internal/it.h @@ -27,7 +27,6 @@ #ifndef INTERNAL_IT_H #define INTERNAL_IT_H - #define BIT_ARRAY_BULLSHIT #include @@ -35,7 +34,6 @@ #include "barray.h" #include "tarray.h" - /** TO DO: THINK ABOUT THE FOLLOWING: sigdata->flags & IT_COMPATIBLE_GXX @@ -49,8 +47,6 @@ sigdata->flags & IT_COMPATIBLE_GXX NewFrequency = OldFrequency * NewC5 / OldC5; */ - - /* These #defines are TEMPORARY. They are used to write alternative code to * handle ambiguities in the format specification. The correct code in each * case will be determined most likely by experimentation. @@ -60,25 +56,20 @@ sigdata->flags & IT_COMPATIBLE_GXX #define SUSTAIN_LOOP_OVERRIDES_NORMAL_LOOP #define VOLUME_OUT_OF_RANGE_SETS_MAXIMUM - - #define SIGTYPE_IT DUMB_ID('I', 'T', ' ', ' ') -#define IT_SIGNATURE DUMB_ID('I', 'M', 'P', 'M') +#define IT_SIGNATURE DUMB_ID('I', 'M', 'P', 'M') #define IT_INSTRUMENT_SIGNATURE DUMB_ID('I', 'M', 'P', 'I') -#define IT_SAMPLE_SIGNATURE DUMB_ID('I', 'M', 'P', 'S') +#define IT_SAMPLE_SIGNATURE DUMB_ID('I', 'M', 'P', 'S') // olivier sux -#define IT_MPTX_SIGNATURE DUMB_ID('X', 'T', 'P', 'M') -#define IT_INSM_SIGNATURE DUMB_ID('M', 'S', 'N', 'I') - +#define IT_MPTX_SIGNATURE DUMB_ID('X', 'T', 'P', 'M') +#define IT_INSM_SIGNATURE DUMB_ID('M', 'S', 'N', 'I') /* This is divided by the tempo times 256 to get the interval between ticks. */ #define TICK_TIME_DIVIDEND (65536 * 5 * 128) - - /* I'm not going to try to explain this, because I didn't derive it very * formally ;) */ @@ -88,8 +79,6 @@ sigdata->flags & IT_COMPATIBLE_GXX #define AMIGA_CLOCK 3546895 #define AMIGA_DIVISOR ((float)(16.0 * AMIGA_CLOCK)) - - typedef struct IT_MIDI IT_MIDI; typedef struct IT_FILTER_STATE IT_FILTER_STATE; typedef struct IT_ENVELOPE IT_ENVELOPE; @@ -103,147 +92,130 @@ typedef struct IT_CHANNEL IT_CHANNEL; typedef struct IT_CHECKPOINT IT_CHECKPOINT; typedef struct IT_CALLBACKS IT_CALLBACKS; - - -struct IT_MIDI -{ - unsigned char SFmacro[16][16]; // read these from 0x120 - unsigned char SFmacrolen[16]; - unsigned short SFmacroz[16]; /* Bitfield; bit 0 set = z in first position */ - unsigned char Zmacro[128][16]; // read these from 0x320 - unsigned char Zmacrolen[128]; +struct IT_MIDI { + unsigned char SFmacro[16][16]; // read these from 0x120 + unsigned char SFmacrolen[16]; + unsigned short SFmacroz[16]; /* Bitfield; bit 0 set = z in first position */ + unsigned char Zmacro[128][16]; // read these from 0x320 + unsigned char Zmacrolen[128]; }; - - -struct IT_FILTER_STATE -{ - sample_t currsample, prevsample; +struct IT_FILTER_STATE { + sample_t currsample, prevsample; }; - - -#define IT_ENVELOPE_ON 1 -#define IT_ENVELOPE_LOOP_ON 2 -#define IT_ENVELOPE_SUSTAIN_LOOP 4 -#define IT_ENVELOPE_CARRY 8 +#define IT_ENVELOPE_ON 1 +#define IT_ENVELOPE_LOOP_ON 2 +#define IT_ENVELOPE_SUSTAIN_LOOP 4 +#define IT_ENVELOPE_CARRY 8 #define IT_ENVELOPE_PITCH_IS_FILTER 128 -struct IT_ENVELOPE -{ - unsigned char flags; - unsigned char n_nodes; - unsigned char loop_start; - unsigned char loop_end; - unsigned char sus_loop_start; - unsigned char sus_loop_end; - signed char node_y[25]; - unsigned short node_t[25]; +struct IT_ENVELOPE { + unsigned char flags; + unsigned char n_nodes; + unsigned char loop_start; + unsigned char loop_end; + unsigned char sus_loop_start; + unsigned char sus_loop_end; + signed char node_y[25]; + unsigned short node_t[25]; }; - - -#define NNA_NOTE_CUT 0 +#define NNA_NOTE_CUT 0 #define NNA_NOTE_CONTINUE 1 -#define NNA_NOTE_OFF 2 -#define NNA_NOTE_FADE 3 +#define NNA_NOTE_OFF 2 +#define NNA_NOTE_FADE 3 -#define DCT_OFF 0 -#define DCT_NOTE 1 -#define DCT_SAMPLE 2 +#define DCT_OFF 0 +#define DCT_NOTE 1 +#define DCT_SAMPLE 2 #define DCT_INSTRUMENT 3 -#define DCA_NOTE_CUT 0 -#define DCA_NOTE_OFF 1 +#define DCA_NOTE_CUT 0 +#define DCA_NOTE_OFF 1 #define DCA_NOTE_FADE 2 -struct IT_INSTRUMENT -{ - unsigned char name[27]; - unsigned char filename[14]; +struct IT_INSTRUMENT { + unsigned char name[27]; + unsigned char filename[14]; - int fadeout; + int fadeout; - IT_ENVELOPE volume_envelope; - IT_ENVELOPE pan_envelope; - IT_ENVELOPE pitch_envelope; + IT_ENVELOPE volume_envelope; + IT_ENVELOPE pan_envelope; + IT_ENVELOPE pitch_envelope; - unsigned char new_note_action; - unsigned char dup_check_type; - unsigned char dup_check_action; - signed char pp_separation; - unsigned char pp_centre; - unsigned char global_volume; - unsigned char default_pan; - unsigned char random_volume; - unsigned char random_pan; + unsigned char new_note_action; + unsigned char dup_check_type; + unsigned char dup_check_action; + signed char pp_separation; + unsigned char pp_centre; + unsigned char global_volume; + unsigned char default_pan; + unsigned char random_volume; + unsigned char random_pan; - unsigned char filter_cutoff; - unsigned char filter_resonance; + unsigned char filter_cutoff; + unsigned char filter_resonance; - unsigned char map_note[120]; - unsigned short map_sample[120]; + unsigned char map_note[120]; + unsigned short map_sample[120]; - //int output; + // int output; }; - - -#define IT_SAMPLE_EXISTS 1 -#define IT_SAMPLE_16BIT 2 -#define IT_SAMPLE_STEREO 4 -#define IT_SAMPLE_LOOP 16 -#define IT_SAMPLE_SUS_LOOP 32 -#define IT_SAMPLE_PINGPONG_LOOP 64 +#define IT_SAMPLE_EXISTS 1 +#define IT_SAMPLE_16BIT 2 +#define IT_SAMPLE_STEREO 4 +#define IT_SAMPLE_LOOP 16 +#define IT_SAMPLE_SUS_LOOP 32 +#define IT_SAMPLE_PINGPONG_LOOP 64 #define IT_SAMPLE_PINGPONG_SUS_LOOP 128 -#define IT_VIBRATO_SINE 0 -#define IT_VIBRATO_SAWTOOTH 1 -#define IT_VIBRATO_SQUARE 2 -#define IT_VIBRATO_RANDOM 3 +#define IT_VIBRATO_SINE 0 +#define IT_VIBRATO_SAWTOOTH 1 +#define IT_VIBRATO_SQUARE 2 +#define IT_VIBRATO_RANDOM 3 #define IT_VIBRATO_XM_SQUARE 4 #define IT_VIBRATO_RAMP_DOWN 5 -#define IT_VIBRATO_RAMP_UP 6 +#define IT_VIBRATO_RAMP_UP 6 -struct IT_SAMPLE -{ - unsigned char name[35]; - unsigned char filename[15]; - unsigned char flags; - unsigned char global_volume; - unsigned char default_volume; - unsigned char default_pan; - /* default_pan: - * 0-255 for XM - * ignored for MOD - * otherwise, 0-64, and add 128 to enable - */ +struct IT_SAMPLE { + unsigned char name[35]; + unsigned char filename[15]; + unsigned char flags; + unsigned char global_volume; + unsigned char default_volume; + unsigned char default_pan; + /* default_pan: + * 0-255 for XM + * ignored for MOD + * otherwise, 0-64, and add 128 to enable + */ - long length; - long loop_start; - long loop_end; - long C5_speed; - long sus_loop_start; - long sus_loop_end; + long length; + long loop_start; + long loop_end; + long C5_speed; + long sus_loop_start; + long sus_loop_end; - unsigned char vibrato_speed; - unsigned char vibrato_depth; - unsigned char vibrato_rate; - unsigned char vibrato_waveform; + unsigned char vibrato_speed; + unsigned char vibrato_depth; + unsigned char vibrato_rate; + unsigned char vibrato_waveform; - signed short finetune; + signed short finetune; - void *data; + void *data; - int max_resampling_quality; + int max_resampling_quality; }; - - -#define IT_ENTRY_NOTE 1 +#define IT_ENTRY_NOTE 1 #define IT_ENTRY_INSTRUMENT 2 -#define IT_ENTRY_VOLPAN 4 -#define IT_ENTRY_EFFECT 8 +#define IT_ENTRY_VOLPAN 4 +#define IT_ENTRY_EFFECT 8 #define IT_SET_END_ROW(entry) ((entry)->channel = 255) #define IT_IS_END_ROW(entry) ((entry)->channel >= DUMB_IT_N_CHANNELS) @@ -257,78 +229,78 @@ struct IT_SAMPLE #define IT_IS_SURROUND(pan) ((pan) > 64) #define IT_IS_SURROUND_SHIFTED(pan) ((pan) > 64 << IT_ENVELOPE_SHIFT) -#define IT_SET_SPEED 1 -#define IT_JUMP_TO_ORDER 2 -#define IT_BREAK_TO_ROW 3 -#define IT_VOLUME_SLIDE 4 -#define IT_PORTAMENTO_DOWN 5 -#define IT_PORTAMENTO_UP 6 -#define IT_TONE_PORTAMENTO 7 -#define IT_VIBRATO 8 -#define IT_TREMOR 9 -#define IT_ARPEGGIO 10 -#define IT_VOLSLIDE_VIBRATO 11 -#define IT_VOLSLIDE_TONEPORTA 12 -#define IT_SET_CHANNEL_VOLUME 13 -#define IT_CHANNEL_VOLUME_SLIDE 14 -#define IT_SET_SAMPLE_OFFSET 15 -#define IT_PANNING_SLIDE 16 -#define IT_RETRIGGER_NOTE 17 -#define IT_TREMOLO 18 -#define IT_S 19 -#define IT_SET_SONG_TEMPO 20 -#define IT_FINE_VIBRATO 21 -#define IT_SET_GLOBAL_VOLUME 22 -#define IT_GLOBAL_VOLUME_SLIDE 23 -#define IT_SET_PANNING 24 -#define IT_PANBRELLO 25 -#define IT_MIDI_MACRO 26 //see MIDI.TXT +#define IT_SET_SPEED 1 +#define IT_JUMP_TO_ORDER 2 +#define IT_BREAK_TO_ROW 3 +#define IT_VOLUME_SLIDE 4 +#define IT_PORTAMENTO_DOWN 5 +#define IT_PORTAMENTO_UP 6 +#define IT_TONE_PORTAMENTO 7 +#define IT_VIBRATO 8 +#define IT_TREMOR 9 +#define IT_ARPEGGIO 10 +#define IT_VOLSLIDE_VIBRATO 11 +#define IT_VOLSLIDE_TONEPORTA 12 +#define IT_SET_CHANNEL_VOLUME 13 +#define IT_CHANNEL_VOLUME_SLIDE 14 +#define IT_SET_SAMPLE_OFFSET 15 +#define IT_PANNING_SLIDE 16 +#define IT_RETRIGGER_NOTE 17 +#define IT_TREMOLO 18 +#define IT_S 19 +#define IT_SET_SONG_TEMPO 20 +#define IT_FINE_VIBRATO 21 +#define IT_SET_GLOBAL_VOLUME 22 +#define IT_GLOBAL_VOLUME_SLIDE 23 +#define IT_SET_PANNING 24 +#define IT_PANBRELLO 25 +#define IT_MIDI_MACRO 26 // see MIDI.TXT /* Some effects needed for XM compatibility */ -#define IT_XM_PORTAMENTO_DOWN 27 -#define IT_XM_PORTAMENTO_UP 28 -#define IT_XM_FINE_VOLSLIDE_DOWN 29 -#define IT_XM_FINE_VOLSLIDE_UP 30 -#define IT_XM_RETRIGGER_NOTE 31 -#define IT_XM_KEY_OFF 32 +#define IT_XM_PORTAMENTO_DOWN 27 +#define IT_XM_PORTAMENTO_UP 28 +#define IT_XM_FINE_VOLSLIDE_DOWN 29 +#define IT_XM_FINE_VOLSLIDE_UP 30 +#define IT_XM_RETRIGGER_NOTE 31 +#define IT_XM_KEY_OFF 32 #define IT_XM_SET_ENVELOPE_POSITION 33 /* More effects needed for PTM compatibility */ -#define IT_PTM_NOTE_SLIDE_DOWN 34 -#define IT_PTM_NOTE_SLIDE_UP 35 +#define IT_PTM_NOTE_SLIDE_DOWN 34 +#define IT_PTM_NOTE_SLIDE_UP 35 #define IT_PTM_NOTE_SLIDE_DOWN_RETRIG 36 -#define IT_PTM_NOTE_SLIDE_UP_RETRIG 37 +#define IT_PTM_NOTE_SLIDE_UP_RETRIG 37 /* More effects needed for OKT compatibility */ -#define IT_OKT_NOTE_SLIDE_DOWN 38 -#define IT_OKT_NOTE_SLIDE_DOWN_ROW 39 -#define IT_OKT_NOTE_SLIDE_UP 40 -#define IT_OKT_NOTE_SLIDE_UP_ROW 41 -#define IT_OKT_ARPEGGIO_3 42 -#define IT_OKT_ARPEGGIO_4 43 -#define IT_OKT_ARPEGGIO_5 44 -#define IT_OKT_VOLUME_SLIDE_DOWN 45 -#define IT_OKT_VOLUME_SLIDE_UP 46 +#define IT_OKT_NOTE_SLIDE_DOWN 38 +#define IT_OKT_NOTE_SLIDE_DOWN_ROW 39 +#define IT_OKT_NOTE_SLIDE_UP 40 +#define IT_OKT_NOTE_SLIDE_UP_ROW 41 +#define IT_OKT_ARPEGGIO_3 42 +#define IT_OKT_ARPEGGIO_4 43 +#define IT_OKT_ARPEGGIO_5 44 +#define IT_OKT_VOLUME_SLIDE_DOWN 45 +#define IT_OKT_VOLUME_SLIDE_UP 46 -#define IT_N_EFFECTS 47 +#define IT_N_EFFECTS 47 /* These represent the top nibble of the command value. */ -#define IT_S_SET_FILTER 0 /* Greyed out in IT... */ -#define IT_S_SET_GLISSANDO_CONTROL 1 /* Greyed out in IT... */ -#define IT_S_FINETUNE 2 /* Greyed out in IT... */ -#define IT_S_SET_VIBRATO_WAVEFORM 3 -#define IT_S_SET_TREMOLO_WAVEFORM 4 -#define IT_S_SET_PANBRELLO_WAVEFORM 5 -#define IT_S_FINE_PATTERN_DELAY 6 -#define IT_S7 7 -#define IT_S_SET_PAN 8 -#define IT_S_SET_SURROUND_SOUND 9 -#define IT_S_SET_HIGH_OFFSET 10 -#define IT_S_PATTERN_LOOP 11 -#define IT_S_DELAYED_NOTE_CUT 12 -#define IT_S_NOTE_DELAY 13 -#define IT_S_PATTERN_DELAY 14 -#define IT_S_SET_MIDI_MACRO 15 +#define IT_S_SET_FILTER 0 /* Greyed out in IT... */ +#define IT_S_SET_GLISSANDO_CONTROL 1 /* Greyed out in IT... */ +#define IT_S_FINETUNE 2 /* Greyed out in IT... */ +#define IT_S_SET_VIBRATO_WAVEFORM 3 +#define IT_S_SET_TREMOLO_WAVEFORM 4 +#define IT_S_SET_PANBRELLO_WAVEFORM 5 +#define IT_S_FINE_PATTERN_DELAY 6 +#define IT_S7 7 +#define IT_S_SET_PAN 8 +#define IT_S_SET_SURROUND_SOUND 9 +#define IT_S_SET_HIGH_OFFSET 10 +#define IT_S_PATTERN_LOOP 11 +#define IT_S_DELAYED_NOTE_CUT 12 +#define IT_S_NOTE_DELAY 13 +#define IT_S_PATTERN_DELAY 14 +#define IT_S_SET_MIDI_MACRO 15 /* S0x Set filter @@ -369,547 +341,523 @@ SEx Pattern delay for x rows SFx Set parameterised MIDI Macro */ -struct IT_ENTRY -{ - unsigned char channel; /* End of row if channel >= DUMB_IT_N_CHANNELS */ - unsigned char mask; - unsigned char note; - unsigned char instrument; - unsigned char volpan; - unsigned char effect; - unsigned char effectvalue; +struct IT_ENTRY { + unsigned char channel; /* End of row if channel >= DUMB_IT_N_CHANNELS */ + unsigned char mask; + unsigned char note; + unsigned char instrument; + unsigned char volpan; + unsigned char effect; + unsigned char effectvalue; }; - - -struct IT_PATTERN -{ - int n_rows; - int n_entries; - IT_ENTRY *entry; +struct IT_PATTERN { + int n_rows; + int n_entries; + IT_ENTRY *entry; }; - - -#define IT_STEREO 1 -#define IT_USE_INSTRUMENTS 4 -#define IT_LINEAR_SLIDES 8 /* If not set, use Amiga slides */ -#define IT_OLD_EFFECTS 16 -#define IT_COMPATIBLE_GXX 32 +#define IT_STEREO 1 +#define IT_USE_INSTRUMENTS 4 +#define IT_LINEAR_SLIDES 8 /* If not set, use Amiga slides */ +#define IT_OLD_EFFECTS 16 +#define IT_COMPATIBLE_GXX 32 /* Make sure IT_WAS_AN_XM and IT_WAS_A_MOD aren't set accidentally */ -#define IT_REAL_FLAGS 63 +#define IT_REAL_FLAGS 63 -#define IT_WAS_AN_XM 64 /* Set for both XMs and MODs */ -#define IT_WAS_A_MOD 128 +#define IT_WAS_AN_XM 64 /* Set for both XMs and MODs */ +#define IT_WAS_A_MOD 128 -#define IT_WAS_AN_S3M 256 +#define IT_WAS_AN_S3M 256 -#define IT_WAS_A_PTM 512 +#define IT_WAS_A_PTM 512 -#define IT_WAS_A_669 1024 +#define IT_WAS_A_669 1024 -#define IT_WAS_AN_OKT 2048 +#define IT_WAS_AN_OKT 2048 -#define IT_WAS_AN_STM 4096 +#define IT_WAS_AN_STM 4096 -#define IT_WAS_PROCESSED 8192 /* Will be set the first time a sigdata passes through a sigrenderer */ +#define IT_WAS_PROCESSED \ + 8192 /* Will be set the first time a sigdata passes through a sigrenderer \ + */ -#define IT_ORDER_END 255 +#define IT_ORDER_END 255 #define IT_ORDER_SKIP 254 -struct DUMB_IT_SIGDATA -{ - unsigned char name[65]; +struct DUMB_IT_SIGDATA { + unsigned char name[65]; - unsigned char *song_message; + unsigned char *song_message; - int n_orders; - int n_instruments; - int n_samples; - int n_patterns; - int n_pchannels; + int n_orders; + int n_instruments; + int n_samples; + int n_patterns; + int n_pchannels; - int flags; + int flags; - int global_volume; - int mixing_volume; - int speed; - int tempo; - int pan_separation; + int global_volume; + int mixing_volume; + int speed; + int tempo; + int pan_separation; - unsigned char channel_pan[DUMB_IT_N_CHANNELS]; - unsigned char channel_volume[DUMB_IT_N_CHANNELS]; + unsigned char channel_pan[DUMB_IT_N_CHANNELS]; + unsigned char channel_volume[DUMB_IT_N_CHANNELS]; - unsigned char *order; - unsigned char restart_position; /* for XM compatiblity */ + unsigned char *order; + unsigned char restart_position; /* for XM compatiblity */ - IT_INSTRUMENT *instrument; - IT_SAMPLE *sample; - IT_PATTERN *pattern; + IT_INSTRUMENT *instrument; + IT_SAMPLE *sample; + IT_PATTERN *pattern; - IT_MIDI *midi; + IT_MIDI *midi; - IT_CHECKPOINT *checkpoint; + IT_CHECKPOINT *checkpoint; }; - - -struct IT_PLAYING_ENVELOPE -{ - int next_node; - int tick; - int value; +struct IT_PLAYING_ENVELOPE { + int next_node; + int tick; + int value; }; - - #define IT_PLAYING_BACKGROUND 1 #define IT_PLAYING_SUSTAINOFF 2 -#define IT_PLAYING_FADING 4 -#define IT_PLAYING_DEAD 8 -#define IT_PLAYING_REVERSE 16 +#define IT_PLAYING_FADING 4 +#define IT_PLAYING_DEAD 8 +#define IT_PLAYING_REVERSE 16 -struct IT_PLAYING -{ - int flags; +struct IT_PLAYING { + int flags; - int resampling_quality; + int resampling_quality; - IT_CHANNEL *channel; - IT_SAMPLE *sample; - IT_INSTRUMENT *instrument; - IT_INSTRUMENT *env_instrument; + IT_CHANNEL *channel; + IT_SAMPLE *sample; + IT_INSTRUMENT *instrument; + IT_INSTRUMENT *env_instrument; - unsigned short sampnum; - unsigned char instnum; + unsigned short sampnum; + unsigned char instnum; - unsigned char declick_stage; + unsigned char declick_stage; - float float_volume[2]; - float ramp_volume[2]; - float ramp_delta[2]; + float float_volume[2]; + float ramp_volume[2]; + float ramp_delta[2]; - unsigned char channel_volume; + unsigned char channel_volume; - unsigned char volume; - unsigned short pan; + unsigned char volume; + unsigned short pan; - signed char volume_offset, panning_offset; + signed char volume_offset, panning_offset; - unsigned char note; + unsigned char note; - unsigned char enabled_envelopes; + unsigned char enabled_envelopes; - unsigned char filter_cutoff; - unsigned char filter_resonance; + unsigned char filter_cutoff; + unsigned char filter_resonance; - unsigned short true_filter_cutoff; /* These incorporate the filter envelope, and will not */ - unsigned char true_filter_resonance; /* be changed if they would be set to 127<<8 and 0. */ + unsigned short + true_filter_cutoff; /* These incorporate the filter envelope, and will + not */ + unsigned char true_filter_resonance; /* be changed if they would be set to + 127<<8 and 0. */ - unsigned char vibrato_speed; - unsigned char vibrato_depth; - unsigned char vibrato_n; /* May be specified twice: volpan & effect. */ - unsigned char vibrato_time; - unsigned char vibrato_waveform; + unsigned char vibrato_speed; + unsigned char vibrato_depth; + unsigned char vibrato_n; /* May be specified twice: volpan & effect. */ + unsigned char vibrato_time; + unsigned char vibrato_waveform; - unsigned char tremolo_speed; - unsigned char tremolo_depth; - unsigned char tremolo_time; - unsigned char tremolo_waveform; + unsigned char tremolo_speed; + unsigned char tremolo_depth; + unsigned char tremolo_time; + unsigned char tremolo_waveform; - unsigned char panbrello_speed; - unsigned char panbrello_depth; - unsigned char panbrello_time; - unsigned char panbrello_waveform; - signed char panbrello_random; + unsigned char panbrello_speed; + unsigned char panbrello_depth; + unsigned char panbrello_time; + unsigned char panbrello_waveform; + signed char panbrello_random; - unsigned char sample_vibrato_time; - unsigned char sample_vibrato_waveform; - int sample_vibrato_depth; /* Starts at rate?0:depth, increases by rate */ + unsigned char sample_vibrato_time; + unsigned char sample_vibrato_waveform; + int sample_vibrato_depth; /* Starts at rate?0:depth, increases by rate */ - int slide; - float delta; - int finetune; + int slide; + float delta; + int finetune; - IT_PLAYING_ENVELOPE volume_envelope; - IT_PLAYING_ENVELOPE pan_envelope; - IT_PLAYING_ENVELOPE pitch_envelope; + IT_PLAYING_ENVELOPE volume_envelope; + IT_PLAYING_ENVELOPE pan_envelope; + IT_PLAYING_ENVELOPE pitch_envelope; - int fadeoutcount; + int fadeoutcount; - IT_FILTER_STATE filter_state[2]; /* Left and right */ + IT_FILTER_STATE filter_state[2]; /* Left and right */ - DUMB_RESAMPLER resampler; + DUMB_RESAMPLER resampler; - /* time_lost is used to emulate Impulse Tracker's sample looping - * characteristics. When time_lost is added to pos, the result represents - * the position in the theoretical version of the sample where all loops - * have been expanded. If this is stored, the resampling helpers will - * safely convert it for use with new loop boundaries. The situation is - * slightly more complicated if dir == -1 when the change takes place; we - * must reflect pos off the loop end point and set dir to 1 before - * proceeding. - */ - long time_lost; + /* time_lost is used to emulate Impulse Tracker's sample looping + * characteristics. When time_lost is added to pos, the result represents + * the position in the theoretical version of the sample where all loops + * have been expanded. If this is stored, the resampling helpers will + * safely convert it for use with new loop boundaries. The situation is + * slightly more complicated if dir == -1 when the change takes place; we + * must reflect pos off the loop end point and set dir to 1 before + * proceeding. + */ + long time_lost; - //int output; + // int output; }; - - #define IT_CHANNEL_MUTED 1 -#define IT_ENV_VOLUME 1 +#define IT_ENV_VOLUME 1 #define IT_ENV_PANNING 2 -#define IT_ENV_PITCH 4 +#define IT_ENV_PITCH 4 -struct IT_CHANNEL -{ - int flags; +struct IT_CHANNEL { + int flags; - unsigned char volume; - signed char volslide; - signed char xm_volslide; - signed char panslide; + unsigned char volume; + signed char volslide; + signed char xm_volslide; + signed char panslide; - /* xm_volslide is used for volume slides done in the volume column in an - * XM file, since it seems the volume column slide is applied first, - * followed by clamping, followed by the effects column slide. IT does - * not exhibit this behaviour, so xm_volslide is maintained at zero. - */ + /* xm_volslide is used for volume slides done in the volume column in an + * XM file, since it seems the volume column slide is applied first, + * followed by clamping, followed by the effects column slide. IT does + * not exhibit this behaviour, so xm_volslide is maintained at zero. + */ - unsigned char pan; - unsigned short truepan; + unsigned char pan; + unsigned short truepan; - unsigned char channelvolume; - signed char channelvolslide; + unsigned char channelvolume; + signed char channelvolslide; - unsigned char instrument; - unsigned char note; + unsigned char instrument; + unsigned char note; - unsigned char SFmacro; + unsigned char SFmacro; - unsigned char filter_cutoff; - unsigned char filter_resonance; + unsigned char filter_cutoff; + unsigned char filter_resonance; - unsigned char key_off_count; - unsigned char note_cut_count; - unsigned char note_delay_count; - IT_ENTRY *note_delay_entry; + unsigned char key_off_count; + unsigned char note_cut_count; + unsigned char note_delay_count; + IT_ENTRY *note_delay_entry; - unsigned char new_note_action; + unsigned char new_note_action; - unsigned char const* arpeggio_table; - signed char arpeggio_offsets[3]; + unsigned char const *arpeggio_table; + signed char arpeggio_offsets[3]; - int arpeggio_shift; - unsigned char retrig; - unsigned char xm_retrig; - int retrig_tick; + int arpeggio_shift; + unsigned char retrig; + unsigned char xm_retrig; + int retrig_tick; - unsigned char tremor; - unsigned char tremor_time; /* Bit 6 set if note on; bit 7 set if tremor active. */ + unsigned char tremor; + unsigned char + tremor_time; /* Bit 6 set if note on; bit 7 set if tremor active. */ - unsigned char vibrato_waveform; - unsigned char tremolo_waveform; - unsigned char panbrello_waveform; + unsigned char vibrato_waveform; + unsigned char tremolo_waveform; + unsigned char panbrello_waveform; - int portamento; - int toneporta; - int toneslide; - unsigned char toneslide_tick, last_toneslide_tick, ptm_toneslide, ptm_last_toneslide, okt_toneslide; - unsigned char destnote; - unsigned char toneslide_retrig; + int portamento; + int toneporta; + int toneslide; + unsigned char toneslide_tick, last_toneslide_tick, ptm_toneslide, + ptm_last_toneslide, okt_toneslide; + unsigned char destnote; + unsigned char toneslide_retrig; - unsigned char glissando; + unsigned char glissando; - /** WARNING - for neatness, should one or both of these be in the IT_PLAYING struct? */ - unsigned short sample; - unsigned char truenote; + /** WARNING - for neatness, should one or both of these be in the IT_PLAYING + * struct? */ + unsigned short sample; + unsigned char truenote; - unsigned char midi_state; + unsigned char midi_state; - signed char lastvolslide; - unsigned char lastDKL; - unsigned char lastEF; /* Doubles as last portamento up for XM files */ - unsigned char lastG; - unsigned char lastHspeed; - unsigned char lastHdepth; - unsigned char lastRspeed; - unsigned char lastRdepth; - unsigned char lastYspeed; - unsigned char lastYdepth; - unsigned char lastI; - unsigned char lastJ; /* Doubles as last portamento down for XM files */ - unsigned char lastN; - unsigned char lastO; - unsigned char high_offset; - unsigned char lastP; - unsigned char lastQ; - unsigned char lastS; - unsigned char pat_loop_row; - unsigned char pat_loop_count; - unsigned char pat_loop_end_row; /* Used to catch infinite pattern loops */ - unsigned char lastW; + signed char lastvolslide; + unsigned char lastDKL; + unsigned char lastEF; /* Doubles as last portamento up for XM files */ + unsigned char lastG; + unsigned char lastHspeed; + unsigned char lastHdepth; + unsigned char lastRspeed; + unsigned char lastRdepth; + unsigned char lastYspeed; + unsigned char lastYdepth; + unsigned char lastI; + unsigned char lastJ; /* Doubles as last portamento down for XM files */ + unsigned char lastN; + unsigned char lastO; + unsigned char high_offset; + unsigned char lastP; + unsigned char lastQ; + unsigned char lastS; + unsigned char pat_loop_row; + unsigned char pat_loop_count; + unsigned char pat_loop_end_row; /* Used to catch infinite pattern loops */ + unsigned char lastW; - unsigned char xm_lastE1; - unsigned char xm_lastE2; - unsigned char xm_lastEA; - unsigned char xm_lastEB; - unsigned char xm_lastX1; - unsigned char xm_lastX2; + unsigned char xm_lastE1; + unsigned char xm_lastE2; + unsigned char xm_lastEA; + unsigned char xm_lastEB; + unsigned char xm_lastX1; + unsigned char xm_lastX2; - unsigned char inv_loop_delay; - unsigned char inv_loop_speed; - int inv_loop_offset; + unsigned char inv_loop_delay; + unsigned char inv_loop_speed; + int inv_loop_offset; - IT_PLAYING *playing; + IT_PLAYING *playing; #ifdef BIT_ARRAY_BULLSHIT - void * played_patjump; - int played_patjump_order; + void *played_patjump; + int played_patjump_order; #endif - //int output; + // int output; }; +struct DUMB_IT_SIGRENDERER { + DUMB_IT_SIGDATA *sigdata; + int n_channels; -struct DUMB_IT_SIGRENDERER -{ - DUMB_IT_SIGDATA *sigdata; + int resampling_quality; - int n_channels; + unsigned char globalvolume; + signed char globalvolslide; - int resampling_quality; + int tempo; + signed char temposlide; - unsigned char globalvolume; - signed char globalvolslide; + IT_CHANNEL channel[DUMB_IT_N_CHANNELS]; - int tempo; - signed char temposlide; + IT_PLAYING *playing[DUMB_IT_N_NNA_CHANNELS]; - IT_CHANNEL channel[DUMB_IT_N_CHANNELS]; + int tick; + int speed; + int rowcount; - IT_PLAYING *playing[DUMB_IT_N_NNA_CHANNELS]; + int order; /* Set to -1 if the song is terminated by a callback. */ + int row; + int processorder; + int processrow; + int breakrow; - int tick; - int speed; - int rowcount; + int restart_position; - int order; /* Set to -1 if the song is terminated by a callback. */ - int row; - int processorder; - int processrow; - int breakrow; + int n_rows; - int restart_position; + IT_ENTRY *entry_start; + IT_ENTRY *entry; + IT_ENTRY *entry_end; - int n_rows; + long time_left; /* Time before the next tick is processed */ + int sub_time_left; - IT_ENTRY *entry_start; - IT_ENTRY *entry; - IT_ENTRY *entry_end; + DUMB_CLICK_REMOVER **click_remover; - long time_left; /* Time before the next tick is processed */ - int sub_time_left; - - DUMB_CLICK_REMOVER **click_remover; - - IT_CALLBACKS *callbacks; + IT_CALLBACKS *callbacks; #ifdef BIT_ARRAY_BULLSHIT - /* bit array, which rows are played, only checked by pattern break or loop commands */ - void * played; + /* bit array, which rows are played, only checked by pattern break or loop + * commands */ + void *played; - /* - Loop indicator for internal processes, may also be useful for external processes - 0 - Not looped - 1 - Looped - -1 - Continued past loop - */ - int looped; + /* + Loop indicator for internal processes, may also be useful for external + processes 0 - Not looped 1 - Looped -1 - Continued past loop + */ + int looped; - /* - Kept until looped - */ - LONG_LONG time_played; + /* + Kept until looped + */ + LONG_LONG time_played; - void * row_timekeeper; + void *row_timekeeper; #endif - long gvz_time; - int gvz_sub_time; + long gvz_time; + int gvz_sub_time; int ramp_style; - - //int max_output; + + // int max_output; }; - - -struct IT_CHECKPOINT -{ - IT_CHECKPOINT *next; - long time; - DUMB_IT_SIGRENDERER *sigrenderer; +struct IT_CHECKPOINT { + IT_CHECKPOINT *next; + long time; + DUMB_IT_SIGRENDERER *sigrenderer; }; +struct IT_CALLBACKS { + int (*loop)(void *data); + void *loop_data; + /* Return 1 to prevent looping; the music will terminate abruptly. If you + * want to make the music stop but allow samples to fade (beware, as they + * might not fade at all!), use dumb_it_sr_set_speed() and set the speed + * to 0. Note that xm_speed_zero() will not be called if you set the + * speed manually, and also that this will work for IT and S3M files even + * though the music can't stop in this way by itself. + */ + int (*xm_speed_zero)(void *data); + void *xm_speed_zero_data; + /* Return 1 to terminate the mod, without letting samples fade. */ -struct IT_CALLBACKS -{ - int (*loop)(void *data); - void *loop_data; - /* Return 1 to prevent looping; the music will terminate abruptly. If you - * want to make the music stop but allow samples to fade (beware, as they - * might not fade at all!), use dumb_it_sr_set_speed() and set the speed - * to 0. Note that xm_speed_zero() will not be called if you set the - * speed manually, and also that this will work for IT and S3M files even - * though the music can't stop in this way by itself. - */ + int (*midi)(void *data, int channel, unsigned char byte); + void *midi_data; + /* Return 1 to prevent DUMB from subsequently interpreting the MIDI bytes + * itself. In other words, return 1 if the Zxx macros in an IT file are + * controlling filters and shouldn't be. + */ - int (*xm_speed_zero)(void *data); - void *xm_speed_zero_data; - /* Return 1 to terminate the mod, without letting samples fade. */ - - int (*midi)(void *data, int channel, unsigned char byte); - void *midi_data; - /* Return 1 to prevent DUMB from subsequently interpreting the MIDI bytes - * itself. In other words, return 1 if the Zxx macros in an IT file are - * controlling filters and shouldn't be. - */ - - int (*global_volume_zero)(void *data); - void *global_volume_zero_data; - /* Return 1 to terminate the module when global volume is set to zero. */ + int (*global_volume_zero)(void *data); + void *global_volume_zero_data; + /* Return 1 to terminate the module when global volume is set to zero. */ }; - - void _dumb_it_end_sigrenderer(sigrenderer_t *sigrenderer); void _dumb_it_unload_sigdata(sigdata_t *vsigdata); extern DUH_SIGTYPE_DESC _dumb_sigtype_it; +#define XM_APPREGIO 0 +#define XM_PORTAMENTO_UP 1 +#define XM_PORTAMENTO_DOWN 2 +#define XM_TONE_PORTAMENTO 3 +#define XM_VIBRATO 4 +#define XM_VOLSLIDE_TONEPORTA 5 +#define XM_VOLSLIDE_VIBRATO 6 +#define XM_TREMOLO 7 +#define XM_SET_PANNING 8 +#define XM_SAMPLE_OFFSET 9 +#define XM_VOLUME_SLIDE 10 /* A */ +#define XM_POSITION_JUMP 11 /* B */ +#define XM_SET_CHANNEL_VOLUME 12 /* C */ +#define XM_PATTERN_BREAK 13 /* D */ +#define XM_E 14 /* E */ +#define XM_SET_TEMPO_BPM 15 /* F */ +#define XM_SET_GLOBAL_VOLUME 16 /* G */ +#define XM_GLOBAL_VOLUME_SLIDE 17 /* H */ +#define XM_KEY_OFF 20 /* K (undocumented) */ +#define XM_SET_ENVELOPE_POSITION 21 /* L */ +#define XM_PANNING_SLIDE 25 /* P */ +#define XM_MULTI_RETRIG 27 /* R */ +#define XM_TREMOR 29 /* T */ +#define XM_X 33 /* X */ +#define XM_N_EFFECTS (10 + 26) - -#define XM_APPREGIO 0 -#define XM_PORTAMENTO_UP 1 -#define XM_PORTAMENTO_DOWN 2 -#define XM_TONE_PORTAMENTO 3 -#define XM_VIBRATO 4 -#define XM_VOLSLIDE_TONEPORTA 5 -#define XM_VOLSLIDE_VIBRATO 6 -#define XM_TREMOLO 7 -#define XM_SET_PANNING 8 -#define XM_SAMPLE_OFFSET 9 -#define XM_VOLUME_SLIDE 10 /* A */ -#define XM_POSITION_JUMP 11 /* B */ -#define XM_SET_CHANNEL_VOLUME 12 /* C */ -#define XM_PATTERN_BREAK 13 /* D */ -#define XM_E 14 /* E */ -#define XM_SET_TEMPO_BPM 15 /* F */ -#define XM_SET_GLOBAL_VOLUME 16 /* G */ -#define XM_GLOBAL_VOLUME_SLIDE 17 /* H */ -#define XM_KEY_OFF 20 /* K (undocumented) */ -#define XM_SET_ENVELOPE_POSITION 21 /* L */ -#define XM_PANNING_SLIDE 25 /* P */ -#define XM_MULTI_RETRIG 27 /* R */ -#define XM_TREMOR 29 /* T */ -#define XM_X 33 /* X */ -#define XM_N_EFFECTS (10+26) - -#define XM_E_SET_FILTER 0x0 -#define XM_E_FINE_PORTA_UP 0x1 -#define XM_E_FINE_PORTA_DOWN 0x2 +#define XM_E_SET_FILTER 0x0 +#define XM_E_FINE_PORTA_UP 0x1 +#define XM_E_FINE_PORTA_DOWN 0x2 #define XM_E_SET_GLISSANDO_CONTROL 0x3 -#define XM_E_SET_VIBRATO_CONTROL 0x4 -#define XM_E_SET_FINETUNE 0x5 -#define XM_E_SET_LOOP 0x6 -#define XM_E_SET_TREMOLO_CONTROL 0x7 -#define XM_E_SET_PANNING 0x8 -#define XM_E_RETRIG_NOTE 0x9 -#define XM_E_FINE_VOLSLIDE_UP 0xA -#define XM_E_FINE_VOLSLIDE_DOWN 0xB -#define XM_E_NOTE_CUT 0xC -#define XM_E_NOTE_DELAY 0xD -#define XM_E_PATTERN_DELAY 0xE -#define XM_E_SET_MIDI_MACRO 0xF +#define XM_E_SET_VIBRATO_CONTROL 0x4 +#define XM_E_SET_FINETUNE 0x5 +#define XM_E_SET_LOOP 0x6 +#define XM_E_SET_TREMOLO_CONTROL 0x7 +#define XM_E_SET_PANNING 0x8 +#define XM_E_RETRIG_NOTE 0x9 +#define XM_E_FINE_VOLSLIDE_UP 0xA +#define XM_E_FINE_VOLSLIDE_DOWN 0xB +#define XM_E_NOTE_CUT 0xC +#define XM_E_NOTE_DELAY 0xD +#define XM_E_PATTERN_DELAY 0xE +#define XM_E_SET_MIDI_MACRO 0xF -#define XM_X_EXTRAFINE_PORTA_UP 1 -#define XM_X_EXTRAFINE_PORTA_DOWN 2 +#define XM_X_EXTRAFINE_PORTA_UP 1 +#define XM_X_EXTRAFINE_PORTA_DOWN 2 /* To make my life a bit simpler during conversion, effect E:xy is converted * to effect number EBASE+x:y. The same applies to effect X, and IT's S. That * way, these effects can be manipulated like regular effects. */ -#define EBASE (XM_N_EFFECTS) -#define XBASE (EBASE+16) -#define SBASE (IT_N_EFFECTS) - -#define EFFECT_VALUE(x, y) (((x)<<4)|(y)) -#define HIGH(v) ((v)>>4) -#define LOW(v) ((v)&0x0F) -#define SET_HIGH(v, x) v = (((x)<<4)|((v)&0x0F)) -#define SET_LOW(v, y) v = (((v)&0xF0)|(y)) -#define BCD_TO_NORMAL(v) (HIGH(v)*10+LOW(v)) - +#define EBASE (XM_N_EFFECTS) +#define XBASE (EBASE + 16) +#define SBASE (IT_N_EFFECTS) +#define EFFECT_VALUE(x, y) (((x) << 4) | (y)) +#define HIGH(v) ((v) >> 4) +#define LOW(v) ((v)&0x0F) +#define SET_HIGH(v, x) v = (((x) << 4) | ((v)&0x0F)) +#define SET_LOW(v, y) v = (((v)&0xF0) | (y)) +#define BCD_TO_NORMAL(v) (HIGH(v) * 10 + LOW(v)) #if 0 unsigned char **_dumb_malloc2(int w, int h); void _dumb_free2(unsigned char **line); #endif -void _dumb_it_xm_convert_effect(int effect, int value, IT_ENTRY *entry, int mod); +void _dumb_it_xm_convert_effect(int effect, int value, IT_ENTRY *entry, + int mod); int _dumb_it_fix_invalid_orders(DUMB_IT_SIGDATA *sigdata); +#define PTM_APPREGIO 0 +#define PTM_PORTAMENTO_UP 1 +#define PTM_PORTAMENTO_DOWN 2 +#define PTM_TONE_PORTAMENTO 3 +#define PTM_VIBRATO 4 +#define PTM_VOLSLIDE_TONEPORTA 5 +#define PTM_VOLSLIDE_VIBRATO 6 +#define PTM_TREMOLO 7 +#define PTM_SAMPLE_OFFSET 9 +#define PTM_VOLUME_SLIDE 10 /* A */ +#define PTM_POSITION_JUMP 11 /* B */ +#define PTM_SET_CHANNEL_VOLUME 12 /* C */ +#define PTM_PATTERN_BREAK 13 /* D */ +#define PTM_E 14 /* E */ +#define PTM_SET_TEMPO_BPM 15 /* F */ +#define PTM_SET_GLOBAL_VOLUME 16 /* G */ +#define PTM_RETRIGGER 17 /* H */ +#define PTM_FINE_VIBRATO 18 /* I */ +#define PTM_NOTE_SLIDE_UP 19 /* J */ +#define PTM_NOTE_SLIDE_DOWN 20 /* K */ +#define PTM_NOTE_SLIDE_UP_RETRIG 21 /* L */ +#define PTM_NOTE_SLIDE_DOWN_RETRIG 22 /* M */ +#define PTM_N_EFFECTS 23 -#define PTM_APPREGIO 0 -#define PTM_PORTAMENTO_UP 1 -#define PTM_PORTAMENTO_DOWN 2 -#define PTM_TONE_PORTAMENTO 3 -#define PTM_VIBRATO 4 -#define PTM_VOLSLIDE_TONEPORTA 5 -#define PTM_VOLSLIDE_VIBRATO 6 -#define PTM_TREMOLO 7 -#define PTM_SAMPLE_OFFSET 9 -#define PTM_VOLUME_SLIDE 10 /* A */ -#define PTM_POSITION_JUMP 11 /* B */ -#define PTM_SET_CHANNEL_VOLUME 12 /* C */ -#define PTM_PATTERN_BREAK 13 /* D */ -#define PTM_E 14 /* E */ -#define PTM_SET_TEMPO_BPM 15 /* F */ -#define PTM_SET_GLOBAL_VOLUME 16 /* G */ -#define PTM_RETRIGGER 17 /* H */ -#define PTM_FINE_VIBRATO 18 /* I */ -#define PTM_NOTE_SLIDE_UP 19 /* J */ -#define PTM_NOTE_SLIDE_DOWN 20 /* K */ -#define PTM_NOTE_SLIDE_UP_RETRIG 21 /* L */ -#define PTM_NOTE_SLIDE_DOWN_RETRIG 22 /* M */ -#define PTM_N_EFFECTS 23 - -#define PTM_E_FINE_PORTA_DOWN 0x1 -#define PTM_E_FINE_PORTA_UP 0x2 -#define PTM_E_SET_VIBRATO_CONTROL 0x4 -#define PTM_E_SET_FINETUNE 0x5 -#define PTM_E_SET_LOOP 0x6 -#define PTM_E_SET_TREMOLO_CONTROL 0x7 -#define PTM_E_SET_PANNING 0x8 -#define PTM_E_RETRIG_NOTE 0x9 -#define PTM_E_FINE_VOLSLIDE_UP 0xA -#define PTM_E_FINE_VOLSLIDE_DOWN 0xB -#define PTM_E_NOTE_CUT 0xC -#define PTM_E_NOTE_DELAY 0xD -#define PTM_E_PATTERN_DELAY 0xE +#define PTM_E_FINE_PORTA_DOWN 0x1 +#define PTM_E_FINE_PORTA_UP 0x2 +#define PTM_E_SET_VIBRATO_CONTROL 0x4 +#define PTM_E_SET_FINETUNE 0x5 +#define PTM_E_SET_LOOP 0x6 +#define PTM_E_SET_TREMOLO_CONTROL 0x7 +#define PTM_E_SET_PANNING 0x8 +#define PTM_E_RETRIG_NOTE 0x9 +#define PTM_E_FINE_VOLSLIDE_UP 0xA +#define PTM_E_FINE_VOLSLIDE_DOWN 0xB +#define PTM_E_NOTE_CUT 0xC +#define PTM_E_NOTE_DELAY 0xD +#define PTM_E_PATTERN_DELAY 0xE /* To make my life a bit simpler during conversion, effect E:xy is converted * to effect number EBASE+x:y. The same applies to effect X, and IT's S. That * way, these effects can be manipulated like regular effects. */ -#define PTM_EBASE (PTM_N_EFFECTS) +#define PTM_EBASE (PTM_N_EFFECTS) void _dumb_it_ptm_convert_effect(int effect, int value, IT_ENTRY *entry); @@ -918,9 +866,9 @@ long _dumb_it_read_sample_data_adpcm4(IT_SAMPLE *sample, DUMBFILE *f); void _dumb_it_interleave_stereo_sample(IT_SAMPLE *sample); /* Calling either of these is optional */ -void _dumb_init_cubic(); +void _dumb_init_cubic(void); #ifdef _USE_SSE -void _dumb_init_sse(); +void _dumb_init_sse(void); #endif #endif /* INTERNAL_IT_H */ diff --git a/Frameworks/Dumb/dumb/include/internal/resampler.h b/Frameworks/Dumb/dumb/include/internal/resampler.h index d0283a340..375fe8cfd 100644 --- a/Frameworks/Dumb/dumb/include/internal/resampler.h +++ b/Frameworks/Dumb/dumb/include/internal/resampler.h @@ -5,36 +5,44 @@ #ifdef RESAMPLER_DECORATE #undef PASTE #undef EVALUATE -#define PASTE(a,b) a ## b -#define EVALUATE(a,b) PASTE(a,b) -#define resampler_init EVALUATE(RESAMPLER_DECORATE,_resampler_init) -#define resampler_create EVALUATE(RESAMPLER_DECORATE,_resampler_create) -#define resampler_delete EVALUATE(RESAMPLER_DECORATE,_resampler_delete) -#define resampler_dup EVALUATE(RESAMPLER_DECORATE,_resampler_dup) -#define resampler_dup_inplace EVALUATE(RESAMPLER_DECORATE,_resampler_dup_inplace) -#define resampler_set_quality EVALUATE(RESAMPLER_DECORATE,_resampler_set_quality) -#define resampler_get_free_count EVALUATE(RESAMPLER_DECORATE,_resampler_get_free_count) -#define resampler_write_sample EVALUATE(RESAMPLER_DECORATE,_resampler_write_sample) -#define resampler_write_sample_fixed EVALUATE(RESAMPLER_DECORATE,_resampler_write_sample_fixed) -#define resampler_write_sample_float EVALUATE(RESAMPLER_DECORATE,_resampler_write_sample_float) -#define resampler_set_rate EVALUATE(RESAMPLER_DECORATE,_resampler_set_rate) -#define resampler_ready EVALUATE(RESAMPLER_DECORATE,_resampler_ready) -#define resampler_clear EVALUATE(RESAMPLER_DECORATE,_resampler_clear) -#define resampler_get_sample_count EVALUATE(RESAMPLER_DECORATE,_resampler_get_sample_count) -#define resampler_get_sample EVALUATE(RESAMPLER_DECORATE,_resampler_get_sample) -#define resampler_get_sample_float EVALUATE(RESAMPLER_DECORATE,_resampler_get_sample_float) -#define resampler_remove_sample EVALUATE(RESAMPLER_DECORATE,_resampler_remove_sample) +#define PASTE(a, b) a##b +#define EVALUATE(a, b) PASTE(a, b) +#define resampler_init EVALUATE(RESAMPLER_DECORATE, _resampler_init) +#define resampler_create EVALUATE(RESAMPLER_DECORATE, _resampler_create) +#define resampler_delete EVALUATE(RESAMPLER_DECORATE, _resampler_delete) +#define resampler_dup EVALUATE(RESAMPLER_DECORATE, _resampler_dup) +#define resampler_dup_inplace \ + EVALUATE(RESAMPLER_DECORATE, _resampler_dup_inplace) +#define resampler_set_quality \ + EVALUATE(RESAMPLER_DECORATE, _resampler_set_quality) +#define resampler_get_free_count \ + EVALUATE(RESAMPLER_DECORATE, _resampler_get_free_count) +#define resampler_write_sample \ + EVALUATE(RESAMPLER_DECORATE, _resampler_write_sample) +#define resampler_write_sample_fixed \ + EVALUATE(RESAMPLER_DECORATE, _resampler_write_sample_fixed) +#define resampler_write_sample_float \ + EVALUATE(RESAMPLER_DECORATE, _resampler_write_sample_float) +#define resampler_set_rate EVALUATE(RESAMPLER_DECORATE, _resampler_set_rate) +#define resampler_ready EVALUATE(RESAMPLER_DECORATE, _resampler_ready) +#define resampler_clear EVALUATE(RESAMPLER_DECORATE, _resampler_clear) +#define resampler_get_sample_count \ + EVALUATE(RESAMPLER_DECORATE, _resampler_get_sample_count) +#define resampler_get_sample EVALUATE(RESAMPLER_DECORATE, _resampler_get_sample) +#define resampler_get_sample_float \ + EVALUATE(RESAMPLER_DECORATE, _resampler_get_sample_float) +#define resampler_remove_sample \ + EVALUATE(RESAMPLER_DECORATE, _resampler_remove_sample) #endif void resampler_init(void); -void * resampler_create(void); +void *resampler_create(void); void resampler_delete(void *); -void * resampler_dup(const void *); +void *resampler_dup(const void *); void resampler_dup_inplace(void *, const void *); -enum -{ +enum { RESAMPLER_QUALITY_MIN = 0, RESAMPLER_QUALITY_ZOH = 0, RESAMPLER_QUALITY_BLEP = 1, @@ -51,7 +59,7 @@ int resampler_get_free_count(void *); void resampler_write_sample(void *, short sample); void resampler_write_sample_fixed(void *, int sample, unsigned char depth); void resampler_write_sample_float(void *, float sample); -void resampler_set_rate( void *, double new_factor ); +void resampler_set_rate(void *, double new_factor); int resampler_ready(void *); void resampler_clear(void *); int resampler_get_sample_count(void *); diff --git a/Frameworks/Dumb/dumb/include/internal/riff.h b/Frameworks/Dumb/dumb/include/internal/riff.h index d8705a95f..c348a8e11 100644 --- a/Frameworks/Dumb/dumb/include/internal/riff.h +++ b/Frameworks/Dumb/dumb/include/internal/riff.h @@ -3,22 +3,20 @@ struct riff; -struct riff_chunk -{ - unsigned type; +struct riff_chunk { + unsigned type; long offset; - unsigned size; - struct riff * nested; + unsigned size; + struct riff *nested; }; -struct riff -{ - unsigned type; - unsigned chunk_count; - struct riff_chunk * chunks; +struct riff { + unsigned type; + unsigned chunk_count; + struct riff_chunk *chunks; }; -struct riff * riff_parse( DUMBFILE * f, long offset, long size, unsigned proper ); -void riff_free( struct riff * ); +struct riff *riff_parse(DUMBFILE *f, long offset, long size, unsigned proper); +void riff_free(struct riff *); #endif diff --git a/Frameworks/Dumb/dumb/include/internal/stack_alloc.h b/Frameworks/Dumb/dumb/include/internal/stack_alloc.h index b82edec05..5f257ff78 100644 --- a/Frameworks/Dumb/dumb/include/internal/stack_alloc.h +++ b/Frameworks/Dumb/dumb/include/internal/stack_alloc.h @@ -36,13 +36,13 @@ #define STACK_ALLOC_H #ifdef WIN32 -# include +#include #else -# ifdef HAVE_ALLOCA_H -# include -# else -# include -# endif +#ifdef HAVE_ALLOCA_H +#include +#else +#include +#endif #endif /** @@ -86,15 +86,21 @@ #include -#define ALIGN(stack, size) ((stack) += ((size) - (long)(stack)) & ((size) - 1)) +#define ALIGN(stack, size) ((stack) += ((size) - (long)(stack)) & ((size)-1)) -#define PUSH(stack, size, type) (VALGRIND_MAKE_NOACCESS(stack, 1000),ALIGN((stack),sizeof(type)),VALGRIND_MAKE_WRITABLE(stack, ((size)*sizeof(type))),(stack)+=((size)*sizeof(type)),(type*)((stack)-((size)*sizeof(type)))) +#define PUSH(stack, size, type) \ + (VALGRIND_MAKE_NOACCESS(stack, 1000), ALIGN((stack), sizeof(type)), \ + VALGRIND_MAKE_WRITABLE(stack, ((size) * sizeof(type))), \ + (stack) += ((size) * sizeof(type)), \ + (type *)((stack) - ((size) * sizeof(type)))) #else -#define ALIGN(stack, size) ((stack) += ((size) - (long)(stack)) & ((size) - 1)) +#define ALIGN(stack, size) ((stack) += ((size) - (long)(stack)) & ((size)-1)) -#define PUSH(stack, size, type) (ALIGN((stack),sizeof(type)),(stack)+=((size)*sizeof(type)),(type*)((stack)-((size)*sizeof(type)))) +#define PUSH(stack, size, type) \ + (ALIGN((stack), sizeof(type)), (stack) += ((size) * sizeof(type)), \ + (type *)((stack) - ((size) * sizeof(type)))) #endif @@ -103,11 +109,10 @@ #define ALLOC(var, size, type) type var[size] #elif defined(USE_ALLOCA) #define VARDECL(var) var -#define ALLOC(var, size, type) var = alloca(sizeof(type)*(size)) +#define ALLOC(var, size, type) var = alloca(sizeof(type) * (size)) #else #define VARDECL(var) var #define ALLOC(var, size, type) var = PUSH(stack, size, type) #endif - #endif diff --git a/Frameworks/Dumb/dumb/include/internal/tarray.h b/Frameworks/Dumb/dumb/include/internal/tarray.h index 7eb3af7c6..2249d7bd9 100644 --- a/Frameworks/Dumb/dumb/include/internal/tarray.h +++ b/Frameworks/Dumb/dumb/include/internal/tarray.h @@ -2,30 +2,19 @@ #define _T_ARRAY_H_ #include +#include "internal/dumb.h" -#ifndef LONG_LONG -#if defined __GNUC__ || defined __INTEL_COMPILER || defined __MWERKS__ -#define LONG_LONG long long -#elif defined _MSC_VER || defined __WATCOMC__ -#define LONG_LONG __int64 -#elif defined __sgi -#define LONG_LONG long long -#else -#error 64-bit integer type unknown -#endif -#endif +void *timekeeping_array_create(size_t size); +void timekeeping_array_destroy(void *array); +void *timekeeping_array_dup(void *array); -void * timekeeping_array_create(size_t size); -void timekeeping_array_destroy(void * array); -void * timekeeping_array_dup(void * array); +void timekeeping_array_reset(void *array, size_t loop_start); -void timekeeping_array_reset(void * array, size_t loop_start); +void timekeeping_array_push(void *array, size_t index, LONG_LONG time); +void timekeeping_array_bump(void *array, size_t index); -void timekeeping_array_push(void * array, size_t index, LONG_LONG time); -void timekeeping_array_bump(void * array, size_t index); +unsigned int timekeeping_array_get_count(void *array, size_t index); -unsigned int timekeeping_array_get_count(void * array, size_t index); - -LONG_LONG timekeeping_array_get_item(void * array, size_t index); +LONG_LONG timekeeping_array_get_item(void *array, size_t index); #endif diff --git a/Frameworks/Dumb/dumb/licence.txt b/Frameworks/Dumb/dumb/licence.txt deleted file mode 100644 index cc707d220..000000000 --- a/Frameworks/Dumb/dumb/licence.txt +++ /dev/null @@ -1,77 +0,0 @@ -/* _______ ____ __ ___ ___ - * \ _ \ \ / \ / \ \ / / ' ' ' - * | | \ \ | | || | \/ | . . - * | | | | | | || ||\ /| | - * | | | | | | || || \/ | | ' ' ' - * | | | | | | || || | | . . - * | |_/ / \ \__// || | | - * /_______/ynamic \____/niversal /__\ /____\usic /| . . ibliotheque - * / \ - * / . \ - * licence.txt - Conditions for use of DUMB. / / \ \ - * | < / \_ - * If you do not agree to these terms, please | \/ /\ / - * do not use DUMB. \_ / > / - * | \ / / - * Information in [brackets] is provided to aid | ' / - * interpretation of the licence. \__/ - */ - - -Dynamic Universal Music Bibliotheque, Version 0.9.3 - -Copyright (C) 2001-2005 Ben Davis, Robert J Ohannessian and Julien Cugniere - -This software is provided 'as-is', without any express or implied warranty. -In no event shall the authors be held liable for any damages arising from the -use of this software. - -Permission is granted to anyone to use this software for any purpose, -including commercial applications, and to alter it and redistribute it -freely, subject to the following restrictions: - -1. The origin of this software must not be misrepresented; you must not claim - that you wrote the original software. If you use this software in a - product, you are requested to acknowledge its use in the product - documentation, along with details on where to get an unmodified version of - this software, but this is not a strict requirement. - - [Note that the above point asks for a link to DUMB, not just a mention. - Googling for DUMB doesn't help much! The URL is "http://dumb.sf.net/".] - - [The link was originally strictly required. This was changed for two - reasons. Firstly, if many projects request an acknowledgement, the list of - acknowledgements can become quite unmanageable. Secondly, DUMB was placing - a restriction on the code using it, preventing people from using the GNU - General Public Licence which disallows any such restrictions. See - http://www.gnu.org/philosophy/bsd.html for more information on this - subject. However, if DUMB plays a significant part in your project, we do - urge you to acknowledge its use.] - -2. Altered source versions must be plainly marked as such, and must not be - misrepresented as being the original software. - -3. This notice may not be removed from or altered in any source distribution. - -4. If you are using the Program in someone else's bedroom on any Monday at - 3:05 pm, you are not allowed to modify the Program for ten minutes. [This - clause provided by Inphernic; every licence should contain at least one - clause, the reasoning behind which is far from obvious.] - -5. Users who wish to use DUMB for the specific purpose of playing music are - required to feed their dog on every full moon (if deemed appropriate). - [This clause provided by Allefant, who couldn't remember what Inphernic's - clause was.] - -6. No clause in this licence shall prevent this software from being depended - upon by a product licensed under the GNU General Public Licence. If such a - clause is deemed to exist, Debian, then it shall be respected in spirit as - far as possible and all other clauses shall continue to apply in full - force. - -We regret that we cannot provide any warranty, not even the implied warranty -of merchantability or fitness for a particular purpose. - -Some files generated or copied by automake, autoconf and friends are -available in an extra download. These fall under separate licences but are -all free to distribute. Please check their licences as necessary. diff --git a/Frameworks/Dumb/dumb/readme.txt b/Frameworks/Dumb/dumb/readme.txt deleted file mode 100644 index e86af048a..000000000 --- a/Frameworks/Dumb/dumb/readme.txt +++ /dev/null @@ -1,541 +0,0 @@ -/* _______ ____ __ ___ ___ - * \ _ \ \ / \ / \ \ / / ' ' ' - * | | \ \ | | || | \/ | . . - * | | | | | | || ||\ /| | - * | | | | | | || || \/ | | ' ' ' - * | | | | | | || || | | . . - * | |_/ / \ \__// || | | - * /_______/ynamic \____/niversal /__\ /____\usic /| . . ibliotheque - * / \ - * / . \ - * readme.txt - General information on DUMB. / / \ \ - * | < / \_ - * | \/ /\ / - * \_ / > / - * | \ / / - * | ' / - * \__/ - */ - - -******************** -*** Introduction *** -******************** - - -Thank you for downloading DUMB v0.9.3! You should have the following -documentation: - - readme.txt - This file - licence.txt - Conditions for the use of this software - release.txt - Release notes and changes for this and past releases - docs/ - howto.txt - Step-by-step instructions on adding DUMB to your project - faq.txt - Frequently asked questions and answers to them - dumb.txt - DUMB library reference - deprec.txt - Information about deprecated parts of the API - ptr.txt - Quick introduction to pointers for those who need it - fnptr.txt - Explanation of function pointers for those who need it - modplug.txt - Our official position regarding ModPlug Tracker - -This file will help you get DUMB set up. If you have not yet done so, please -read licence.txt and release.txt before proceeding. After you've got DUMB set -up, please refer to the files in the docs/ directory at your convenience. I -recommend you start with howto.txt. - - -**************** -*** Features *** -**************** - - -Here is the statutory feature list: - -- Freeware - -- Supports playback of IT, XM, S3M and MOD files - -- Faithful to the original trackers, especially IT; if it plays your module - wrongly, please tell me so I can fix the bug! (But please don't complain - about differences between DUMB and ModPlug Tracker; see docs/modplug.txt) - -- Accurate support for low-pass resonant filters for IT files - -- Very accurate timing and pitching; completely deterministic playback - -- Click removal - -- Facility to embed music files in other files (e.g. Allegro datafiles) - -- Three resampling quality settings: aliasing, linear interpolation and cubic - interpolation - -- Number of samples playing at once can be limited to reduce processor usage, - but samples will come back in when other louder ones stop - -- All notes will be present and correct even if you start a piece of music in - the middle - -- Option to take longer loading but seek fast to any point before the music - first loops (seeking time increases beyond this point) - -- Audio generated can be used in any way; DUMB does not necessarily send it - straight to a sound output system - -- Can be used with Allegro, can be used without (if you'd like to help make - DUMB more approachable to people who aren't using Allegro, please contact - me) - -- Makefile provided for DJGPP, MinGW, Linux, BeOS and Mac OS X - -- Project files provided for MSVC 6 - -- Autotools-based configure script available as a separate download for - masochists - -- Code should port anywhere that has a 32-bit C compiler; instructions on - compiling it manually are available further down - - -********************* -*** What you need *** -********************* - - -To use DUMB, you need a 32-bit C compiler (GCC and MSVC are fine). If you -have Allegro, DUMB can integrate with its audio streams and datafiles, making -your life easier. If you do not wish to use Allegro, you will have to do some -work to get music playing back. The 'dumbplay' example program requires -Allegro. - - Allegro - http://alleg.sf.net/ - - -********************************************** -*** How to set DUMB up with DJGPP or MinGW *** -********************************************** - - -You should have got the .zip version. If for some reason you got the .tar.gz -version instead, you may have to convert make/config.bat to DOS text file -format. WinZip does this automatically by default. Otherwise, loading it into -MS EDIT and saving it again should do the trick (but do not do this to the -Makefiles as it destroys tabs). You will have to do the same for any files -you want to view in Windows Notepad. If you have problems, just go and -download the .zip instead. - -Make sure you preserved the directory structure when you extracted DUMB from -the archive. Most unzipping programs will do this by default, but pkunzip -requires you to pass -d. If not, please delete DUMB and extract it again -properly. - -If you are using Windows, open an MS-DOS Prompt or a Windows Command Line. -Change to the directory into which you unzipped DUMB. - -If you are using MinGW (and you haven't renamed 'mingw32-make'), type: - - mingw32-make - -Otherwise, type the following: - - make - -DUMB will ask you whether you wish to compile for DJGPP or MinGW. Then it -will ask you whether you want support for Allegro. (You have to have made and -installed Allegro's optimised library for this to work.) Finally, it will -compile optimised and debugging builds of DUMB, along with the example -programs. When it has finished, run one of the following to install the -libraries: - - make install - mingw32-make install - -All done! If you ever need the configuration again (e.g. if you compiled for -DJGPP before and you want to compile for MinGW now), run one of the -following: - - make config - mingw32-make config - -See the comments in the Makefile for other targets. - -Note: the Makefile will only work properly if you have COMSPEC or ComSpec set -to point to command.com or cmd.exe. If you set it to point to a Unix-style -shell, the Makefile won't work. - -Please let me know if you have any trouble. - -As an alternative, MSYS users may attempt to use the configure script, -available in dumb-0.9.3-autotools.tar.gz. This has been found to work without -Allegro, and is untested with Allegro. I should appreciate feedback from -anyone else who tries this. I do not recommend its use, partly because it -creates dynamically linked libraries and I don't know how to stop it from -doing that (see the section on compiling DUMB manually), and partly because -autotools are plain evil. - -Scroll down for information on the example programs. Refer to docs/howto.txt -when you are ready to start programming with DUMB. If you use DUMB in a game, -let me know - I might decide to place a link to your game on DUMB's website! - - -****************************************************** -*** How to set DUMB up with Microsoft Visual C++ 6 *** -****************************************************** - - -If you have a newer version of Microsoft Visual C++ or Visual Something that -supports C++, please try these instructions and let me know if it works. - -You should have got the .zip version. If for some reason you got the .tar.gz -version instead, you may have to convert some files to DOS text file format. -WinZip does this automatically by default. Otherwise, loading such files into -MS EDIT and saving them again should do the trick. You will have to do this -for any files you want to view in Windows Notepad. If you have problems, just -go and download the .zip instead. - -Make sure you preserved the directory structure when you extracted DUMB from -the archive. Most unzipping programs will do this by default, but pkunzip -requires you to pass -d. If not, please delete DUMB and extract it again -properly. - -DUMB comes with a workspace Microsoft Visual C++ 6, containing projects for -the DUMB core, the Allegro interface library and each of the examples. The -first thing you might want to do is load the workspace up and have a look -around. You will find it in the dumb\vc6 directory under the name dumb.dsw. -Note that the aldumb and dumbplay projects require Allegro, so they won't -work if you don't have Allegro. Nevertheless, dumbplay is the best-commented -of the examples, so do have a look. - -When you are ready to add DUMB to your project, follow these instructions: - -1. Open your project in VC++. -2. Select Project|Insert Project into Workspace... -3. Navigate to the dumb\vc6\dumb directory and select dumb.dsp. - Alternatively, if you know that you are statically linking with a library - that uses the statically linked multithreaded runtime (/MT), you may wish - to select dumb_static.dsp in the dumb_static subdirectory instead. -4. Select Build|Set Active Configuration..., and reselect one of your - project's configurations. -5. Select Project|Dependencies... and ensure your project is dependent on - DUMB. -6. Select Project|Settings..., Settings for: All Configurations, C/C++ tab, - Preprocessor category. Add the DUMB include directory to the Additional - Include Directories box. -7. Ensure that for all the projects in the workspace (or more likely just all - the projects in a particular dependency chain) the run-time libraries are - the same. That's in Project|Settings, C/C++ tab, Code generation category, - Use run-time library dropdown. The settings for Release and Debug are - separate, so you'll have to change them one at a time. Exactly which run- - time library you use will depend on what you need; it doesn't appear that - DUMB has any particular requirements, so set it to whatever you're using - now. (It will have to be /MD, the multithreaded DLL library, if you are - statically linking with Allegro. If you are dynamically linking with - Allegro than it doesn't matter.) -8. If you are using Allegro, do some or all of the above for the aldumb.dsp - project in the aldumb directory too. - -Good thing you only have to do all that once ... or twice ... - -If you have the Intel compiler installed, it will - well, should - be used to -compile DUMB. The only setting I [Tom Seddon] added is /QxiM. This allows the -compiler to use PPro and MMX instructions, and so when compiling with Intel -the resultant EXE will require a Pentium II or greater. I don't think this is -unreasonable. After all, it is 2003 :) - -[Note from Ben: the Intel compiler is evil! It makes AMD processors look bad! -Patch it or boycott it or something!] - -If you don't have the Intel compiler, VC will compile DUMB as normal. - -This project file and these instructions were provided by Tom Seddon (I hope -I got his name right; I had to guess it from his e-mail address!). Chad -Austin has since changed the project files around, and I've just attempted to -hack them to incorporate new source files. I've also tried to update the -instructions using guesswork and some knowledge of Visual J++ (you heard me). -The instructions and the project files are to this day untested by me. If you -have problems, check the download page at http://dumb.sf.net/ to see if they -are addressed; failing that, direct queries to me and I'll try to figure them -out. - -If you have any comments at all on how the VC6 projects are laid out, or how -the instructions could be improved, I should be really grateful to hear them. -I am a perfectionist, after all. :) - -Scroll down for information on the example programs. When you are ready to -start using DUMB, refer to docs/howto.txt. If you use DUMB in a game, let me -know - I might decide to place a link to your game on DUMB's website! - - -****************************************************** -*** How to set DUMB up on Linux, BeOS and Mac OS X *** -****************************************************** - - -You should have got the .tar.gz version. If for some reason you got the .zip -version instead, you may have to strip all characters with ASCII code 13 from -some of the text files. If you have problems, just go and download the -.tar.gz instead. - -You have two options. There is a Makefile which should cope with most -systems. The first option is to use this default Makefile, and the procedure -is explained below. The second option is to download -dumb-0.9.3-autotools.tar.gz, extract it over the installation, run -./configure and use the generated Makefile. Users who choose to do this are -left to their own devices but advised to read the information at the end of -this section. I strongly recommend the first option. - -If you are not using the configure script, the procedure is as follows. - -First, run the following command as a normal user: - - make - -You will be asked whether you want Allegro support. Then, unless you are on -BeOS, you will be asked where you'd like DUMB to install its headers, -libraries and examples (which will go in the include/, lib/ and bin/ -subdirectories of the prefix you specify). BeOS has fixed locations for these -files. You may use shell variables here, e.g. $HOME or ${HOME}, but ~ will -not work. Once you have specified these pieces of information, the optimised -and debugging builds of DUMB will be compiled, along with the examples. When -it has finished, you can install them with: - - make install - -You may need to be root for this to work. It depends on the prefix you chose. - -Note: the Makefile will only work if COMSPEC and ComSpec are both undefined. -If either of these is defined, the Makefile will try to build for a Windows -system, and will fail. - -Please let me know if you have any trouble. - -Scroll down for information on the example programs. Refer to docs/howto.txt -when you are ready to start programming with DUMB. If you use DUMB in a game, -let me know - I might decide to place a link to your game on DUMB's website! - -Important information for users of the configure script follows. - -The Makefile generated by the configure script creates dynamically linked -libraries, and I don't know how to stop it from doing so. See the section -below on building DUMB manually for why I recommend linking DUMB statically. -However, if you choose to use the configure script, note the following. - -The default Makefile is a copy of Makefile.rdy (short for 'ready'), and it -must exist with the name Makefile.rdy in order to work. The configure script -will overwrite Makefile, so if you want the default Makefile back, just run: - - cp Makefile.rdy Makefile - -Do not use a symlink, as that would result in Makefile.rdy getting -overwritten next time the configure script is run! - -You can also access the usual build system by passing '-f Makefile.rdy' to -Make. - - -******************************************************** -*** How to build DUMB manually if nothing else works *** -******************************************************** - - -Those porting to platforms without floating point support should be aware -that DUMB does use floating point operations but not in the inner loops. They -are used for volume and note pitch calculations, and they are used when -initialising the filter algorithm for given cut-off and resonance values. -Please let me know if this is a problem for you. If there is enough demand, I -may be able to eliminate one or both of these cases. - -All of the library source code may be found in the src/ subdirectory. There -are headers in the include/ subdirectory, and src/helpers/resample.c also -#includes some .inc files in its own directory. - -There are four subdirectories under src/. For projects not using Allegro, you -will need all the files in src/core/, src/helpers/ and src/it/. If you are -using Allegro, you will want the src/allegro/ subdirectory too. For -consistency with the other build systems, the contents of src/allegro/ should -be compiled into a separate library. - -I recommend static-linking DUMB, since the version information is done via -macros and the API has a tendency to change. If you static-link, then once -your program is in binary form, you can be sure that changes to the installed -version of DUMB won't cause it to malfuction. It is my fault that the API has -been so unstable. Sorry! - -Compile each .c file separately. As mentioned above, you will need to specify -two places to look for #include files: the include/ directory and the source -file's own directory. You will also need to define the symbol -DUMB_DECLARE_DEPRECATED on the command line. - -Do not compile the .inc files separately. - -You may need to edit dumb.h and add your own definition for LONG_LONG. It -should be a 64-bit integer. If you do this, please see if you can add a check -for your compiler so that it still works with other compilers. - -DUMB has two build modes. If you define the symbol DEBUGMODE, some checks for -programmer error will be incorporated into the library. Otherwise it will be -built without any such checks. (DUMB will however always thoroughly check the -validity of files it is loading. If you ever find a module file that crashes -DUMB, please let me know!) - -I recommend building two versions of the library, one with DEBUGMODE defined -and debugging information included, and the other with compiler optimisation -enabled. If you can install DUMB system-wide so that your projects, and other -people's, can simply #include or and link with libraries -by simple name with no path, then that is ideal. - -If you successfully port DUMB to a new platform, please let me know! - - -**************************** -*** The example programs *** -**************************** - - -Three example programs are provided. On DOS and Windows, you can find them in -the examples subdirectory. On other systems they will be installed system- -wide. - -dumbplay - This program will only be built if you have Allegro. Pass it the filename - of an IT, XM, S3M or MOD file, and it will play it. It's not a polished - player with real-time threading or anything - so don't complain about it - stuttering while you use other programs - but it does show DUMB's fidelity - nicely. You can control the playback quality by editing dumb.ini, which - must be in the current working directory. (This is a flaw for systems - where the program is installed system-wide, but it is non-fatal.) Have a - look at the examples/dumb.ini file for further information. - -dumbout - This program does not need Allegro. You can use it to stream an IT, XM, - S3M or MOD file to raw PCM. This can be used as input to an encoder like - oggenc (with appropriate command-line options), or it can be sent to a - .pcm file which can be read by any respectable waveform editor. This - program is also convenient for timing DUMB. Compare the time it takes to - render a module with the module's playing time! dumbout doesn't try to - read any configuration file; the options are set on the command line. - -dumb2wav - This program is much the same as dumbout, but it writes a .wav file with - the appropriate header. Thanks go to Chad Austin for this useful tool. - - -********************************************* -*** Downloading music or writing your own *** -********************************************* - - -If you would like to compose your own music modules, then this section should -help get you started. - -The best programs for the job are the trackers that pioneered the file -formats: - - Impulse Tracker - IT files - http://www.lim.com.au/ImpulseTracker/ - Fast Tracker II - XM files - http://www.fasttracker2.com/ - Scream Tracker 3 - S3M files - No official site known, please use Google - -MOD files come from the Amiga; I do not know what PC tracker to recommend for -editing these. If you know of one, let me know! In the meantime, I would -recommend using a more advanced file format. However, don't convert your -existing MODs just for the sake of it. - -Fast Tracker II is Shareware. It offers a very flashy interface and has a -game embedded, but the IT file format is more powerful and better defined. By -all means try them both and see which you prefer; it is largely a matter of -taste (and, in some cases, religion). Impulse Tracker and Scream Tracker 3 -are Freeware, although you can donate to Impulse Tracker and receive a -slightly upgraded version. DUMB is likely to be at its best with IT files. - -These editors are DOS programs. Users of DOS-incapable operating systems may -like to try ModPlug Tracker, but should read docs/modplug.txt before using it -for any serious work. If you use a different operating system, or if you know -of any module editors for Windows that are more faithful to the original -trackers' playback, please give me some links so I can put them here! - - ModPlug Tracker - http://www.modplug.com/ - -If you have an x86 Linux system with VGA-compatible hardware (which covers -all PC graphics cards I've ever seen), you should be able to get Impulse -Tracker running with DOSEMU. You will have to give it access to the VGA ports -and run it in a true console, as it will not work with the X-based VGA -emulation. I personally added the SB16 emulation to DOSEMU, so you can even -use filters! However, it corrupts samples alarmingly often when saving on my -system - probably a DOSEMU issue. If you set this up, I am curious to know -whether it works for you. - - DOSEMU - http://www.dosemu.org/ - -BEWARE OF WINAMP! Although it's excellent for MP3s, it is notorious for being -one of the worst module players in existence; very many modules play wrongly -with it. There are plug-ins available to improve Winamp's module support, for -example WSP. - - Winamp - http://www.winamp.com/ - WSP - http://www.spytech.cz/index.php?sec=demo - -(There is a Winamp plug-in that uses DUMB, but it is unreliable. If anyone -would like to work on it, please get in touch.) - -While I am at it I should also point out that Winamp is notorious for -containing security flaws. Install it at your own risk, and if it is your -work computer, check with your boss first! - -Samples and instruments are the building blocks of music modules. You can -download samples at - - http://www.tump.net/ - -If you would like to download module files composed by other people, check -the following sites: - - http://www.modarchive.com/ - http://www.scene.org/ - http://www.tump.net/ - http://www.homemusic.cc/main.php - http://www.modplug.com/ - -Once again, if you know of more sites where samples or module files are -available for download, please let me know. - -If you wish to use someone's music in your game, please respect the -composer's wishes. In general, you should ask the composer. Music that has -been placed in the Public Domain can be used by anyone for anything, but it -wouldn't do any harm to ask anyway if you know who the author is. In many -cases the author will be thrilled, so don't hesitate! - -A note about converting modules from one format to another, or converting -from MIDI: don't do it, unless you are a musician and are prepared to go -through the file and make sure everything sounds the way it should! The -module formats are all slightly different, and MIDI is very different; -converting from one format to another will usually do some damage. - -Instead, it is recommended that you allow DUMB to interpret the original file -as it sees fit. DUMB may make mistakes (it does a lot of conversion on -loading), but future versions of DUMB will be able to rectify these mistakes. -On the other hand, if you convert the file, the damage is permanent. - - -*********************** -*** Contact details *** -*********************** - - -If you have trouble with DUMB, or want to contact me for any other reason, my -e-mail address is given below. Please do get in touch, even if I appear to -have disappeared! - -If you wish to chat online about something, perhaps on IRC, that can most -likely be arranged. Send me an e-mail. - - -****************** -*** Conclusion *** -****************** - - -This is the conclusion. - - -Ben Davis -entheh@users.sf.net diff --git a/Frameworks/Dumb/dumb/src/core/atexit.c b/Frameworks/Dumb/dumb/src/core/atexit.c index 64814efda..5ee625e8a 100644 --- a/Frameworks/Dumb/dumb/src/core/atexit.c +++ b/Frameworks/Dumb/dumb/src/core/atexit.c @@ -22,50 +22,39 @@ #include "dumb.h" #include "internal/dumb.h" - - -typedef struct DUMB_ATEXIT_PROC -{ - struct DUMB_ATEXIT_PROC *next; - void (*proc)(void); -} -DUMB_ATEXIT_PROC; - - +typedef struct DUMB_ATEXIT_PROC { + struct DUMB_ATEXIT_PROC *next; + void (*proc)(void); +} DUMB_ATEXIT_PROC; static DUMB_ATEXIT_PROC *dumb_atexit_proc = NULL; +int dumb_atexit(void (*proc)(void)) { + DUMB_ATEXIT_PROC *dap = dumb_atexit_proc; + while (dap) { + if (dap->proc == proc) + return 0; + dap = dap->next; + } -int dumb_atexit(void (*proc)(void)) -{ - DUMB_ATEXIT_PROC *dap = dumb_atexit_proc; + dap = malloc(sizeof(*dap)); - while (dap) { - if (dap->proc == proc) return 0; - dap = dap->next; - } + if (!dap) + return -1; - dap = malloc(sizeof(*dap)); + dap->next = dumb_atexit_proc; + dap->proc = proc; + dumb_atexit_proc = dap; - if (!dap) - return -1; - - dap->next = dumb_atexit_proc; - dap->proc = proc; - dumb_atexit_proc = dap; - - return 0; + return 0; } - - -void dumb_exit(void) -{ - while (dumb_atexit_proc) { - DUMB_ATEXIT_PROC *next = dumb_atexit_proc->next; - (*dumb_atexit_proc->proc)(); - free(dumb_atexit_proc); - dumb_atexit_proc = next; - } +void dumb_exit(void) { + while (dumb_atexit_proc) { + DUMB_ATEXIT_PROC *next = dumb_atexit_proc->next; + (*dumb_atexit_proc->proc)(); + free(dumb_atexit_proc); + dumb_atexit_proc = next; + } } diff --git a/Frameworks/Dumb/dumb/src/core/duhlen.c b/Frameworks/Dumb/dumb/src/core/duhlen.c index 2c3a35767..6929cc2a1 100644 --- a/Frameworks/Dumb/dumb/src/core/duhlen.c +++ b/Frameworks/Dumb/dumb/src/core/duhlen.c @@ -26,17 +26,9 @@ #include "dumb.h" #include "internal/dumb.h" +dumb_off_t duh_get_length(DUH *duh) { return duh ? duh->length : 0; } - -long duh_get_length(DUH *duh) -{ - return duh ? duh->length : 0; -} - - - -void duh_set_length(DUH *duh, long length) -{ - if (duh) - duh->length = length; +void duh_set_length(DUH *duh, dumb_off_t length) { + if (duh) + duh->length = length; } diff --git a/Frameworks/Dumb/dumb/src/core/duhtag.c b/Frameworks/Dumb/dumb/src/core/duhtag.c index 3dd02c2ca..bf0492b5e 100644 --- a/Frameworks/Dumb/dumb/src/core/duhtag.c +++ b/Frameworks/Dumb/dumb/src/core/duhtag.c @@ -22,37 +22,32 @@ #include "dumb.h" #include "internal/dumb.h" +const char *duh_get_tag(DUH *duh, const char *key) { + int i; + ASSERT(key); + if (!duh || !duh->tag) + return NULL; + for (i = 0; i < duh->n_tags; i++) + if (strcmp(key, duh->tag[i][0]) == 0) + return duh->tag[i][1]; -const char *duh_get_tag(DUH *duh, const char *key) -{ - int i; - ASSERT(key); - if (!duh || !duh->tag) return NULL; - - for (i = 0; i < duh->n_tags; i++) - if (strcmp(key, duh->tag[i][0]) == 0) - return duh->tag[i][1]; - - return NULL; + return NULL; } - - -int duh_get_tag_iterator_size(DUH *duh) -{ - return (duh && duh->tag ? duh->n_tags : 0); +int duh_get_tag_iterator_size(DUH *duh) { + return (duh && duh->tag ? duh->n_tags : 0); } +int duh_get_tag_iterator_get(DUH *duh, const char **key, const char **tag, + int i) { + ASSERT(key); + ASSERT(tag); + if (!duh || !duh->tag || i >= duh->n_tags) + return -1; -int duh_get_tag_iterator_get(DUH *duh, const char **key, const char **tag, int i) -{ - ASSERT(key); - ASSERT(tag); - if (!duh || !duh->tag || i >= duh->n_tags) return -1; + *key = duh->tag[i][0]; + *tag = duh->tag[i][1]; - *key = duh->tag[i][0]; - *tag = duh->tag[i][1]; - - return 0; + return 0; } diff --git a/Frameworks/Dumb/dumb/src/core/dumbfile.c b/Frameworks/Dumb/dumb/src/core/dumbfile.c index ebcb601ce..00223f993 100644 --- a/Frameworks/Dumb/dumb/src/core/dumbfile.c +++ b/Frameworks/Dumb/dumb/src/core/dumbfile.c @@ -22,398 +22,352 @@ #include "dumb.h" #include "internal/dumb.h" - - static const DUMBFILE_SYSTEM *the_dfs = NULL; - - -void register_dumbfile_system(const DUMBFILE_SYSTEM *dfs) -{ - ASSERT(dfs); - ASSERT(dfs->open); - ASSERT(dfs->getc); - ASSERT(dfs->close); +void register_dumbfile_system(const DUMBFILE_SYSTEM *dfs) { + ASSERT(dfs); + ASSERT(dfs->open); + ASSERT(dfs->getc); + ASSERT(dfs->close); ASSERT(dfs->seek); ASSERT(dfs->get_size); - the_dfs = dfs; + the_dfs = dfs; } - - #include "internal/dumbfile.h" +DUMBFILE *dumbfile_open(const char *filename) { + DUMBFILE *f; + ASSERT(the_dfs); -DUMBFILE *dumbfile_open(const char *filename) -{ - DUMBFILE *f; + f = (DUMBFILE *)malloc(sizeof(*f)); - ASSERT(the_dfs); + if (!f) + return NULL; - f = (DUMBFILE *) malloc(sizeof(*f)); + f->dfs = the_dfs; - if (!f) - return NULL; + f->file = (*the_dfs->open)(filename); - f->dfs = the_dfs; + if (!f->file) { + free(f); + return NULL; + } - f->file = (*the_dfs->open)(filename); + f->pos = 0; - if (!f->file) { - free(f); - return NULL; - } - - f->pos = 0; - - return f; + return f; } +DUMBFILE *dumbfile_open_ex(void *file, const DUMBFILE_SYSTEM *dfs) { + DUMBFILE *f; + ASSERT(dfs); + ASSERT(dfs->getc); + ASSERT(file); -DUMBFILE *dumbfile_open_ex(void *file, const DUMBFILE_SYSTEM *dfs) -{ - DUMBFILE *f; + f = (DUMBFILE *)malloc(sizeof(*f)); - ASSERT(dfs); - ASSERT(dfs->getc); - ASSERT(file); + if (!f) { + if (dfs->close) + (*dfs->close)(file); + return NULL; + } - f = (DUMBFILE *) malloc(sizeof(*f)); + f->dfs = dfs; + f->file = file; - if (!f) { - if (dfs->close) - (*dfs->close)(file); - return NULL; - } + f->pos = 0; - f->dfs = dfs; - f->file = file; - - f->pos = 0; - - return f; + return f; } +dumb_off_t dumbfile_pos(DUMBFILE *f) { + ASSERT(f); - -long dumbfile_pos(DUMBFILE *f) -{ - ASSERT(f); - - return f->pos; + return f->pos; } +/* Move forward in the file from the current position by n bytes. */ +int dumbfile_skip(DUMBFILE *f, dumb_off_t n) { + int rv; + ASSERT(f); + ASSERT(n >= 0); -int dumbfile_skip(DUMBFILE *f, long n) -{ - int rv; + if (f->pos < 0) + return -1; - ASSERT(f); - ASSERT(n >= 0); + f->pos += n; - if (f->pos < 0) - return -1; + if (f->dfs->skip) { + rv = (*f->dfs->skip)(f->file, n); + if (rv) { + f->pos = -1; + return rv; + } + } else { + while (n) { + rv = (*f->dfs->getc)(f->file); + if (rv < 0) { + f->pos = -1; + return rv; + } + n--; + } + } - f->pos += n; - - if (f->dfs->skip) { - rv = (*f->dfs->skip)(f->file, n); - if (rv) { - f->pos = -1; - return rv; - } - } else { - while (n) { - rv = (*f->dfs->getc)(f->file); - if (rv < 0) { - f->pos = -1; - return rv; - } - n--; - } - } - - return 0; + return 0; } +int dumbfile_getc(DUMBFILE *f) { + int rv; + ASSERT(f); -int dumbfile_getc(DUMBFILE *f) -{ - int rv; + if (f->pos < 0) + return -1; - ASSERT(f); + rv = (*f->dfs->getc)(f->file); - if (f->pos < 0) - return -1; + if (rv < 0) { + f->pos = -1; + return rv; + } - rv = (*f->dfs->getc)(f->file); + f->pos++; - if (rv < 0) { - f->pos = -1; - return rv; - } - - f->pos++; - - return rv; + return rv; } +int dumbfile_igetw(DUMBFILE *f) { + int l, h; + ASSERT(f); -int dumbfile_igetw(DUMBFILE *f) -{ - int l, h; + if (f->pos < 0) + return -1; - ASSERT(f); + l = (*f->dfs->getc)(f->file); + if (l < 0) { + f->pos = -1; + return l; + } - if (f->pos < 0) - return -1; + h = (*f->dfs->getc)(f->file); + if (h < 0) { + f->pos = -1; + return h; + } - l = (*f->dfs->getc)(f->file); - if (l < 0) { - f->pos = -1; - return l; - } + f->pos += 2; - h = (*f->dfs->getc)(f->file); - if (h < 0) { - f->pos = -1; - return h; - } - - f->pos += 2; - - return l | (h << 8); + return l | (h << 8); } +int dumbfile_mgetw(DUMBFILE *f) { + int l, h; + ASSERT(f); -int dumbfile_mgetw(DUMBFILE *f) -{ - int l, h; + if (f->pos < 0) + return -1; - ASSERT(f); + h = (*f->dfs->getc)(f->file); + if (h < 0) { + f->pos = -1; + return h; + } - if (f->pos < 0) - return -1; + l = (*f->dfs->getc)(f->file); + if (l < 0) { + f->pos = -1; + return l; + } - h = (*f->dfs->getc)(f->file); - if (h < 0) { - f->pos = -1; - return h; - } + f->pos += 2; - l = (*f->dfs->getc)(f->file); - if (l < 0) { - f->pos = -1; - return l; - } - - f->pos += 2; - - return l | (h << 8); + return l | (h << 8); } +long dumbfile_igetl(DUMBFILE *f) { + unsigned long rv, b; + ASSERT(f); -long dumbfile_igetl(DUMBFILE *f) -{ - unsigned long rv, b; + if (f->pos < 0) + return -1; - ASSERT(f); + rv = (*f->dfs->getc)(f->file); + if ((signed long)rv < 0) { + f->pos = -1; + return rv; + } - if (f->pos < 0) - return -1; + b = (*f->dfs->getc)(f->file); + if ((signed long)b < 0) { + f->pos = -1; + return b; + } + rv |= b << 8; - rv = (*f->dfs->getc)(f->file); - if ((signed long)rv < 0) { - f->pos = -1; - return rv; - } + b = (*f->dfs->getc)(f->file); + if ((signed long)b < 0) { + f->pos = -1; + return b; + } + rv |= b << 16; - b = (*f->dfs->getc)(f->file); - if ((signed long)b < 0) { - f->pos = -1; - return b; - } - rv |= b << 8; + b = (*f->dfs->getc)(f->file); + if ((signed long)b < 0) { + f->pos = -1; + return b; + } + rv |= b << 24; - b = (*f->dfs->getc)(f->file); - if ((signed long)b < 0) { - f->pos = -1; - return b; - } - rv |= b << 16; + f->pos += 4; - b = (*f->dfs->getc)(f->file); - if ((signed long)b < 0) { - f->pos = -1; - return b; - } - rv |= b << 24; - - f->pos += 4; - - return rv; + return rv; } +long dumbfile_mgetl(DUMBFILE *f) { + unsigned long rv, b; + ASSERT(f); -long dumbfile_mgetl(DUMBFILE *f) -{ - unsigned long rv, b; + if (f->pos < 0) + return -1; - ASSERT(f); + rv = (*f->dfs->getc)(f->file); + if ((signed long)rv < 0) { + f->pos = -1; + return rv; + } + rv <<= 24; - if (f->pos < 0) - return -1; + b = (*f->dfs->getc)(f->file); + if ((signed long)b < 0) { + f->pos = -1; + return b; + } + rv |= b << 16; - rv = (*f->dfs->getc)(f->file); - if ((signed long)rv < 0) { - f->pos = -1; - return rv; - } - rv <<= 24; + b = (*f->dfs->getc)(f->file); + if ((signed long)b < 0) { + f->pos = -1; + return b; + } + rv |= b << 8; - b = (*f->dfs->getc)(f->file); - if ((signed long)b < 0) { - f->pos = -1; - return b; - } - rv |= b << 16; + b = (*f->dfs->getc)(f->file); + if ((signed long)b < 0) { + f->pos = -1; + return b; + } + rv |= b; - b = (*f->dfs->getc)(f->file); - if ((signed long)b < 0) { - f->pos = -1; - return b; - } - rv |= b << 8; + f->pos += 4; - b = (*f->dfs->getc)(f->file); - if ((signed long)b < 0) { - f->pos = -1; - return b; - } - rv |= b; - - f->pos += 4; - - return rv; + return rv; } +unsigned long dumbfile_cgetul(DUMBFILE *f) { + unsigned long rv = 0; + int v; + do { + v = dumbfile_getc(f); -unsigned long dumbfile_cgetul(DUMBFILE *f) -{ - unsigned long rv = 0; - int v; + if (v < 0) + return v; - do { - v = dumbfile_getc(f); + rv <<= 7; + rv |= v & 0x7F; + } while (v & 0x80); - if (v < 0) - return v; - - rv <<= 7; - rv |= v & 0x7F; - } while (v & 0x80); - - return rv; + return rv; } +signed long dumbfile_cgetsl(DUMBFILE *f) { + unsigned long rv = dumbfile_cgetul(f); + if (f->pos < 0) + return rv; -signed long dumbfile_cgetsl(DUMBFILE *f) -{ - unsigned long rv = dumbfile_cgetul(f); - - if (f->pos < 0) - return rv; - - return (rv >> 1) | (rv << 31); + return (rv >> 1) | (rv << 31); } +dumb_ssize_t dumbfile_getnc(char *ptr, size_t n, DUMBFILE *f) { + dumb_ssize_t rv; + ASSERT(f); + ASSERT(n >= 0); -long dumbfile_getnc(char *ptr, long n, DUMBFILE *f) -{ - long rv; + if (f->pos < 0) + return -1; - ASSERT(f); - ASSERT(n >= 0); + if (f->dfs->getnc) { + rv = (*f->dfs->getnc)(ptr, n, f->file); + if (rv < (dumb_ssize_t)n) { + f->pos = -1; + return MAX(rv, 0); + } + } else { + for (rv = 0; rv < (dumb_ssize_t)n; rv++) { + int c = (*f->dfs->getc)(f->file); + if (c < 0) { + f->pos = -1; + return rv; + } + *ptr++ = c; + } + } - if (f->pos < 0) - return -1; + f->pos += rv; - if (f->dfs->getnc) { - rv = (*f->dfs->getnc)(ptr, n, f->file); - if (rv < n) { - f->pos = -1; - return MAX(rv, 0); - } - } else { - for (rv = 0; rv < n; rv++) { - int c = (*f->dfs->getc)(f->file); - if (c < 0) { - f->pos = -1; - return rv; - } - *ptr++ = c; - } - } - - f->pos += rv; - - return rv; + return rv; } - - -int dumbfile_seek(DUMBFILE *f, long n, int origin) -{ - switch ( origin ) - { - case DFS_SEEK_CUR: n += f->pos; break; - case DFS_SEEK_END: n += (*f->dfs->get_size)(f->file); break; +/* Move to an arbitrary position n in the file, specified relative to origin, + * where origin shall be one of the DFS_SEEK_* constants. + */ +int dumbfile_seek(DUMBFILE *f, dumb_off_t n, int origin) { + switch (origin) { + case DFS_SEEK_CUR: + n += f->pos; + break; + case DFS_SEEK_END: + n += (*f->dfs->get_size)(f->file); + break; + default: + break; /* keep n, seek position from beginning of file */ } f->pos = n; return (*f->dfs->seek)(f->file, n); } - - -long dumbfile_get_size(DUMBFILE *f) -{ +dumb_off_t dumbfile_get_size(DUMBFILE *f) { return (*f->dfs->get_size)(f->file); } +int dumbfile_error(DUMBFILE *f) { + ASSERT(f); - -int dumbfile_error(DUMBFILE *f) -{ - ASSERT(f); - - return f->pos < 0; + return f->pos < 0; } +int dumbfile_close(DUMBFILE *f) { + int rv; + ASSERT(f); -int dumbfile_close(DUMBFILE *f) -{ - int rv; + rv = f->pos < 0; - ASSERT(f); + if (f->dfs->close) + (*f->dfs->close)(f->file); - rv = f->pos < 0; + free(f); - if (f->dfs->close) - (*f->dfs->close)(f->file); - - free(f); - - return rv; + return rv; } diff --git a/Frameworks/Dumb/dumb/src/core/loadduh.c b/Frameworks/Dumb/dumb/src/core/loadduh.c index e954fe24c..d87d557d9 100644 --- a/Frameworks/Dumb/dumb/src/core/loadduh.c +++ b/Frameworks/Dumb/dumb/src/core/loadduh.c @@ -20,23 +20,20 @@ #include "dumb.h" #include "internal/dumb.h" - - /* load_duh(): loads a .duh file, returning a pointer to a DUH struct. * When you have finished with it, you must pass the pointer to unload_duh() * so that the memory can be freed. */ -DUH *load_duh(const char *filename) -{ - DUH *duh; - DUMBFILE *f = dumbfile_open(filename); +DUH *load_duh(const char *filename) { + DUH *duh; + DUMBFILE *f = dumbfile_open(filename); - if (!f) - return NULL; + if (!f) + return NULL; - duh = read_duh(f); + duh = read_duh(f); - dumbfile_close(f); + dumbfile_close(f); - return duh; + return duh; } diff --git a/Frameworks/Dumb/dumb/src/core/makeduh.c b/Frameworks/Dumb/dumb/src/core/makeduh.c index 345e2d65b..467896e50 100644 --- a/Frameworks/Dumb/dumb/src/core/makeduh.c +++ b/Frameworks/Dumb/dumb/src/core/makeduh.c @@ -23,129 +23,124 @@ #include "dumb.h" #include "internal/dumb.h" +static DUH_SIGNAL *make_signal(DUH_SIGTYPE_DESC *desc, sigdata_t *sigdata) { + DUH_SIGNAL *signal; + ASSERT((desc->start_sigrenderer && desc->end_sigrenderer) || + (!desc->start_sigrenderer && !desc->end_sigrenderer)); + ASSERT(desc->sigrenderer_generate_samples && + desc->sigrenderer_get_current_sample); -static DUH_SIGNAL *make_signal(DUH_SIGTYPE_DESC *desc, sigdata_t *sigdata) -{ - DUH_SIGNAL *signal; + signal = malloc(sizeof(*signal)); - ASSERT((desc->start_sigrenderer && desc->end_sigrenderer) || (!desc->start_sigrenderer && !desc->end_sigrenderer)); - ASSERT(desc->sigrenderer_generate_samples && desc->sigrenderer_get_current_sample); + if (!signal) { + if (desc->unload_sigdata) + if (sigdata) + (*desc->unload_sigdata)(sigdata); + return NULL; + } - signal = malloc(sizeof(*signal)); + signal->desc = desc; + signal->sigdata = sigdata; - if (!signal) { - if (desc->unload_sigdata) - if (sigdata) - (*desc->unload_sigdata)(sigdata); - return NULL; - } - - signal->desc = desc; - signal->sigdata = sigdata; - - return signal; + return signal; } +DUH *make_duh(dumb_off_t length, int n_tags, const char *const tags[][2], + int n_signals, DUH_SIGTYPE_DESC *desc[], sigdata_t *sigdata[]) { + DUH *duh = malloc(sizeof(*duh)); + int i; + int fail; + if (duh) { + duh->n_signals = n_signals; -DUH *make_duh( - long length, - int n_tags, - const char *const tags[][2], - int n_signals, - DUH_SIGTYPE_DESC *desc[], - sigdata_t *sigdata[] -) -{ - DUH *duh = malloc(sizeof(*duh)); - int i; - int fail; + duh->signal = malloc(n_signals * sizeof(*duh->signal)); - if (duh) { - duh->n_signals = n_signals; + if (!duh->signal) { + free(duh); + duh = NULL; + } + } - duh->signal = malloc(n_signals * sizeof(*duh->signal)); + if (!duh) { + for (i = 0; i < n_signals; i++) + if (desc[i]->unload_sigdata) + if (sigdata[i]) + (*desc[i]->unload_sigdata)(sigdata[i]); + return NULL; + } - if (!duh->signal) { - free(duh); - duh = NULL; - } - } + duh->n_tags = 0; + duh->tag = NULL; - if (!duh) { - for (i = 0; i < n_signals; i++) - if (desc[i]->unload_sigdata) - if (sigdata[i]) - (*desc[i]->unload_sigdata)(sigdata[i]); - return NULL; - } + fail = 0; - duh->n_tags = 0; - duh->tag = NULL; + for (i = 0; i < n_signals; i++) { + duh->signal[i] = make_signal(desc[i], sigdata[i]); + if (!duh->signal[i]) + fail = 1; + } - fail = 0; + if (fail) { + unload_duh(duh); + return NULL; + } - for (i = 0; i < n_signals; i++) { - duh->signal[i] = make_signal(desc[i], sigdata[i]); - if (!duh->signal[i]) - fail = 1; - } + duh->length = length; - if (fail) { - unload_duh(duh); - return NULL; - } + { + int mem = n_tags * 2; /* account for NUL terminators here */ + char *ptr; - duh->length = length; + for (i = 0; i < n_tags; i++) + mem += strlen(tags[i][0]) + strlen(tags[i][1]); - { - int mem = n_tags * 2; /* account for NUL terminators here */ - char *ptr; + if (mem <= 0) + return duh; - for (i = 0; i < n_tags; i++) - mem += strlen(tags[i][0]) + strlen(tags[i][1]); + duh->tag = malloc(n_tags * sizeof(*duh->tag)); + if (!duh->tag) + return duh; + duh->tag[0][0] = malloc(mem); + if (!duh->tag[0][0]) { + free(duh->tag); + duh->tag = NULL; + return duh; + } + duh->n_tags = n_tags; + ptr = duh->tag[0][0]; + for (i = 0; i < n_tags; i++) { + duh->tag[i][0] = ptr; + strcpy(ptr, tags[i][0]); + ptr += strlen(tags[i][0]) + 1; + duh->tag[i][1] = ptr; + strcpy(ptr, tags[i][1]); + ptr += strlen(tags[i][1]) + 1; + } + } - if (mem <= 0) return duh; - - duh->tag = malloc(n_tags * sizeof(*duh->tag)); - if (!duh->tag) return duh; - duh->tag[0][0] = malloc(mem); - if (!duh->tag[0][0]) { - free(duh->tag); - duh->tag = NULL; - return duh; - } - duh->n_tags = n_tags; - ptr = duh->tag[0][0]; - for (i = 0; i < n_tags; i++) { - duh->tag[i][0] = ptr; - strcpy(ptr, tags[i][0]); - ptr += strlen(tags[i][0]) + 1; - duh->tag[i][1] = ptr; - strcpy(ptr, tags[i][1]); - ptr += strlen(tags[i][1]) + 1; - } - } - - return duh; + return duh; } -int duh_add_signal(DUH *duh, DUH_SIGTYPE_DESC *desc, sigdata_t *sigdata) -{ - DUH_SIGNAL **signal; +int duh_add_signal(DUH *duh, DUH_SIGTYPE_DESC *desc, sigdata_t *sigdata) { + DUH_SIGNAL **signal; - if ( !duh || !desc || !sigdata ) return -1; + if (!duh || !desc || !sigdata) + return -1; - signal = ( DUH_SIGNAL ** ) realloc( duh->signal, ( duh->n_signals + 1 ) * sizeof( *duh->signal ) ); - if ( !signal ) return -1; - duh->signal = signal; + signal = (DUH_SIGNAL **)realloc(duh->signal, (duh->n_signals + 1) * + sizeof(*duh->signal)); + if (!signal) + return -1; + duh->signal = signal; - memmove( signal + 1, signal, duh->n_signals * sizeof( *signal ) ); - duh->n_signals++; + memmove(signal + 1, signal, duh->n_signals * sizeof(*signal)); + duh->n_signals++; - signal[ 0 ] = make_signal( desc, sigdata ); - if ( !signal[ 0 ] ) return -1; + signal[0] = make_signal(desc, sigdata); + if (!signal[0]) + return -1; - return 0; + return 0; } diff --git a/Frameworks/Dumb/dumb/src/core/rawsig.c b/Frameworks/Dumb/dumb/src/core/rawsig.c index 8a750a67e..d9dc42da7 100644 --- a/Frameworks/Dumb/dumb/src/core/rawsig.c +++ b/Frameworks/Dumb/dumb/src/core/rawsig.c @@ -22,37 +22,32 @@ #include "dumb.h" #include "internal/dumb.h" - - /* You have to specify the type of sigdata, proving you know what to do with * the pointer. If you get it wrong, you can expect NULL back. */ -sigdata_t *duh_get_raw_sigdata(DUH *duh, int sig, long type) -{ - int i; - DUH_SIGNAL *signal; +sigdata_t *duh_get_raw_sigdata(DUH *duh, int sig, long type) { + int i; + DUH_SIGNAL *signal; - if (!duh) return NULL; + if (!duh) + return NULL; - if ( sig >= 0 ) - { - if ((unsigned int)sig >= (unsigned int)duh->n_signals) return NULL; + if (sig >= 0) { + if ((unsigned int)sig >= (unsigned int)duh->n_signals) + return NULL; - signal = duh->signal[sig]; + signal = duh->signal[sig]; - if (signal && signal->desc->type == type) - return signal->sigdata; - } - else - { - for ( i = 0; i < duh->n_signals; i++ ) - { - signal = duh->signal[i]; + if (signal && signal->desc->type == type) + return signal->sigdata; + } else { + for (i = 0; i < duh->n_signals; i++) { + signal = duh->signal[i]; - if (signal && signal->desc->type == type) - return signal->sigdata; - } - } + if (signal && signal->desc->type == type) + return signal->sigdata; + } + } - return NULL; + return NULL; } diff --git a/Frameworks/Dumb/dumb/src/core/readduh.c b/Frameworks/Dumb/dumb/src/core/readduh.c index 0fb775b2b..23f04e508 100644 --- a/Frameworks/Dumb/dumb/src/core/readduh.c +++ b/Frameworks/Dumb/dumb/src/core/readduh.c @@ -22,86 +22,80 @@ #include "dumb.h" #include "internal/dumb.h" +static DUH_SIGNAL *read_signal(DUH *duh, DUMBFILE *f) { + DUH_SIGNAL *signal; + long type; + signal = malloc(sizeof(*signal)); -static DUH_SIGNAL *read_signal(DUH *duh, DUMBFILE *f) -{ - DUH_SIGNAL *signal; - long type; + if (!signal) + return NULL; - signal = malloc(sizeof(*signal)); + type = dumbfile_mgetl(f); + if (dumbfile_error(f)) { + free(signal); + return NULL; + } - if (!signal) - return NULL; + signal->desc = _dumb_get_sigtype_desc(type); + if (!signal->desc) { + free(signal); + return NULL; + } - type = dumbfile_mgetl(f); - if (dumbfile_error(f)) { - free(signal); - return NULL; - } + if (signal->desc->load_sigdata) { + signal->sigdata = (*signal->desc->load_sigdata)(duh, f); + if (!signal->sigdata) { + free(signal); + return NULL; + } + } else + signal->sigdata = NULL; - signal->desc = _dumb_get_sigtype_desc(type); - if (!signal->desc) { - free(signal); - return NULL; - } - - if (signal->desc->load_sigdata) { - signal->sigdata = (*signal->desc->load_sigdata)(duh, f); - if (!signal->sigdata) { - free(signal); - return NULL; - } - } else - signal->sigdata = NULL; - - return signal; + return signal; } - - /* read_duh(): reads a DUH from an already open DUMBFILE, and returns its * pointer, or null on error. The file is not closed. */ -DUH *read_duh(DUMBFILE *f) -{ - DUH *duh; - int i; +DUH *read_duh(DUMBFILE *f) { + DUH *duh; + int i; - if (dumbfile_mgetl(f) != DUH_SIGNATURE) - return NULL; + if (dumbfile_mgetl(f) != DUH_SIGNATURE) + return NULL; - duh = malloc(sizeof(*duh)); - if (!duh) - return NULL; + duh = malloc(sizeof(*duh)); + if (!duh) + return NULL; - duh->length = dumbfile_igetl(f); - if (dumbfile_error(f) || duh->length <= 0) { - free(duh); - return NULL; - } + duh->length = dumbfile_igetl(f); + if (dumbfile_error(f) || duh->length <= 0) { + free(duh); + return NULL; + } - duh->n_signals = dumbfile_igetl(f); - if (dumbfile_error(f) || duh->n_signals <= 0) { - free(duh); - return NULL; - } + duh->n_signals = (int)dumbfile_igetl(f); + if (dumbfile_error(f) || duh->n_signals <= 0) { + free(duh); + return NULL; + } - duh->signal = malloc(sizeof(*duh->signal) * duh->n_signals); - if (!duh->signal) { - free(duh); - return NULL; - } + duh->signal = malloc(sizeof(*duh->signal) * duh->n_signals); + if (!duh->signal) { + free(duh); + return NULL; + } - for (i = 0; i < duh->n_signals; i++) - duh->signal[i] = NULL; + for (i = 0; i < duh->n_signals; i++) + duh->signal[i] = NULL; - for (i = 0; i < duh->n_signals; i++) { - if (!(duh->signal[i] = read_signal(duh, f))) { - unload_duh(duh); - return NULL; - } - } + for (i = 0; i < duh->n_signals; i++) { + if (!(duh->signal[i] = read_signal(duh, f))) { + unload_duh(duh); + return NULL; + } + } - return duh; + return duh; } diff --git a/Frameworks/Dumb/dumb/src/core/register.c b/Frameworks/Dumb/dumb/src/core/register.c index 2e16c9a7e..d78549409 100644 --- a/Frameworks/Dumb/dumb/src/core/register.c +++ b/Frameworks/Dumb/dumb/src/core/register.c @@ -22,31 +22,24 @@ #include "dumb.h" #include "internal/dumb.h" - - static DUH_SIGTYPE_DESC_LINK *sigtype_desc = NULL; static DUH_SIGTYPE_DESC_LINK **sigtype_desc_tail = &sigtype_desc; - - /* destroy_sigtypes(): frees all memory allocated while registering signal * types. This function is set up to be called by dumb_exit(). */ -static void destroy_sigtypes(void) -{ - DUH_SIGTYPE_DESC_LINK *desc_link = sigtype_desc, *next; - sigtype_desc = NULL; - sigtype_desc_tail = &sigtype_desc; +static void destroy_sigtypes(void) { + DUH_SIGTYPE_DESC_LINK *desc_link = sigtype_desc, *next; + sigtype_desc = NULL; + sigtype_desc_tail = &sigtype_desc; - while (desc_link) { - next = desc_link->next; - free(desc_link); - desc_link = next; - } + while (desc_link) { + next = desc_link->next; + free(desc_link); + desc_link = next; + } } - - /* dumb_register_sigtype(): registers a new signal type with DUMB. The signal * type is identified by a four-character string (e.g. "WAVE"), which you can * encode using the the DUMB_ID() macro (e.g. DUMB_ID('W','A','V','E')). The @@ -56,49 +49,48 @@ static void destroy_sigtypes(void) * If a DUH tries to use a signal that has not been registered using this * function, then the library will fail to load the DUH. */ -void dumb_register_sigtype(DUH_SIGTYPE_DESC *desc) -{ - DUH_SIGTYPE_DESC_LINK *desc_link = sigtype_desc; +void dumb_register_sigtype(DUH_SIGTYPE_DESC *desc) { + DUH_SIGTYPE_DESC_LINK *desc_link = sigtype_desc; - ASSERT((desc->load_sigdata && desc->unload_sigdata) || (!desc->load_sigdata && !desc->unload_sigdata)); - ASSERT((desc->start_sigrenderer && desc->end_sigrenderer) || (!desc->start_sigrenderer && !desc->end_sigrenderer)); - ASSERT(desc->sigrenderer_generate_samples && desc->sigrenderer_get_current_sample); + ASSERT((desc->load_sigdata && desc->unload_sigdata) || + (!desc->load_sigdata && !desc->unload_sigdata)); + ASSERT((desc->start_sigrenderer && desc->end_sigrenderer) || + (!desc->start_sigrenderer && !desc->end_sigrenderer)); + ASSERT(desc->sigrenderer_generate_samples && + desc->sigrenderer_get_current_sample); - if (desc_link) { - do { - if (desc_link->desc->type == desc->type) { - desc_link->desc = desc; - return; - } - desc_link = desc_link->next; - } while (desc_link); - } else - dumb_atexit(&destroy_sigtypes); + if (desc_link) { + do { + if (desc_link->desc->type == desc->type) { + desc_link->desc = desc; + return; + } + desc_link = desc_link->next; + } while (desc_link); + } else + dumb_atexit(&destroy_sigtypes); - desc_link = *sigtype_desc_tail = malloc(sizeof(DUH_SIGTYPE_DESC_LINK)); + desc_link = *sigtype_desc_tail = malloc(sizeof(DUH_SIGTYPE_DESC_LINK)); - if (!desc_link) - return; + if (!desc_link) + return; - desc_link->next = NULL; - sigtype_desc_tail = &desc_link->next; + desc_link->next = NULL; + sigtype_desc_tail = &desc_link->next; - desc_link->desc = desc; + desc_link->desc = desc; } - - /* _dumb_get_sigtype_desc(): searches the registered functions for a signal * type matching the parameter. If such a sigtype is found, it returns a * pointer to a sigtype descriptor containing the necessary functions to * manage the signal. If none is found, it returns NULL. */ -DUH_SIGTYPE_DESC *_dumb_get_sigtype_desc(long type) -{ - DUH_SIGTYPE_DESC_LINK *desc_link = sigtype_desc; +DUH_SIGTYPE_DESC *_dumb_get_sigtype_desc(long type) { + DUH_SIGTYPE_DESC_LINK *desc_link = sigtype_desc; - while (desc_link && desc_link->desc->type != type) - desc_link = desc_link->next; + while (desc_link && desc_link->desc->type != type) + desc_link = desc_link->next; - return desc_link ? desc_link->desc : NULL; + return desc_link ? desc_link->desc : NULL; } diff --git a/Frameworks/Dumb/dumb/src/core/rendduh.c b/Frameworks/Dumb/dumb/src/core/rendduh.c index 2077c089a..e24eac836 100644 --- a/Frameworks/Dumb/dumb/src/core/rendduh.c +++ b/Frameworks/Dumb/dumb/src/core/rendduh.c @@ -23,309 +23,239 @@ #include "dumb.h" #include "internal/dumb.h" - - /* On the x86, we can use some tricks to speed stuff up */ #if (defined _MSC_VER) || (defined __DJGPP__) || (defined __MINGW__) // Can't we detect Linux and other x86 platforms here? :/ -#define FAST_MID(var, min, max) { \ - var -= (min); \ - var &= (~var) >> (sizeof(var) * CHAR_BIT - 1); \ - var += (min); \ - var -= (max); \ - var &= var >> (sizeof(var) * CHAR_BIT - 1); \ - var += (max); \ -} +#define FAST_MID(var, min, max) \ + { \ + var -= (min); \ + var &= (~var) >> (sizeof(var) * CHAR_BIT - 1); \ + var += (min); \ + var -= (max); \ + var &= var >> (sizeof(var) * CHAR_BIT - 1); \ + var += (max); \ + } -#define CONVERT8(src, pos, signconv) { \ - signed int f = (src + 0x8000) >> 16; \ - FAST_MID(f, -128, 127); \ - ((char*)sptr)[pos] = (char)f ^ signconv; \ -} +#define CONVERT8(src, pos, signconv) \ + { \ + signed int f = (src + 0x8000) >> 16; \ + FAST_MID(f, -128, 127); \ + ((char *)sptr)[pos] = (char)f ^ signconv; \ + } -#define CONVERT16(src, pos, signconv) { \ - signed int f = (src + 0x80) >> 8; \ - FAST_MID(f, -32768, 32767); \ - ((short*)sptr)[pos] = (short)(f ^ signconv); \ -} +#define CONVERT16(src, pos, signconv) \ + { \ + signed int f = (src + 0x80) >> 8; \ + FAST_MID(f, -32768, 32767); \ + ((short *)sptr)[pos] = (short)(f ^ signconv); \ + } #else -#define CONVERT8(src, pos, signconv) \ -{ \ - signed int f = (src + 0x8000) >> 16; \ - f = MID(-128, f, 127); \ - ((char *)sptr)[pos] = (char)f ^ signconv; \ -} +#define CONVERT8(src, pos, signconv) \ + { \ + signed int f = (src + 0x8000) >> 16; \ + f = MID(-128, f, 127); \ + ((char *)sptr)[pos] = (char)f ^ signconv; \ + } - - -#define CONVERT16(src, pos, signconv) \ -{ \ - signed int f = (src + 0x80) >> 8; \ - f = MID(-32768, f, 32767); \ - ((short *)sptr)[pos] = (short)(f ^ signconv); \ -} +#define CONVERT16(src, pos, signconv) \ + { \ + signed int f = (src + 0x80) >> 8; \ + f = MID(-32768, f, 32767); \ + ((short *)sptr)[pos] = (short)(f ^ signconv); \ + } #endif -#define CONVERT24(src, pos) { \ - signed int f = src; \ - f = MID(-8388608, f, 8388607); \ - ((unsigned char*)sptr)[pos ] = (f) & 0xFF; \ - ((unsigned char*)sptr)[pos+1] = (f >> 8) & 0xFF; \ - ((unsigned char*)sptr)[pos+2] = (f >> 16) & 0xFF; \ -} +#define CONVERT24(src, pos) \ + { \ + signed int f = src; \ + f = MID(-8388608, f, 8388607); \ + ((unsigned char *)sptr)[pos] = (f)&0xFF; \ + ((unsigned char *)sptr)[pos + 1] = (f >> 8) & 0xFF; \ + ((unsigned char *)sptr)[pos + 2] = (f >> 16) & 0xFF; \ + } -#define CONVERT32F(src, pos) { \ - ((float*)sptr)[pos] = (float)((signed int)src) * (1.0f/(float)(0xffffff/2+1)); \ -} - -#define CONVERT64F(src, pos) { \ - ((double*)sptr)[pos] = (double)((signed int)src) * (1.0/(double)(0xffffff/2+1)); \ -} +#define CONVERT32F(src, pos) \ + { \ + ((float *)sptr)[pos] = \ + (float)((signed int)src) * (1.0f / (float)(0xffffff / 2 + 1)); \ + } +#define CONVERT64F(src, pos) \ + { \ + ((double *)sptr)[pos] = \ + (double)((signed int)src) * (1.0 / (double)(0xffffff / 2 + 1)); \ + } +/* This is the only deprecated function in 2.0.0. */ /* DEPRECATED */ -DUH_SIGRENDERER *duh_start_renderer(DUH *duh, int n_channels, long pos) -{ - return duh_start_sigrenderer(duh, 0, n_channels, pos); +long duh_render(DUH_SIGRENDERER *sigrenderer, int bits, int unsign, + float volume, float delta, long size, void *sptr) { + long n; + + sample_t **sampptr; + + int n_channels; + + ASSERT(bits == 8 || bits == 16); + ASSERT(sptr); + + if (!sigrenderer) + return 0; + + n_channels = duh_sigrenderer_get_n_channels(sigrenderer); + + ASSERT(n_channels > 0); + /* This restriction will be removed when need be. At the moment, tightly + * optimised loops exist for exactly one or two channels. + */ + ASSERT(n_channels <= 2); + + sampptr = allocate_sample_buffer(n_channels, size); + + if (!sampptr) + return 0; + + dumb_silence(sampptr[0], n_channels * size); + + size = duh_sigrenderer_generate_samples(sigrenderer, volume, delta, size, + sampptr); + + if (bits == 16) { + int signconv = unsign ? 0x8000 : 0x0000; + + for (n = 0; n < size * n_channels; n++) { + CONVERT16(sampptr[0][n], n, signconv); + } + } else { + char signconv = unsign ? 0x80 : 0x00; + + for (n = 0; n < size * n_channels; n++) { + CONVERT8(sampptr[0][n], n, signconv); + } + } + + destroy_sample_buffer(sampptr); + + return size; } +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) { + long n; -/* DEPRECATED */ -long duh_render( - DUH_SIGRENDERER *sigrenderer, - int bits, int unsign, - float volume, float delta, - long size, void *sptr -) -{ - long n; + sample_t **sampptr; - sample_t **sampptr; + int n_channels; - int n_channels; + ASSERT(bits == 8 || bits == 16 || bits == 24); + ASSERT(sptr); + ASSERT(sig_samples); + ASSERT(sig_samples_size); - ASSERT(bits == 8 || bits == 16); - ASSERT(sptr); + if (!sigrenderer) + return 0; - if (!sigrenderer) - return 0; + n_channels = duh_sigrenderer_get_n_channels(sigrenderer); - n_channels = duh_sigrenderer_get_n_channels(sigrenderer); + ASSERT(n_channels > 0); + /* This restriction will be removed when need be. At the moment, tightly + * optimised loops exist for exactly one or two channels. + */ + ASSERT(n_channels <= 2); - ASSERT(n_channels > 0); - /* This restriction will be removed when need be. At the moment, tightly - * optimised loops exist for exactly one or two channels. - */ - ASSERT(n_channels <= 2); + if ((*sig_samples == NULL) || (*sig_samples_size != size)) { + destroy_sample_buffer(*sig_samples); + *sig_samples = allocate_sample_buffer(n_channels, size); + *sig_samples_size = size; + } + sampptr = *sig_samples; - sampptr = allocate_sample_buffer(n_channels, size); + if (!sampptr) + return 0; - if (!sampptr) - return 0; + dumb_silence(sampptr[0], n_channels * size); - dumb_silence(sampptr[0], n_channels * size); + size = duh_sigrenderer_generate_samples(sigrenderer, volume, delta, size, + sampptr); - size = duh_sigrenderer_generate_samples(sigrenderer, volume, delta, size, sampptr); + if (bits == 24) { + long i = 0; + ASSERT(unsign == 0); - if (bits == 16) { - int signconv = unsign ? 0x8000 : 0x0000; + for (n = 0; n < size * n_channels; n++, i += 3) { + CONVERT24(sampptr[0][n], i); + } + } else if (bits == 16) { + int signconv = unsign ? 0x8000 : 0x0000; - for (n = 0; n < size * n_channels; n++) { - CONVERT16(sampptr[0][n], n, signconv); - } - } else { - char signconv = unsign ? 0x80 : 0x00; + for (n = 0; n < size * n_channels; n++) { + CONVERT16(sampptr[0][n], n, signconv); + } + } else { + char signconv = unsign ? 0x80 : 0x00; - for (n = 0; n < size * n_channels; n++) { - CONVERT8(sampptr[0][n], n, signconv); - } - } + for (n = 0; n < size * n_channels; n++) { + CONVERT8(sampptr[0][n], n, signconv); + } + } - destroy_sample_buffer(sampptr); - - return size; + return size; } +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) { + long n; -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 -) -{ - long n; + sample_t **sampptr; - sample_t **sampptr; + int n_channels; - int n_channels; + ASSERT(bits == 32 || bits == 64); + ASSERT(sptr); + ASSERT(sig_samples); + ASSERT(sig_samples_size); - ASSERT(bits == 8 || bits == 16 || bits == 24); - ASSERT(sptr); - ASSERT(sig_samples); - ASSERT(sig_samples_size); + if (!sigrenderer) + return 0; - if (!sigrenderer) - return 0; + n_channels = duh_sigrenderer_get_n_channels(sigrenderer); - n_channels = duh_sigrenderer_get_n_channels(sigrenderer); + ASSERT(n_channels > 0); + /* This restriction will be removed when need be. At the moment, tightly + * optimised loops exist for exactly one or two channels. + */ + ASSERT(n_channels <= 2); - ASSERT(n_channels > 0); - /* This restriction will be removed when need be. At the moment, tightly - * optimised loops exist for exactly one or two channels. - */ - ASSERT(n_channels <= 2); + if ((*sig_samples == NULL) || (*sig_samples_size != size)) { + destroy_sample_buffer(*sig_samples); + *sig_samples = allocate_sample_buffer(n_channels, size); + *sig_samples_size = size; + } + sampptr = *sig_samples; - if ((*sig_samples == NULL) || (*sig_samples_size != size)) - { - destroy_sample_buffer(*sig_samples); - *sig_samples = allocate_sample_buffer(n_channels, size); - *sig_samples_size = size; - } - sampptr = *sig_samples; + if (!sampptr) + return 0; - if (!sampptr) - return 0; + dumb_silence(sampptr[0], n_channels * size); - dumb_silence(sampptr[0], n_channels * size); + size = duh_sigrenderer_generate_samples(sigrenderer, volume, delta, size, + sampptr); - size = duh_sigrenderer_generate_samples(sigrenderer, volume, delta, size, sampptr); + if (bits == 64) { + for (n = 0; n < size * n_channels; n++) { + CONVERT64F(sampptr[0][n], n); + } + } else if (bits == 32) { + for (n = 0; n < size * n_channels; n++) { + CONVERT32F(sampptr[0][n], n); + } + } - if (bits == 24) { - long i = 0; - ASSERT(unsign == 0); - - for (n = 0; n < size * n_channels; n++, i += 3) { - CONVERT24(sampptr[0][n], i); - } - } else - if (bits == 16) { - int signconv = unsign ? 0x8000 : 0x0000; - - for (n = 0; n < size * n_channels; n++) { - CONVERT16(sampptr[0][n], n, signconv); - } - } else { - char signconv = unsign ? 0x80 : 0x00; - - for (n = 0; n < size * n_channels; n++) { - CONVERT8(sampptr[0][n], n, signconv); - } - } - - return size; -} - - -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 -) -{ - long n; - - sample_t **sampptr; - - int n_channels; - - ASSERT(bits == 32 || bits == 64); - ASSERT(sptr); - ASSERT(sig_samples); - ASSERT(sig_samples_size); - - if (!sigrenderer) - return 0; - - n_channels = duh_sigrenderer_get_n_channels(sigrenderer); - - ASSERT(n_channels > 0); - /* This restriction will be removed when need be. At the moment, tightly - * optimised loops exist for exactly one or two channels. - */ - ASSERT(n_channels <= 2); - - if ((*sig_samples == NULL) || (*sig_samples_size != size)) - { - destroy_sample_buffer(*sig_samples); - *sig_samples = allocate_sample_buffer(n_channels, size); - *sig_samples_size = size; - } - sampptr = *sig_samples; - - if (!sampptr) - return 0; - - dumb_silence(sampptr[0], n_channels * size); - - size = duh_sigrenderer_generate_samples(sigrenderer, volume, delta, size, sampptr); - - if (bits == 64) { - for (n = 0; n < size * n_channels; n++) { - CONVERT64F(sampptr[0][n], n); - } - } else - if (bits == 32) { - for (n = 0; n < size * n_channels; n++) { - CONVERT32F(sampptr[0][n], n); - } - } - - return size; -} - - -/* DEPRECATED */ -int duh_renderer_get_n_channels(DUH_SIGRENDERER *dr) -{ - return duh_sigrenderer_get_n_channels(dr); -} - - - -/* DEPRECATED */ -long duh_renderer_get_position(DUH_SIGRENDERER *dr) -{ - return duh_sigrenderer_get_position(dr); -} - - - -/* DEPRECATED */ -void duh_end_renderer(DUH_SIGRENDERER *dr) -{ - duh_end_sigrenderer(dr); -} - - - -/* DEPRECATED */ -DUH_SIGRENDERER *duh_renderer_encapsulate_sigrenderer(DUH_SIGRENDERER *sigrenderer) -{ - return sigrenderer; -} - - - -/* DEPRECATED */ -DUH_SIGRENDERER *duh_renderer_get_sigrenderer(DUH_SIGRENDERER *dr) -{ - return dr; -} - - - -/* DEPRECATED */ -DUH_SIGRENDERER *duh_renderer_decompose_to_sigrenderer(DUH_SIGRENDERER *dr) -{ - return dr; + return size; } diff --git a/Frameworks/Dumb/dumb/src/core/rendsig.c b/Frameworks/Dumb/dumb/src/core/rendsig.c index 0111c52a2..189c1ed18 100644 --- a/Frameworks/Dumb/dumb/src/core/rendsig.c +++ b/Frameworks/Dumb/dumb/src/core/rendsig.c @@ -22,304 +22,194 @@ #include "dumb.h" #include "internal/dumb.h" +struct DUH_SIGRENDERER { + DUH_SIGTYPE_DESC *desc; + sigrenderer_t *sigrenderer; -struct DUH_SIGRENDERER -{ - DUH_SIGTYPE_DESC *desc; + int n_channels; - sigrenderer_t *sigrenderer; + long pos; + int subpos; - int n_channels; - - long pos; - int subpos; - - DUH_SIGRENDERER_SAMPLE_ANALYSER_CALLBACK callback; - void *callback_data; + DUH_SIGRENDERER_SAMPLE_ANALYSER_CALLBACK callback; + void *callback_data; }; +DUH_SIGRENDERER *duh_start_sigrenderer(DUH *duh, int sig, int n_channels, + long pos) { + DUH_SIGRENDERER *sigrenderer; + DUH_SIGNAL *signal; + DUH_START_SIGRENDERER proc; -DUH_SIGRENDERER *duh_start_sigrenderer(DUH *duh, int sig, int n_channels, long pos) -{ - DUH_SIGRENDERER *sigrenderer; + if (!duh) + return NULL; - DUH_SIGNAL *signal; - DUH_START_SIGRENDERER proc; + if ((unsigned int)sig >= (unsigned int)duh->n_signals) + return NULL; - if (!duh) - return NULL; + signal = duh->signal[sig]; + if (!signal) + return NULL; - if ((unsigned int)sig >= (unsigned int)duh->n_signals) - return NULL; + sigrenderer = malloc(sizeof(*sigrenderer)); + if (!sigrenderer) + return NULL; - signal = duh->signal[sig]; - if (!signal) - return NULL; + sigrenderer->desc = signal->desc; - sigrenderer = malloc(sizeof(*sigrenderer)); - if (!sigrenderer) - return NULL; + proc = sigrenderer->desc->start_sigrenderer; - sigrenderer->desc = signal->desc; + if (proc) { + duh->signal[sig] = NULL; + sigrenderer->sigrenderer = + (*proc)(duh, signal->sigdata, n_channels, pos); + duh->signal[sig] = signal; - proc = sigrenderer->desc->start_sigrenderer; + if (!sigrenderer->sigrenderer) { + free(sigrenderer); + return NULL; + } + } else + sigrenderer->sigrenderer = NULL; - if (proc) { - duh->signal[sig] = NULL; - sigrenderer->sigrenderer = (*proc)(duh, signal->sigdata, n_channels, pos); - duh->signal[sig] = signal; + sigrenderer->n_channels = n_channels; - if (!sigrenderer->sigrenderer) { - free(sigrenderer); - return NULL; - } - } else - sigrenderer->sigrenderer = NULL; + sigrenderer->pos = pos; + sigrenderer->subpos = 0; - sigrenderer->n_channels = n_channels; + sigrenderer->callback = NULL; - sigrenderer->pos = pos; - sigrenderer->subpos = 0; - - sigrenderer->callback = NULL; - - return sigrenderer; + return sigrenderer; } - - -#include -void duh_sigrenderer_set_callback( - DUH_SIGRENDERER *sigrenderer, - DUH_SIGRENDERER_CALLBACK callback, void *data -) -{ - (void)sigrenderer; - (void)callback; - (void)data; - /*fprintf(stderr, - "Call to deprecated function duh_sigrenderer_set_callback(). The callback\n" - "was not installed. See dumb/docs/deprec.txt for how to fix this.\n");*/ -} - - - -void duh_sigrenderer_set_analyser_callback( - DUH_SIGRENDERER *sigrenderer, - DUH_SIGRENDERER_ANALYSER_CALLBACK callback, void *data -) -{ - (void)sigrenderer; - (void)callback; - (void)data; - fprintf(stderr, - "Call to deprecated function duh_sigrenderer_set_analyser_callback(). The\n" - "callback was not installed. See dumb/docs/deprec.txt for how to fix this.\n"); -} - - - void duh_sigrenderer_set_sample_analyser_callback( - DUH_SIGRENDERER *sigrenderer, - DUH_SIGRENDERER_SAMPLE_ANALYSER_CALLBACK callback, void *data -) -{ - if (sigrenderer) { - sigrenderer->callback = callback; - sigrenderer->callback_data = data; - } + DUH_SIGRENDERER *sigrenderer, + DUH_SIGRENDERER_SAMPLE_ANALYSER_CALLBACK callback, void *data) { + if (sigrenderer) { + sigrenderer->callback = callback; + sigrenderer->callback_data = data; + } } - - -int duh_sigrenderer_get_n_channels(DUH_SIGRENDERER *sigrenderer) -{ - return sigrenderer ? sigrenderer->n_channels : 0; +int duh_sigrenderer_get_n_channels(DUH_SIGRENDERER *sigrenderer) { + return sigrenderer ? sigrenderer->n_channels : 0; } +long duh_sigrenderer_get_position(DUH_SIGRENDERER *sigrenderer) { + DUH_SIGRENDERER_GET_POSITION proc; + if (!sigrenderer) + return -1; -long duh_sigrenderer_get_position(DUH_SIGRENDERER *sigrenderer) -{ - DUH_SIGRENDERER_GET_POSITION proc; - - if (!sigrenderer) return -1; - - proc = sigrenderer->desc->sigrenderer_get_position; - if (proc) - return (*proc)(sigrenderer->sigrenderer); - else - return sigrenderer->pos; + proc = sigrenderer->desc->sigrenderer_get_position; + if (proc) + return (*proc)(sigrenderer->sigrenderer); + else + return sigrenderer->pos; } +void duh_sigrenderer_set_sigparam(DUH_SIGRENDERER *sigrenderer, + unsigned char id, long value) { + DUH_SIGRENDERER_SET_SIGPARAM proc; + if (!sigrenderer) + return; -void duh_sigrenderer_set_sigparam( - DUH_SIGRENDERER *sigrenderer, - unsigned char id, long value -) -{ - DUH_SIGRENDERER_SET_SIGPARAM proc; - - if (!sigrenderer) return; - - proc = sigrenderer->desc->sigrenderer_set_sigparam; - if (proc) - (*proc)(sigrenderer->sigrenderer, id, value); - else - TRACE("Parameter #%d = %ld for signal %c%c%c%c, which does not take parameters.\n", - (int)id, - value, - (int)(sigrenderer->desc->type >> 24), - (int)(sigrenderer->desc->type >> 16), - (int)(sigrenderer->desc->type >> 8), - (int)(sigrenderer->desc->type)); + proc = sigrenderer->desc->sigrenderer_set_sigparam; + if (proc) + (*proc)(sigrenderer->sigrenderer, id, value); + else + TRACE("Parameter #%d = %ld for signal %c%c%c%c, which does not take " + "parameters.\n", + (int)id, value, (int)(sigrenderer->desc->type >> 24), + (int)(sigrenderer->desc->type >> 16), + (int)(sigrenderer->desc->type >> 8), + (int)(sigrenderer->desc->type)); } +long duh_sigrenderer_generate_samples(DUH_SIGRENDERER *sigrenderer, + float volume, float delta, long size, + sample_t **samples) { + long rendered; + LONG_LONG t; + if (!sigrenderer) + return 0; -long duh_sigrenderer_generate_samples( - DUH_SIGRENDERER *sigrenderer, - float volume, float delta, - long size, sample_t **samples -) -{ - long rendered; - LONG_LONG t; + rendered = (*sigrenderer->desc->sigrenderer_generate_samples)( + sigrenderer->sigrenderer, volume, delta, size, samples); - if (!sigrenderer) return 0; + if (rendered) { + if (sigrenderer->callback) + (*sigrenderer->callback)(sigrenderer->callback_data, + (const sample_t *const *)samples, + sigrenderer->n_channels, rendered); - rendered = (*sigrenderer->desc->sigrenderer_generate_samples) - (sigrenderer->sigrenderer, volume, delta, size, samples); + t = sigrenderer->subpos + (LONG_LONG)(delta * 65536.0 + 0.5) * rendered; - if (rendered) { - if (sigrenderer->callback) - (*sigrenderer->callback)(sigrenderer->callback_data, - (const sample_t *const *)samples, sigrenderer->n_channels, rendered); + sigrenderer->pos += (long)(t >> 16); + sigrenderer->subpos = (int)t & 65535; + } - t = sigrenderer->subpos + (LONG_LONG)(delta * 65536.0 + 0.5) * rendered; - - sigrenderer->pos += (long)(t >> 16); - sigrenderer->subpos = (int)t & 65535; - } - - return rendered; + return rendered; } - - -/* DEPRECATED */ -long duh_sigrenderer_get_samples( - DUH_SIGRENDERER *sigrenderer, - float volume, float delta, - long size, sample_t **samples -) -{ - sample_t **s; - long rendered; - long i; - int j; - if (!samples) return duh_sigrenderer_generate_samples(sigrenderer, volume, delta, size, NULL); - s = allocate_sample_buffer(sigrenderer->n_channels, size); - if (!s) return 0; - dumb_silence(s[0], sigrenderer->n_channels * size); - rendered = duh_sigrenderer_generate_samples(sigrenderer, volume, delta, size, s); - for (j = 0; j < sigrenderer->n_channels; j++) - for (i = 0; i < rendered; i++) - samples[j][i] += s[0][i*sigrenderer->n_channels+j]; - destroy_sample_buffer(s); - return rendered; +void duh_sigrenderer_get_current_sample(DUH_SIGRENDERER *sigrenderer, + float volume, sample_t *samples) { + if (sigrenderer) + (*sigrenderer->desc->sigrenderer_get_current_sample)( + sigrenderer->sigrenderer, volume, samples); } +void duh_end_sigrenderer(DUH_SIGRENDERER *sigrenderer) { + if (sigrenderer) { + if (sigrenderer->desc->end_sigrenderer) + if (sigrenderer->sigrenderer) + (*sigrenderer->desc->end_sigrenderer)(sigrenderer->sigrenderer); - -/* DEPRECATED */ -long duh_render_signal( - DUH_SIGRENDERER *sigrenderer, - float volume, float delta, - long size, sample_t **samples -) -{ - sample_t **s; - long rendered; - long i; - int j; - if (!samples) return duh_sigrenderer_generate_samples(sigrenderer, volume, delta, size, NULL); - s = allocate_sample_buffer(sigrenderer->n_channels, size); - if (!s) return 0; - dumb_silence(s[0], sigrenderer->n_channels * size); - rendered = duh_sigrenderer_generate_samples(sigrenderer, volume, delta, size, s); - for (j = 0; j < sigrenderer->n_channels; j++) - for (i = 0; i < rendered; i++) - samples[j][i] += s[0][i*sigrenderer->n_channels+j] >> 8; - destroy_sample_buffer(s); - return rendered; + free(sigrenderer); + } } +DUH_SIGRENDERER *duh_encapsulate_raw_sigrenderer(sigrenderer_t *vsigrenderer, + DUH_SIGTYPE_DESC *desc, + int n_channels, long pos) { + DUH_SIGRENDERER *sigrenderer; + if (desc->start_sigrenderer && !vsigrenderer) + return NULL; -void duh_sigrenderer_get_current_sample(DUH_SIGRENDERER *sigrenderer, float volume, sample_t *samples) -{ - if (sigrenderer) - (*sigrenderer->desc->sigrenderer_get_current_sample)(sigrenderer->sigrenderer, volume, samples); + sigrenderer = malloc(sizeof(*sigrenderer)); + if (!sigrenderer) { + if (desc->end_sigrenderer) + if (vsigrenderer) + (*desc->end_sigrenderer)(vsigrenderer); + return NULL; + } + + sigrenderer->desc = desc; + sigrenderer->sigrenderer = vsigrenderer; + + sigrenderer->n_channels = n_channels; + + sigrenderer->pos = pos; + sigrenderer->subpos = 0; + + sigrenderer->callback = NULL; + + return sigrenderer; } +sigrenderer_t *duh_get_raw_sigrenderer(DUH_SIGRENDERER *sigrenderer, + long type) { + if (sigrenderer && sigrenderer->desc->type == type) + return sigrenderer->sigrenderer; - -void duh_end_sigrenderer(DUH_SIGRENDERER *sigrenderer) -{ - if (sigrenderer) { - if (sigrenderer->desc->end_sigrenderer) - if (sigrenderer->sigrenderer) - (*sigrenderer->desc->end_sigrenderer)(sigrenderer->sigrenderer); - - free(sigrenderer); - } + return NULL; } - - -DUH_SIGRENDERER *duh_encapsulate_raw_sigrenderer(sigrenderer_t *vsigrenderer, DUH_SIGTYPE_DESC *desc, int n_channels, long pos) -{ - DUH_SIGRENDERER *sigrenderer; - - if (desc->start_sigrenderer && !vsigrenderer) return NULL; - - sigrenderer = malloc(sizeof(*sigrenderer)); - if (!sigrenderer) { - if (desc->end_sigrenderer) - if (vsigrenderer) - (*desc->end_sigrenderer)(vsigrenderer); - return NULL; - } - - sigrenderer->desc = desc; - sigrenderer->sigrenderer = vsigrenderer; - - sigrenderer->n_channels = n_channels; - - sigrenderer->pos = pos; - sigrenderer->subpos = 0; - - sigrenderer->callback = NULL; - - return sigrenderer; -} - - - -sigrenderer_t *duh_get_raw_sigrenderer(DUH_SIGRENDERER *sigrenderer, long type) -{ - if (sigrenderer && sigrenderer->desc->type == type) - return sigrenderer->sigrenderer; - - return NULL; -} - - - #if 0 // This function is disabled because we don't know whether we want to destroy // the sigrenderer if the type doesn't match. We don't even know if we need diff --git a/Frameworks/Dumb/dumb/src/core/unload.c b/Frameworks/Dumb/dumb/src/core/unload.c index f241f718d..2cb7bb3e1 100644 --- a/Frameworks/Dumb/dumb/src/core/unload.c +++ b/Frameworks/Dumb/dumb/src/core/unload.c @@ -22,43 +22,37 @@ #include "dumb.h" #include "internal/dumb.h" +static void destroy_signal(DUH_SIGNAL *signal) { + if (signal) { + if (signal->desc) + if (signal->desc->unload_sigdata) + if (signal->sigdata) + (*signal->desc->unload_sigdata)(signal->sigdata); - -static void destroy_signal(DUH_SIGNAL *signal) -{ - if (signal) { - if (signal->desc) - if (signal->desc->unload_sigdata) - if (signal->sigdata) - (*signal->desc->unload_sigdata)(signal->sigdata); - - free(signal); - } + free(signal); + } } - - /* unload_duh(): destroys a DUH struct. You must call this for every DUH * struct created, when you've finished with it. */ -void unload_duh(DUH *duh) -{ - int i; +void unload_duh(DUH *duh) { + int i; - if (duh) { - if (duh->signal) { - for (i = 0; i < duh->n_signals; i++) - destroy_signal(duh->signal[i]); + if (duh) { + if (duh->signal) { + for (i = 0; i < duh->n_signals; i++) + destroy_signal(duh->signal[i]); - free(duh->signal); - } + free(duh->signal); + } - if (duh->tag) { - if (duh->tag[0][0]) - free(duh->tag[0][0]); - free(duh->tag); - } + if (duh->tag) { + if (duh->tag[0][0]) + free(duh->tag[0][0]); + free(duh->tag); + } - free(duh); - } + free(duh); + } } diff --git a/Frameworks/Dumb/dumb/src/helpers/barray.c b/Frameworks/Dumb/dumb/src/helpers/barray.c index 23db09887..0b2d40f7b 100644 --- a/Frameworks/Dumb/dumb/src/helpers/barray.c +++ b/Frameworks/Dumb/dumb/src/helpers/barray.c @@ -2,65 +2,54 @@ #include - -void * bit_array_create(size_t size) -{ - size_t bsize = ((size + 7) >> 3) + sizeof(size_t); - void * ret = calloc(1, bsize); - if (ret) *(size_t *)ret = size; - return ret; +void *bit_array_create(size_t size) { + size_t bsize = ((size + 7) >> 3) + sizeof(size_t); + void *ret = calloc(1, bsize); + if (ret) + *(size_t *)ret = size; + return ret; } -void bit_array_destroy(void * array) -{ - if (array) free(array); +void bit_array_destroy(void *array) { + if (array) + free(array); } -void * bit_array_dup(void * array) -{ - if (array) - { - size_t * size = (size_t *) array; - size_t bsize = ((*size + 7) >> 3) + sizeof(*size); - void * ret = malloc(bsize); - if (ret) memcpy(ret, array, bsize); - return ret; - } - return NULL; +void *bit_array_dup(void *array) { + if (array) { + size_t *size = (size_t *)array; + size_t bsize = ((*size + 7) >> 3) + sizeof(*size); + void *ret = malloc(bsize); + if (ret) + memcpy(ret, array, bsize); + return ret; + } + return NULL; } -void bit_array_reset(void * array) -{ - if (array) - { - size_t * size = (size_t *) array; - size_t bsize = (*size + 7) >> 3; - memset(size + 1, 0, bsize); - } +void bit_array_reset(void *array) { + if (array) { + size_t *size = (size_t *)array; + size_t bsize = (*size + 7) >> 3; + memset(size + 1, 0, bsize); + } } - -void bit_array_set(void * array, size_t bit) -{ - if (array) - { - size_t * size = (size_t *) array; - if (bit < *size) - { - unsigned char * ptr = (unsigned char *)(size + 1); - ptr[bit >> 3] |= (1U << (bit & 7)); - } - } +void bit_array_set(void *array, size_t bit) { + if (array) { + size_t *size = (size_t *)array; + if (bit < *size) { + unsigned char *ptr = (unsigned char *)(size + 1); + ptr[bit >> 3] |= (1U << (bit & 7)); + } + } } -void bit_array_set_range(void * array, size_t bit, size_t count) -{ - if (array && count) - { - size_t * size = (size_t *) array; - if (bit < *size) - { - unsigned char * ptr = (unsigned char *)(size + 1); +void bit_array_set_range(void *array, size_t bit, size_t count) { + if (array && count) { + size_t *size = (size_t *)array; + if (bit < *size) { + unsigned char *ptr = (unsigned char *)(size + 1); size_t i; for (i = bit; i < *size && i < bit + count; ++i) ptr[i >> 3] |= (1U << (i & 7)); @@ -68,81 +57,66 @@ void bit_array_set_range(void * array, size_t bit, size_t count) } } -int bit_array_test(void * array, size_t bit) -{ - if (array) - { - size_t * size = (size_t *) array; - if (bit < *size) - { - unsigned char * ptr = (unsigned char *)(size + 1); - if (ptr[bit >> 3] & (1U << (bit & 7))) - { - return 1; - } - } - } - return 0; +int bit_array_test(void *array, size_t bit) { + if (array) { + size_t *size = (size_t *)array; + if (bit < *size) { + unsigned char *ptr = (unsigned char *)(size + 1); + if (ptr[bit >> 3] & (1U << (bit & 7))) { + return 1; + } + } + } + return 0; } -int bit_array_test_range(void * array, size_t bit, size_t count) -{ - if (array) - { - size_t * size = (size_t *) array; - if (bit < *size) - { - unsigned char * ptr = (unsigned char *)(size + 1); - if ((bit & 7) && (count > 8)) - { - while ((bit < *size) && count && (bit & 7)) - { - if (ptr[bit >> 3] & (1U << (bit & 7))) return 1; - bit++; - count--; - } - } - if (!(bit & 7)) - { - while (((*size - bit) >= 8) && (count >= 8)) - { - if (ptr[bit >> 3]) return 1; - bit += 8; - count -= 8; - } - } - while ((bit < *size) && count) - { - if (ptr[bit >> 3] & (1U << (bit & 7))) return 1; - bit++; - count--; - } - } - } - return 0; +int bit_array_test_range(void *array, size_t bit, size_t count) { + if (array) { + size_t *size = (size_t *)array; + if (bit < *size) { + unsigned char *ptr = (unsigned char *)(size + 1); + if ((bit & 7) && (count > 8)) { + while ((bit < *size) && count && (bit & 7)) { + if (ptr[bit >> 3] & (1U << (bit & 7))) + return 1; + bit++; + count--; + } + } + if (!(bit & 7)) { + while (((*size - bit) >= 8) && (count >= 8)) { + if (ptr[bit >> 3]) + return 1; + bit += 8; + count -= 8; + } + } + while ((bit < *size) && count) { + if (ptr[bit >> 3] & (1U << (bit & 7))) + return 1; + bit++; + count--; + } + } + } + return 0; } -void bit_array_clear(void * array, size_t bit) -{ - if (array) - { - size_t * size = (size_t *) array; - if (bit < *size) - { - unsigned char * ptr = (unsigned char *)(size + 1); - ptr[bit >> 3] &= ~(1U << (bit & 7)); - } - } +void bit_array_clear(void *array, size_t bit) { + if (array) { + size_t *size = (size_t *)array; + if (bit < *size) { + unsigned char *ptr = (unsigned char *)(size + 1); + ptr[bit >> 3] &= ~(1U << (bit & 7)); + } + } } -void bit_array_clear_range(void * array, size_t bit, size_t count) -{ - if (array && count) - { - size_t * size = (size_t *) array; - if (bit < *size) - { - unsigned char * ptr = (unsigned char *)(size + 1); +void bit_array_clear_range(void *array, size_t bit, size_t count) { + if (array && count) { + size_t *size = (size_t *)array; + if (bit < *size) { + unsigned char *ptr = (unsigned char *)(size + 1); size_t i; for (i = bit; i < *size && i < bit + count; ++i) ptr[i >> 3] &= ~(1U << (i & 7)); @@ -150,40 +124,32 @@ void bit_array_clear_range(void * array, size_t bit, size_t count) } } -void bit_array_merge(void * dest, void * source, size_t offset) -{ - if (dest && source) - { - size_t * dsize = (size_t *) dest; - size_t * ssize = (size_t *) source; - size_t soffset = 0; - while (offset < *dsize && soffset < *ssize) - { - if (bit_array_test(source, soffset)) - { - bit_array_set(dest, offset); - } - soffset++; - offset++; - } - } +void bit_array_merge(void *dest, void *source, size_t offset) { + if (dest && source) { + size_t *dsize = (size_t *)dest; + size_t *ssize = (size_t *)source; + size_t soffset = 0; + while (offset < *dsize && soffset < *ssize) { + if (bit_array_test(source, soffset)) { + bit_array_set(dest, offset); + } + soffset++; + offset++; + } + } } -void bit_array_mask(void * dest, void * source, size_t offset) -{ - if (dest && source) - { - size_t * dsize = (size_t *) dest; - size_t * ssize = (size_t *) source; - size_t soffset = 0; - while (offset < *dsize && soffset < *ssize) - { - if (bit_array_test(source, soffset)) - { - bit_array_clear(dest, offset); - } - soffset++; - offset++; - } - } +void bit_array_mask(void *dest, void *source, size_t offset) { + if (dest && source) { + size_t *dsize = (size_t *)dest; + size_t *ssize = (size_t *)source; + size_t soffset = 0; + while (offset < *dsize && soffset < *ssize) { + if (bit_array_test(source, soffset)) { + bit_array_clear(dest, offset); + } + soffset++; + offset++; + } + } } diff --git a/Frameworks/Dumb/dumb/src/helpers/clickrem.c b/Frameworks/Dumb/dumb/src/helpers/clickrem.c index 336b492de..5e3765dce 100644 --- a/Frameworks/Dumb/dumb/src/helpers/clickrem.c +++ b/Frameworks/Dumb/dumb/src/helpers/clickrem.c @@ -20,262 +20,238 @@ #include #include #include "dumb.h" - - +#include "internal/dumb.h" typedef struct DUMB_CLICK DUMB_CLICK; +struct DUMB_CLICK_REMOVER { + DUMB_CLICK *click; + int n_clicks; -struct DUMB_CLICK_REMOVER -{ - DUMB_CLICK *click; - int n_clicks; - - int offset; + int offset; }; - -struct DUMB_CLICK -{ - DUMB_CLICK *next; - long pos; - sample_t step; +struct DUMB_CLICK { + DUMB_CLICK *next; + long pos; + sample_t step; }; +DUMB_CLICK_REMOVER *dumb_create_click_remover(void) { + DUMB_CLICK_REMOVER *cr = malloc(sizeof(*cr)); + if (!cr) + return NULL; + cr->click = NULL; + cr->n_clicks = 0; -DUMB_CLICK_REMOVER *dumb_create_click_remover(void) -{ - DUMB_CLICK_REMOVER *cr = malloc(sizeof(*cr)); - if (!cr) return NULL; + cr->offset = 0; - cr->click = NULL; - cr->n_clicks = 0; - - cr->offset = 0; - - return cr; + return cr; } +void dumb_record_click(DUMB_CLICK_REMOVER *cr, long pos, sample_t step) { + DUMB_CLICK *click; + ASSERT(pos >= 0); -void dumb_record_click(DUMB_CLICK_REMOVER *cr, long pos, sample_t step) -{ - DUMB_CLICK *click; + if (!cr || !step) + return; - ASSERT(pos >= 0); + if (pos == 0) { + cr->offset -= step; + return; + } - if (!cr || !step) return; + click = malloc(sizeof(*click)); + if (!click) + return; - if (pos == 0) { - cr->offset -= step; - return; - } + click->pos = pos; + click->step = step; - click = malloc(sizeof(*click)); - if (!click) return; - - click->pos = pos; - click->step = step; - - click->next = cr->click; - cr->click = click; - cr->n_clicks++; + click->next = cr->click; + cr->click = click; + cr->n_clicks++; } +static DUMB_CLICK *dumb_click_mergesort(DUMB_CLICK *click, int n_clicks) { + int i; + DUMB_CLICK *c1, *c2, **cp; + if (n_clicks <= 1) + return click; -static DUMB_CLICK *dumb_click_mergesort(DUMB_CLICK *click, int n_clicks) -{ - int i; - DUMB_CLICK *c1, *c2, **cp; + /* Split the list into two */ + c1 = click; + cp = &c1; + for (i = 0; i < n_clicks; i += 2) + cp = &(*cp)->next; + c2 = *cp; + *cp = NULL; - if (n_clicks <= 1) return click; + /* Sort the sublists */ + c1 = dumb_click_mergesort(c1, (n_clicks + 1) >> 1); + c2 = dumb_click_mergesort(c2, n_clicks >> 1); - /* Split the list into two */ - c1 = click; - cp = &c1; - for (i = 0; i < n_clicks; i += 2) cp = &(*cp)->next; - c2 = *cp; - *cp = NULL; + /* Merge them */ + cp = &click; + while (c1 && c2) { + if (c1->pos > c2->pos) { + *cp = c2; + c2 = c2->next; + } else { + *cp = c1; + c1 = c1->next; + } + cp = &(*cp)->next; + } + if (c2) + *cp = c2; + else + *cp = c1; - /* Sort the sublists */ - c1 = dumb_click_mergesort(c1, (n_clicks + 1) >> 1); - c2 = dumb_click_mergesort(c2, n_clicks >> 1); - - /* Merge them */ - cp = &click; - while (c1 && c2) { - if (c1->pos > c2->pos) { - *cp = c2; - c2 = c2->next; - } else { - *cp = c1; - c1 = c1->next; - } - cp = &(*cp)->next; - } - if (c2) - *cp = c2; - else - *cp = c1; - - return click; + return click; } +void dumb_remove_clicks(DUMB_CLICK_REMOVER *cr, sample_t *samples, long length, + int step, float halflife) { + DUMB_CLICK *click; + long pos = 0; + int offset; + int factor; + if (!cr) + return; -void dumb_remove_clicks(DUMB_CLICK_REMOVER *cr, sample_t *samples, long length, int step, float halflife) -{ - DUMB_CLICK *click; - long pos = 0; - int offset; - int factor; + factor = (int)floor(pow(0.5, 1.0 / halflife) * (1U << 31)); - if (!cr) return; + click = dumb_click_mergesort(cr->click, cr->n_clicks); + cr->click = NULL; + cr->n_clicks = 0; - factor = (int)floor(pow(0.5, 1.0/halflife) * (1U << 31)); + length *= step; - click = dumb_click_mergesort(cr->click, cr->n_clicks); - cr->click = NULL; - cr->n_clicks = 0; + while (click) { + DUMB_CLICK *next = click->next; + long end = click->pos * step; + ASSERT(end <= length); + offset = cr->offset; + if (offset < 0) { + offset = -offset; + while (pos < end) { + samples[pos] -= offset; + offset = (int)(((LONG_LONG)(offset << 1) * factor) >> 32); + pos += step; + } + offset = -offset; + } else { + while (pos < end) { + samples[pos] += offset; + offset = (int)(((LONG_LONG)(offset << 1) * factor) >> 32); + pos += step; + } + } + cr->offset = offset - click->step; + free(click); + click = next; + } - length *= step; - - while (click) { - DUMB_CLICK *next = click->next; - int end = click->pos * step; - ASSERT(end <= length); - offset = cr->offset; - if (offset < 0) { - offset = -offset; - while (pos < end) { - samples[pos] -= offset; - offset = (int)(((LONG_LONG)(offset << 1) * factor) >> 32); - pos += step; - } - offset = -offset; - } else { - while (pos < end) { - samples[pos] += offset; - offset = (int)(((LONG_LONG)(offset << 1) * factor) >> 32); - pos += step; - } - } - cr->offset = offset - click->step; - free(click); - click = next; - } - - offset = cr->offset; - if (offset < 0) { - offset = -offset; - while (pos < length) { - samples[pos] -= offset; - offset = (int)((LONG_LONG)(offset << 1) * factor >> 32); - pos += step; - } - offset = -offset; - } else { - while (pos < length) { - samples[pos] += offset; - offset = (int)((LONG_LONG)(offset << 1) * factor >> 32); - pos += step; - } - } - cr->offset = offset; + offset = cr->offset; + if (offset < 0) { + offset = -offset; + while (pos < length) { + samples[pos] -= offset; + offset = (int)((LONG_LONG)(offset << 1) * factor >> 32); + pos += step; + } + offset = -offset; + } else { + while (pos < length) { + samples[pos] += offset; + offset = (int)((LONG_LONG)(offset << 1) * factor >> 32); + pos += step; + } + } + cr->offset = offset; } - - -sample_t dumb_click_remover_get_offset(DUMB_CLICK_REMOVER *cr) -{ - return cr ? cr->offset : 0; +sample_t dumb_click_remover_get_offset(DUMB_CLICK_REMOVER *cr) { + return cr ? cr->offset : 0; } - - -void dumb_destroy_click_remover(DUMB_CLICK_REMOVER *cr) -{ - if (cr) { - DUMB_CLICK *click = cr->click; - while (click) { - DUMB_CLICK *next = click->next; - free(click); - click = next; - } - free(cr); - } +void dumb_destroy_click_remover(DUMB_CLICK_REMOVER *cr) { + if (cr) { + DUMB_CLICK *click = cr->click; + while (click) { + DUMB_CLICK *next = click->next; + free(click); + click = next; + } + free(cr); + } } - - -DUMB_CLICK_REMOVER **dumb_create_click_remover_array(int n) -{ - int i; - DUMB_CLICK_REMOVER **cr; - if (n <= 0) return NULL; - cr = malloc(n * sizeof(*cr)); - if (!cr) return NULL; - for (i = 0; i < n; i++) cr[i] = dumb_create_click_remover(); - return cr; +DUMB_CLICK_REMOVER **dumb_create_click_remover_array(int n) { + int i; + DUMB_CLICK_REMOVER **cr; + if (n <= 0) + return NULL; + cr = malloc(n * sizeof(*cr)); + if (!cr) + return NULL; + for (i = 0; i < n; i++) + cr[i] = dumb_create_click_remover(); + return cr; } - - -void dumb_record_click_array(int n, DUMB_CLICK_REMOVER **cr, long pos, sample_t *step) -{ - if (cr) { - int i; - for (i = 0; i < n; i++) - dumb_record_click(cr[i], pos, step[i]); - } +void dumb_record_click_array(int n, DUMB_CLICK_REMOVER **cr, long pos, + sample_t *step) { + if (cr) { + int i; + for (i = 0; i < n; i++) + dumb_record_click(cr[i], pos, step[i]); + } } - - -void dumb_record_click_negative_array(int n, DUMB_CLICK_REMOVER **cr, long pos, sample_t *step) -{ - if (cr) { - int i; - for (i = 0; i < n; i++) - dumb_record_click(cr[i], pos, -step[i]); - } +void dumb_record_click_negative_array(int n, DUMB_CLICK_REMOVER **cr, long pos, + sample_t *step) { + if (cr) { + int i; + for (i = 0; i < n; i++) + dumb_record_click(cr[i], pos, -step[i]); + } } - - -void dumb_remove_clicks_array(int n, DUMB_CLICK_REMOVER **cr, sample_t **samples, long length, float halflife) -{ - if (cr) { - int i; - for (i = 0; i < n >> 1; i++) { - dumb_remove_clicks(cr[i << 1], samples[i], length, 2, halflife); - dumb_remove_clicks(cr[(i << 1) + 1], samples[i] + 1, length, 2, halflife); - } - if (n & 1) - dumb_remove_clicks(cr[i << 1], samples[i], length, 1, halflife); - } +void dumb_remove_clicks_array(int n, DUMB_CLICK_REMOVER **cr, + sample_t **samples, long length, float halflife) { + if (cr) { + int i; + for (i = 0; i> 1; i++) { + dumb_remove_clicks(cr[i << 1], samples[i], length, 2, halflife); + dumb_remove_clicks(cr[(i << 1) + 1], samples[i] + 1, length, 2, + halflife); + } + if (n & 1) + dumb_remove_clicks(cr[i << 1], samples[i], length, 1, halflife); + } } - - -void dumb_click_remover_get_offset_array(int n, DUMB_CLICK_REMOVER **cr, sample_t *offset) -{ - if (cr) { - int i; - for (i = 0; i < n; i++) - if (cr[i]) offset[i] += cr[i]->offset; - } +void dumb_click_remover_get_offset_array(int n, DUMB_CLICK_REMOVER **cr, + sample_t *offset) { + if (cr) { + int i; + for (i = 0; i < n; i++) + if (cr[i]) + offset[i] += cr[i]->offset; + } } - - -void dumb_destroy_click_remover_array(int n, DUMB_CLICK_REMOVER **cr) -{ - if (cr) { - int i; - for (i = 0; i < n; i++) dumb_destroy_click_remover(cr[i]); - free(cr); - } +void dumb_destroy_click_remover_array(int n, DUMB_CLICK_REMOVER **cr) { + if (cr) { + int i; + for (i = 0; i < n; i++) + dumb_destroy_click_remover(cr[i]); + free(cr); + } } diff --git a/Frameworks/Dumb/dumb/src/helpers/fir_resampler.c b/Frameworks/Dumb/dumb/src/helpers/fir_resampler.c deleted file mode 100644 index cc6460769..000000000 --- a/Frameworks/Dumb/dumb/src/helpers/fir_resampler.c +++ /dev/null @@ -1,281 +0,0 @@ -#include -#include -#include - -#include "internal/fir_resampler.h" - -enum { fir_width = 16 }; - -enum { fir_max_res = 1024 }; -enum { fir_min_width = (fir_width < 4 ? 4 : fir_width) }; -enum { fir_adj_width = fir_min_width / 4 * 4 + 2 }; -enum { fir_stereo = 1 }; /* channel count, not boolean value */ -enum { fir_write_offset = fir_adj_width * fir_stereo }; - -enum { fir_buffer_size = fir_width * 2 }; - -typedef short fir_impulse[fir_adj_width]; - -/* exp slope to 31/32 of ln(8) */ -static const double fir_ratios[32] = { - 1.000, 1.067, 1.139, 1.215, 1.297, 1.384, 1.477, 1.576, - 1.682, 1.795, 1.915, 2.044, 2.181, 2.327, 2.484, 2.650, - 2.828, 3.018, 3.221, 3.437, 3.668, 3.914, 4.177, 4.458, - 4.757, 5.076, 5.417, 5.781, 6.169, 6.583, 7.025, 7.497 -}; - -static fir_impulse fir_impulses[32][fir_max_res]; - -#undef PI -#define PI 3.1415926535897932384626433832795029 - -static void gen_sinc( double rolloff, int width, double offset, double spacing, double scale, - int count, short* out ) -{ - double const maxh = 256; - double const step = PI / maxh * spacing; - double const to_w = maxh * 2 / width; - double const pow_a_n = pow( rolloff, maxh ); - - double angle = (count / 2 - 1 + offset) * -step; - - scale /= maxh * 2; - - while ( count-- ) - { - double w; - *out++ = 0; - w = angle * to_w; - if ( fabs( w ) < PI ) - { - double rolloff_cos_a = rolloff * cos( angle ); - double num = 1 - rolloff_cos_a - - pow_a_n * cos( maxh * angle ) + - pow_a_n * rolloff * cos( (maxh - 1) * angle ); - double den = 1 - rolloff_cos_a - rolloff_cos_a + rolloff * rolloff; - double sinc = scale * num / den - scale; - - out [-1] = (short) (cos( w ) * sinc + sinc); - } - angle += step; - } -} - -typedef struct fir_resampler -{ - int write_pos, write_filled; - int read_pos, read_filled; - unsigned short phase; - unsigned int phase_inc; - unsigned int ratio_set; - int buffer_in[fir_buffer_size * 2]; - int buffer_out[fir_buffer_size]; -} fir_resampler; - -void * fir_resampler_create() -{ - fir_resampler * r = ( fir_resampler * ) malloc( sizeof(fir_resampler) ); - if ( !r ) return 0; - - r->write_pos = 0; - r->write_filled = 0; - r->read_pos = 0; - r->read_filled = 0; - r->phase = 0; - r->phase_inc = 0; - r->ratio_set = 0; - memset( r->buffer_in, 0, sizeof(r->buffer_in) ); - memset( r->buffer_out, 0, sizeof(r->buffer_out) ); - - return r; -} - -void fir_resampler_delete(void * _r) -{ - free( _r ); -} - -void * fir_resampler_dup(void * _r) -{ - fir_resampler * r_in = ( fir_resampler * ) _r; - fir_resampler * r_out = ( fir_resampler * ) malloc( sizeof(fir_resampler) ); - if ( !r_out ) return 0; - - r_out->write_pos = r_in->write_pos; - r_out->write_filled = r_in->write_filled; - r_out->read_pos = r_in->read_pos; - r_out->read_filled = r_in->read_filled; - r_out->phase = r_in->phase; - r_out->phase_inc = r_in->phase_inc; - r_out->ratio_set = r_in->ratio_set; - memcpy( r_out->buffer_in, r_in->buffer_in, sizeof(r_in->buffer_in) ); - memcpy( r_out->buffer_out, r_in->buffer_out, sizeof(r_in->buffer_out) ); - - return r_out; -} - -int fir_resampler_get_free_count(void *_r) -{ - fir_resampler * r = ( fir_resampler * ) _r; - return fir_buffer_size - r->write_filled; -} - -int fir_resampler_ready(void *_r) -{ - fir_resampler * r = ( fir_resampler * ) _r; - return r->write_filled > fir_adj_width; -} - -void fir_resampler_clear(void *_r) -{ - fir_resampler * r = ( fir_resampler * ) _r; - r->write_pos = 0; - r->write_filled = 0; - r->read_pos = 0; - r->read_filled = 0; - r->phase = 0; - memset( r->buffer_in, 0, sizeof(r->buffer_in) ); -} - -void fir_resampler_set_rate(void *_r, double new_factor) -{ - fir_resampler * r = ( fir_resampler * ) _r; - r->phase_inc = (int)( new_factor * 65536.0 ); - r->ratio_set = 0; - while ( r->ratio_set < 31 && new_factor > fir_ratios[ r->ratio_set ] ) r->ratio_set++; -} - -void fir_resampler_write_sample(void *_r, short s) -{ - fir_resampler * r = ( fir_resampler * ) _r; - - if ( r->write_filled < fir_buffer_size ) - { - int s32 = s; - - r->buffer_in[ r->write_pos ] = s32; - r->buffer_in[ r->write_pos + fir_buffer_size ] = s32; - - ++r->write_filled; - - r->write_pos = ( r->write_pos + 1 ) % fir_buffer_size; - } -} - -void fir_init() -{ - double const rolloff = 0.999; - double const gain = 1.0; - - int const res = fir_max_res; - - int i; - - for (i = 0; i < 32; i++) - { - double const ratio_ = fir_ratios[ i ]; - - double fraction = 1.0 / (double)fir_max_res; - - double const filter = (ratio_ < 1.0) ? 1.0 : 1.0 / ratio_; - double pos = 0.0; - short* out = (short*) fir_impulses[ i ]; - int n; - for ( n = res; --n >= 0; ) - { - gen_sinc( rolloff, (int) (fir_adj_width * filter + 1) & ~1, pos, filter, - (double) (0x7FFF * gain * filter), (int) fir_adj_width, out ); - out += fir_adj_width; - - pos += fraction; - } - } -} - -int fir_resampler_run(void *_r, int ** out_, int * out_end) -{ - fir_resampler * r = ( fir_resampler * ) _r; - int in_size = r->write_filled; - int const* in_ = r->buffer_in + fir_buffer_size + r->write_pos - r->write_filled; - int used = 0; - in_size -= fir_write_offset; - if ( in_size > 0 ) - { - int* out = *out_; - int const* in = in_; - int const* const in_end = in + in_size; - int phase = r->phase; - int phase_inc = r->phase_inc; - int ratio_set = r->ratio_set; - - do - { - // accumulate in extended precision - short const* imp = fir_impulses[ratio_set][(phase & 0xFFC0) >> 6]; - int pt = imp [0]; - int s = pt * in [0]; - int n; - if ( out >= out_end ) - break; - for ( n = (fir_adj_width - 2) / 2; n; --n ) - { - pt = imp [1]; - s += pt * in [1]; - - // pre-increment more efficient on some RISC processors - imp += 2; - pt = imp [0]; - in += 2; - s += pt * in [0]; - } - pt = imp [1]; - s += pt * in [1]; - - phase += phase_inc; - - in += (phase >> 16) - fir_adj_width + 2; - - phase &= 65535; - - *out++ = (int) (s >> 7); - } - while ( in < in_end ); - - r->phase = phase; - *out_ = out; - - used = in - in_; - - r->write_filled -= used; - } - - return used; -} - -int fir_resampler_get_sample(void *_r) -{ - fir_resampler * r = ( fir_resampler * ) _r; - if ( r->read_filled < 1 ) - { - int write_pos = ( r->read_pos + r->read_filled ) % fir_buffer_size; - int write_size = fir_buffer_size - write_pos; - int * out = r->buffer_out + write_pos; - if ( write_size > ( fir_buffer_size - r->read_filled ) ) - write_size = fir_buffer_size - r->read_filled; - fir_resampler_run( r, &out, out + write_size ); - r->read_filled += out - r->buffer_out - write_pos; - } - if ( r->read_filled < 1 ) - return 0; - return r->buffer_out[ r->read_pos ]; -} - -void fir_resampler_remove_sample(void *_r) -{ - fir_resampler * r = ( fir_resampler * ) _r; - if ( r->read_filled > 0 ) - { - --r->read_filled; - r->read_pos = ( r->read_pos + 1 ) % fir_buffer_size; - } -} diff --git a/Frameworks/Dumb/dumb/src/helpers/lpc.c b/Frameworks/Dumb/dumb/src/helpers/lpc.c index 309f976bc..276230aa4 100644 --- a/Frameworks/Dumb/dumb/src/helpers/lpc.c +++ b/Frameworks/Dumb/dumb/src/helpers/lpc.c @@ -55,286 +55,286 @@ Carsten Bormann /* Input : n elements of time doamin data Output: m lpc coefficients, excitation energy */ -static float vorbis_lpc_from_data(float *data,float *lpci,long n,long m){ - double *aut=alloca(sizeof(*aut)*(m+1)); - double *lpc=alloca(sizeof(*lpc)*(m)); - double error; - double epsilon; - long i,j; +static float vorbis_lpc_from_data(float *data, float *lpci, long n, long m) { + double *aut = alloca(sizeof(*aut) * (m + 1)); + double *lpc = alloca(sizeof(*lpc) * (m)); + double error; + double epsilon; + long i, j; - /* autocorrelation, p+1 lag coefficients */ - j=m+1; - while(j--){ - double d=0; /* double needed for accumulator depth */ - for(i=j;in_samples; n++ ) { - IT_SAMPLE * sample = sigdata->sample + n; - if ( ( sample->flags & ( IT_SAMPLE_EXISTS | IT_SAMPLE_LOOP) ) == IT_SAMPLE_EXISTS && - sample->data != NULL ) { - /* If we have enough sample data to train the filter, use the filter to generate the padding */ - if ( sample->length >= lpc_order ) { + for (n = 0; n < sigdata->n_samples; n++) { + IT_SAMPLE *sample = sigdata->sample + n; + if ((sample->flags & (IT_SAMPLE_EXISTS | IT_SAMPLE_LOOP)) == + IT_SAMPLE_EXISTS && + sample->data != NULL) { + /* If we have enough sample data to train the filter, use the filter + * to generate the padding */ + if (sample->length >= lpc_order) { lpc_samples = sample->length; - if (lpc_samples > lpc_max) lpc_samples = lpc_max; + if (lpc_samples > lpc_max) + lpc_samples = lpc_max; offset = sample->length - lpc_samples; - if ( sample->flags & IT_SAMPLE_STEREO ) - { - if ( sample->flags & IT_SAMPLE_16BIT ) - { - s16 = ( signed short * ) sample->data; + if (sample->flags & IT_SAMPLE_STEREO) { + if (sample->flags & IT_SAMPLE_16BIT) { + s16 = (signed short *)sample->data; s16 += offset * 2; - for ( o = 0; o < lpc_samples; o++ ) - { - lpc_input[ o ] = s16[ o * 2 + 0 ]; - lpc_input[ o + lpc_max ] = s16[ o * 2 + 1 ]; + for (o = 0; o < lpc_samples; o++) { + lpc_input[o] = s16[o * 2 + 0]; + lpc_input[o + lpc_max] = s16[o * 2 + 1]; } - } - else - { - s8 = ( signed char * ) sample->data; + } else { + s8 = (signed char *)sample->data; s8 += offset * 2; - for ( o = 0; o < lpc_samples; o++ ) - { - lpc_input[ o ] = s8[ o * 2 + 0 ]; - lpc_input[ o + lpc_max ] = s8[ o * 2 + 1 ]; + for (o = 0; o < lpc_samples; o++) { + lpc_input[o] = s8[o * 2 + 0]; + lpc_input[o + lpc_max] = s8[o * 2 + 1]; } } - vorbis_lpc_from_data( lpc_input, lpc, lpc_samples, lpc_order ); - vorbis_lpc_from_data( lpc_input + lpc_max, lpc + lpc_order, lpc_samples, lpc_order ); + vorbis_lpc_from_data(lpc_input, lpc, lpc_samples, + lpc_order); + vorbis_lpc_from_data(lpc_input + lpc_max, lpc + lpc_order, + lpc_samples, lpc_order); - vorbis_lpc_predict( lpc, lpc_input + lpc_samples - lpc_order, lpc_order, lpc_output, lpc_extra ); - vorbis_lpc_predict( lpc + lpc_order, lpc_input + lpc_max + lpc_samples - lpc_order, lpc_order, lpc_output + lpc_extra, lpc_extra ); + vorbis_lpc_predict(lpc, lpc_input + lpc_samples - lpc_order, + lpc_order, lpc_output, lpc_extra); + vorbis_lpc_predict( + lpc + lpc_order, + lpc_input + lpc_max + lpc_samples - lpc_order, + lpc_order, lpc_output + lpc_extra, lpc_extra); + + if (sample->flags & IT_SAMPLE_16BIT) { + s16 = (signed short *)realloc( + sample->data, + (sample->length + lpc_extra) * 2 * sizeof(short)); + if (!s16) + return -1; - if ( sample->flags & IT_SAMPLE_16BIT ) - { - s16 = ( signed short * ) realloc( sample->data, ( sample->length + lpc_extra ) * 2 * sizeof(short) ); - if ( !s16 ) - return -1; - sample->data = s16; s16 += sample->length * 2; sample->length += lpc_extra; - for ( o = 0; o < lpc_extra; o++ ) - { - s16[ o * 2 + 0 ] = lpc_output[ o ]; - s16[ o * 2 + 1 ] = lpc_output[ o + lpc_extra ]; + for (o = 0; o < lpc_extra; o++) { + s16[o * 2 + 0] = lpc_output[o]; + s16[o * 2 + 1] = lpc_output[o + lpc_extra]; } - } - else - { - s8 = ( signed char * ) realloc( sample->data, ( sample->length + lpc_extra ) * 2 ); - if ( !s8 ) - return -1; - + } else { + s8 = (signed char *)realloc( + sample->data, (sample->length + lpc_extra) * 2); + if (!s8) + return -1; + sample->data = s8; s8 += sample->length * 2; sample->length += lpc_extra; - for ( o = 0; o < lpc_extra; o++ ) - { - s8[ o * 2 + 0 ] = lpc_output[ o ]; - s8[ o * 2 + 1 ] = lpc_output[ o + lpc_extra ]; + for (o = 0; o < lpc_extra; o++) { + s8[o * 2 + 0] = lpc_output[o]; + s8[o * 2 + 1] = lpc_output[o + lpc_extra]; } } - } - else - { - if ( sample->flags & IT_SAMPLE_16BIT ) - { - s16 = ( signed short * ) sample->data; + } else { + if (sample->flags & IT_SAMPLE_16BIT) { + s16 = (signed short *)sample->data; s16 += offset; - for ( o = 0; o < lpc_samples; o++ ) - { - lpc_input[ o ] = s16[ o ]; + for (o = 0; o < lpc_samples; o++) { + lpc_input[o] = s16[o]; } - } - else - { - s8 = ( signed char * ) sample->data; + } else { + s8 = (signed char *)sample->data; s8 += offset; - for ( o = 0; o < lpc_samples; o++ ) - { - lpc_input[ o ] = s8[ o ]; + for (o = 0; o < lpc_samples; o++) { + lpc_input[o] = s8[o]; } } - vorbis_lpc_from_data( lpc_input, lpc, lpc_samples, lpc_order ); + vorbis_lpc_from_data(lpc_input, lpc, lpc_samples, + lpc_order); - vorbis_lpc_predict( lpc, lpc_input + lpc_samples - lpc_order, lpc_order, lpc_output, lpc_extra ); + vorbis_lpc_predict(lpc, lpc_input + lpc_samples - lpc_order, + lpc_order, lpc_output, lpc_extra); + + if (sample->flags & IT_SAMPLE_16BIT) { + s16 = (signed short *)realloc( + sample->data, + (sample->length + lpc_extra) * sizeof(short)); + if (!s16) + return -1; - if ( sample->flags & IT_SAMPLE_16BIT ) - { - s16 = ( signed short * ) realloc( sample->data, ( sample->length + lpc_extra ) * sizeof(short) ); - if (!s16) - return -1; - sample->data = s16; s16 += sample->length; sample->length += lpc_extra; - for ( o = 0; o < lpc_extra; o++ ) - { - s16[ o ] = lpc_output[ o ]; + for (o = 0; o < lpc_extra; o++) { + s16[o] = lpc_output[o]; } - } - else - { - s8 = ( signed char * ) realloc( sample->data, sample->length + lpc_extra ); - if ( !s8 ) - return -1; - + } else { + s8 = (signed char *)realloc(sample->data, + sample->length + lpc_extra); + if (!s8) + return -1; + sample->data = s8; s8 += sample->length; sample->length += lpc_extra; - for ( o = 0; o < lpc_extra; o++ ) - { - s8[ o ] = lpc_output[ o ]; + for (o = 0; o < lpc_extra; o++) { + s8[o] = lpc_output[o]; } } } - } - else + } else /* Otherwise, pad with silence. */ { - void *data; + void *data; offset = sample->length; lpc_samples = lpc_extra; sample->length += lpc_samples; n = 1; - if ( sample->flags & IT_SAMPLE_STEREO ) n *= 2; - if ( sample->flags & IT_SAMPLE_16BIT ) n *= 2; + if (sample->flags & IT_SAMPLE_STEREO) + n *= 2; + if (sample->flags & IT_SAMPLE_16BIT) + n *= 2; offset *= n; lpc_samples *= n; - data = realloc( sample->data, offset + lpc_samples ); - if (!data) - return -1; - sample->data = data; - - memset( (char*)data + offset, 0, lpc_samples ); + data = realloc(sample->data, offset + lpc_samples); + if (!data) + return -1; + sample->data = data; + + memset((char *)data + offset, 0, lpc_samples); } } } - - return 0; + + return 0; } diff --git a/Frameworks/Dumb/dumb/src/helpers/memfile.c b/Frameworks/Dumb/dumb/src/helpers/memfile.c index 623c4d6d0..461116d8e 100644 --- a/Frameworks/Dumb/dumb/src/helpers/memfile.c +++ b/Frameworks/Dumb/dumb/src/helpers/memfile.c @@ -22,96 +22,73 @@ #include "dumb.h" - - typedef struct MEMFILE MEMFILE; -struct MEMFILE -{ - const char *ptr, *ptr_begin; - long left, size; +struct MEMFILE { + const char *ptr, *ptr_begin; + size_t left, size; }; - - -static int dumb_memfile_skip(void *f, long n) -{ - MEMFILE *m = f; - if (n > m->left) return -1; - m->ptr += n; - m->left -= n; - return 0; +static int dumb_memfile_skip(void *f, dumb_off_t n) { + MEMFILE *m = f; + if (n > (dumb_off_t)m->left) + return -1; + m->ptr += n; + m->left -= n; + return 0; } - - -static int dumb_memfile_getc(void *f) -{ - MEMFILE *m = f; - if (m->left <= 0) return -1; - m->left--; - return *(const unsigned char *)m->ptr++; +static int dumb_memfile_getc(void *f) { + MEMFILE *m = f; + if (m->left <= 0) + return -1; + m->left--; + return *(const unsigned char *)m->ptr++; } - - -static long dumb_memfile_getnc(char *ptr, long n, void *f) -{ - MEMFILE *m = f; - if (n > m->left) n = m->left; - memcpy(ptr, m->ptr, n); - m->ptr += n; - m->left -= n; - return n; +static dumb_ssize_t dumb_memfile_getnc(char *ptr, size_t n, void *f) { + MEMFILE *m = f; + if (n > m->left) + n = m->left; + memcpy(ptr, m->ptr, n); + m->ptr += n; + m->left -= n; + return n; } +static void dumb_memfile_close(void *f) { free(f); } +static int dumb_memfile_seek(void *f, dumb_off_t n) { + MEMFILE *m = f; -static void dumb_memfile_close(void *f) -{ - free(f); + m->ptr = m->ptr_begin + n; + m->left = m->size - n; + + return 0; } - -static int dumb_memfile_seek(void *f, long n) -{ - MEMFILE *m = f; - - m->ptr = m->ptr_begin + n; - m->left = m->size - n; - - return 0; +static dumb_off_t dumb_memfile_get_size(void *f) { + MEMFILE *m = f; + return m->size; } +static const DUMBFILE_SYSTEM memfile_dfs = {NULL, + &dumb_memfile_skip, + &dumb_memfile_getc, + &dumb_memfile_getnc, + &dumb_memfile_close, + &dumb_memfile_seek, + &dumb_memfile_get_size}; -static long dumb_memfile_get_size(void *f) -{ - MEMFILE *m = f; - return m->size; -} - - -static const DUMBFILE_SYSTEM memfile_dfs = { - NULL, - &dumb_memfile_skip, - &dumb_memfile_getc, - &dumb_memfile_getnc, - &dumb_memfile_close, - &dumb_memfile_seek, - &dumb_memfile_get_size -}; - - - -DUMBFILE *dumbfile_open_memory(const char *data, long size) -{ - MEMFILE *m = malloc(sizeof(*m)); - if (!m) return NULL; - - m->ptr_begin = data; - m->ptr = data; - m->left = size; - m->size = size; - - return dumbfile_open_ex(m, &memfile_dfs); +DUMBFILE *dumbfile_open_memory(const char *data, size_t size) { + MEMFILE *m = malloc(sizeof(*m)); + if (!m) + return NULL; + + m->ptr_begin = data; + m->ptr = data; + m->left = size; + m->size = size; + + return dumbfile_open_ex(m, &memfile_dfs); } diff --git a/Frameworks/Dumb/dumb/src/helpers/resamp2.inc b/Frameworks/Dumb/dumb/src/helpers/resamp2.inc index ee4151280..6d7eba0fe 100644 --- a/Frameworks/Dumb/dumb/src/helpers/resamp2.inc +++ b/Frameworks/Dumb/dumb/src/helpers/resamp2.inc @@ -42,51 +42,57 @@ * FIXME: these comments are somewhat out of date now. */ - - #define SUFFIX3 _1 /* For convenience, returns nonzero on stop. */ -static int process_pickup(DUMB_RESAMPLER *resampler) -{ - if (resampler->overshot < 0) { - resampler->overshot = 0; - dumb_resample(resampler, NULL, 2, MONO_DEST_VOLUME_ZEROS, 1.0f); /* Doesn't matter which SUFFIX3. */ - COPYSRC(resampler->X, 0, resampler->X, 1); - } +static int process_pickup(DUMB_RESAMPLER *resampler) { + if (resampler->overshot < 0) { + resampler->overshot = 0; + dumb_resample(resampler, NULL, 2, MONO_DEST_VOLUME_ZEROS, + 1.0f); /* Doesn't matter which SUFFIX3. */ + COPYSRC(resampler->X, 0, resampler->X, 1); + } - for (;;) { - SRCTYPE *src = resampler->src; + for (;;) { + SRCTYPE *src = resampler->src; - if (resampler->dir < 0) { - if (resampler->overshot >= 3 && resampler->pos+3 >= resampler->start) COPYSRC(resampler->X, 0, src, resampler->pos+3); - if (resampler->overshot >= 2 && resampler->pos+2 >= resampler->start) COPYSRC(resampler->X, 1, src, resampler->pos+2); - if (resampler->overshot >= 1 && resampler->pos+1 >= resampler->start) COPYSRC(resampler->X, 2, src, resampler->pos+1); - resampler->overshot = resampler->start - resampler->pos - 1; - } else { - if (resampler->overshot >= 3 && resampler->pos-3 < resampler->end) COPYSRC(resampler->X, 0, src, resampler->pos-3); - if (resampler->overshot >= 2 && resampler->pos-2 < resampler->end) COPYSRC(resampler->X, 1, src, resampler->pos-2); - if (resampler->overshot >= 1 && resampler->pos-1 < resampler->end) COPYSRC(resampler->X, 2, src, resampler->pos-1); - resampler->overshot = resampler->pos - resampler->end; - } + if (resampler->dir < 0) { + if (resampler->overshot >= 3 && + resampler->pos + 3 >= resampler->start) + COPYSRC(resampler->X, 0, src, resampler->pos + 3); + if (resampler->overshot >= 2 && + resampler->pos + 2 >= resampler->start) + COPYSRC(resampler->X, 1, src, resampler->pos + 2); + if (resampler->overshot >= 1 && + resampler->pos + 1 >= resampler->start) + COPYSRC(resampler->X, 2, src, resampler->pos + 1); + resampler->overshot = (int)(resampler->start - resampler->pos - 1); + } else { + if (resampler->overshot >= 3 && resampler->pos - 3 < resampler->end) + COPYSRC(resampler->X, 0, src, resampler->pos - 3); + if (resampler->overshot >= 2 && resampler->pos - 2 < resampler->end) + COPYSRC(resampler->X, 1, src, resampler->pos - 2); + if (resampler->overshot >= 1 && resampler->pos - 1 < resampler->end) + COPYSRC(resampler->X, 2, src, resampler->pos - 1); + resampler->overshot = (int)(resampler->pos - resampler->end); + } - if (resampler->overshot < 0) { - resampler->overshot = 0; - return 0; - } + if (resampler->overshot < 0) { + resampler->overshot = 0; + return 0; + } - if (!resampler->pickup) { - resampler->dir = 0; - return 1; - } - (*resampler->pickup)(resampler, resampler->pickup_data); - if (resampler->dir == 0) return 1; - ASSERT(resampler->dir == -1 || resampler->dir == 1); - } + if (!resampler->pickup) { + resampler->dir = 0; + return 1; + } + (*resampler->pickup)(resampler, resampler->pickup_data); + if (resampler->dir == 0) + return 1; + ASSERT(resampler->dir == -1 || resampler->dir == 1); + } } - - /* Create mono destination resampler. */ /* SUFFIX3 was set above. */ #define VOLUME_PARAMETERS MONO_DEST_VOLUME_PARAMETERS @@ -101,48 +107,58 @@ static int process_pickup(DUMB_RESAMPLER *resampler) /* Create stereo destination resampler. */ #define SUFFIX3 _2 -#define VOLUME_PARAMETERS DUMB_VOLUME_RAMP_INFO * volume_left, DUMB_VOLUME_RAMP_INFO * volume_right -#define VOLUME_VARIABLES lvol, lvolr, lvold, lvolt, lvolm, rvol, rvolr, rvold, rvolt, rvolm -#define SET_VOLUME_VARIABLES { \ - if ( volume_left ) { \ - lvolr = volume_left->volume; \ - lvold = volume_left->delta; \ - lvolt = volume_left->target; \ - lvolm = volume_left->mix; \ - lvol = lvolr * lvolm; \ - if ( lvolr == lvolt ) volume_left = NULL; \ - } else { \ - lvol = 0; \ - lvold = 0; \ - lvolt = 0; \ - lvolm = 0; \ - } \ - if ( volume_right ) { \ - rvolr = volume_right->volume; \ - rvold = volume_right->delta; \ - rvolt = volume_right->target; \ - rvolm = volume_right->mix; \ - rvol = rvolr * rvolm; \ - if ( rvolr == rvolt ) volume_right = NULL; \ - } else { \ - rvol = 0; \ - rvold = 0; \ - rvolt = 0; \ - rvolm = 0; \ - } \ -} -#define RETURN_VOLUME_VARIABLES { \ - if ( volume_left ) volume_left->volume = lvolr; \ - if ( volume_right ) volume_right->volume = rvolr; \ -} +#define VOLUME_PARAMETERS \ + DUMB_VOLUME_RAMP_INFO *volume_left, DUMB_VOLUME_RAMP_INFO *volume_right +#define VOLUME_VARIABLES \ + lvol, lvolr, lvold, lvolt, lvolm, rvol, rvolr, rvold, rvolt, rvolm +#define SET_VOLUME_VARIABLES \ + { \ + if (volume_left) { \ + lvolr = volume_left->volume; \ + lvold = volume_left->delta; \ + lvolt = volume_left->target; \ + lvolm = volume_left->mix; \ + lvol = lvolr * lvolm; \ + if (lvolr == lvolt) \ + volume_left = NULL; \ + } else { \ + lvol = 0; \ + lvold = 0; \ + lvolt = 0; \ + lvolm = 0; \ + } \ + if (volume_right) { \ + rvolr = volume_right->volume; \ + rvold = volume_right->delta; \ + rvolt = volume_right->target; \ + rvolm = volume_right->mix; \ + rvol = rvolr * rvolm; \ + if (rvolr == rvolt) \ + volume_right = NULL; \ + } else { \ + rvol = 0; \ + rvold = 0; \ + rvolt = 0; \ + rvolm = 0; \ + } \ + } +#define RETURN_VOLUME_VARIABLES \ + { \ + if (volume_left) \ + volume_left->volume = lvolr; \ + if (volume_right) \ + volume_right->volume = rvolr; \ + } #define VOLUMES_ARE_ZERO (lvol == 0 && lvolt == 0 && rvol == 0 && rvolt == 0) #define PEEK_FIR STEREO_DEST_PEEK_FIR #define MIX_FIR STEREO_DEST_MIX_FIR -#define MIX_ZEROS(op) { *dst++ op 0; *dst++ op 0; } +#define MIX_ZEROS(op) \ + { \ + *dst++ op 0; \ + *dst++ op 0; \ + } #include "resamp3.inc" - - #undef MONO_DEST_VOLUMES_ARE_ZERO #undef SET_MONO_DEST_VOLUME_VARIABLES #undef RETURN_MONO_DEST_VOLUME_VARIABLES diff --git a/Frameworks/Dumb/dumb/src/helpers/resamp3.inc b/Frameworks/Dumb/dumb/src/helpers/resamp3.inc index e98515b19..6e8391d3b 100644 --- a/Frameworks/Dumb/dumb/src/helpers/resamp3.inc +++ b/Frameworks/Dumb/dumb/src/helpers/resamp3.inc @@ -42,211 +42,231 @@ * FIXME: these comments are somewhat out of date now. */ +long dumb_resample(DUMB_RESAMPLER *resampler, sample_t *dst, long dst_size, + VOLUME_PARAMETERS, float delta) { + int dt, inv_dt; + float VOLUME_VARIABLES; + long done; + long todo; + LONG_LONG todo64; + int quality; + if (!resampler || resampler->dir == 0) + return 0; + ASSERT(resampler->dir == -1 || resampler->dir == 1); -long dumb_resample(DUMB_RESAMPLER *resampler, sample_t *dst, long dst_size, VOLUME_PARAMETERS, float delta) -{ - int dt, inv_dt; - float VOLUME_VARIABLES; - long done; - long todo; - LONG_LONG todo64; - int quality; + done = 0; + dt = (int)(delta * 65536.0 + 0.5); + if (dt == 0 || dt == (int)-0x80000000) + return 0; + inv_dt = (int)(1.0 / delta * 65536.0 + 0.5); + SET_VOLUME_VARIABLES; - if (!resampler || resampler->dir == 0) return 0; - ASSERT(resampler->dir == -1 || resampler->dir == 1); + if (VOLUMES_ARE_ZERO) + dst = NULL; - done = 0; - dt = (int)(delta * 65536.0 + 0.5); - if (dt == 0 || dt == (int)-0x80000000) return 0; - inv_dt = (int)(1.0 / delta * 65536.0 + 0.5); - SET_VOLUME_VARIABLES; + _dumb_init_cubic(); - if (VOLUMES_ARE_ZERO) dst = NULL; + quality = resampler->quality; - _dumb_init_cubic(); + while (done < dst_size) { + if (process_pickup(resampler)) { + RETURN_VOLUME_VARIABLES; + return done; + } - quality = resampler->quality; + if ((resampler->dir ^ dt) < 0) + dt = -dt; - while (done < dst_size) { - if (process_pickup(resampler)) { - RETURN_VOLUME_VARIABLES; - return done; - } + if (resampler->dir < 0) + todo64 = ((((LONG_LONG)(resampler->pos - resampler->start) << 16) + + resampler->subpos - dt) / + -dt); + else + todo64 = ((((LONG_LONG)(resampler->end - resampler->pos) << 16) - + resampler->subpos - 1 + dt) / + dt); - if ((resampler->dir ^ dt) < 0) - dt = -dt; + if (todo64 < 0) + todo = 0; + else if (todo64 > dst_size - done) + todo = dst_size - done; + else + todo = (long)todo64; - if (resampler->dir < 0) - todo64 = ((((LONG_LONG)(resampler->pos - resampler->start) << 16) + resampler->subpos - dt) / -dt); - else - todo64 = ((((LONG_LONG)(resampler->end - resampler->pos) << 16) - resampler->subpos - 1 + dt) / dt); + done += todo; - if (todo64 < 0) - todo = 0; - else if (todo64 > dst_size - done) - todo = dst_size - done; - else - todo = (long) todo64; - - done += todo; - - { - SRCTYPE *src = resampler->src; - long pos = resampler->pos; - int subpos = resampler->subpos; - long diff = pos; - long overshot; - if (resampler->dir < 0) { - if (!dst) { - /* Silence or simulation */ - LONG_LONG new_subpos = subpos + (LONG_LONG)dt * todo; - pos += (long)(new_subpos >> 16); - subpos = (long)new_subpos & 65535; - } else { - /* FIR resampling, backwards */ - SRCTYPE *x; - if ( resampler->fir_resampler_ratio != delta ) { - resampler_set_rate( resampler->fir_resampler[0], delta ); - resampler_set_rate( resampler->fir_resampler[1], delta ); - resampler->fir_resampler_ratio = delta; - } - x = &src[pos*SRC_CHANNELS]; - while ( todo ) { - while ( ( resampler_get_free_count( resampler->fir_resampler[0] ) || - (!resampler_get_sample_count( resampler->fir_resampler[0] ) + { + SRCTYPE *src = resampler->src; + long pos = resampler->pos; + int subpos = resampler->subpos; + long diff = pos; + long overshot; + if (resampler->dir < 0) { + if (!dst) { + /* Silence or simulation */ + LONG_LONG new_subpos = subpos + (LONG_LONG)dt * todo; + pos += (long)(new_subpos >> 16); + subpos = (long)new_subpos & 65535; + } else { + /* FIR resampling, backwards */ + SRCTYPE *x; + if (resampler->fir_resampler_ratio != delta) { + resampler_set_rate(resampler->fir_resampler[0], delta); + resampler_set_rate(resampler->fir_resampler[1], delta); + resampler->fir_resampler_ratio = delta; + } + x = &src[pos * SRC_CHANNELS]; + while (todo) { + while ((resampler_get_free_count( + resampler->fir_resampler[0]) || + (!resampler_get_sample_count( + resampler->fir_resampler[0]) #if SRC_CHANNELS == 2 - && !resampler_get_sample_count( resampler->fir_resampler[1] ) + && !resampler_get_sample_count( + resampler->fir_resampler[1]) #endif - ) ) && pos >= resampler->start ) - { - POKE_FIR(0); - pos--; - x -= SRC_CHANNELS; - } - if ( !resampler_get_sample_count( resampler->fir_resampler[0] ) ) break; - MIX_FIR; - ADVANCE_FIR; - --todo; - } - done -= todo; - } - diff = diff - pos; - overshot = resampler->start - pos - 1; - if (diff >= 3) { - COPYSRC2(resampler->X, 0, overshot < 3, src, pos+3); - COPYSRC2(resampler->X, 1, overshot < 2, src, pos+2); - COPYSRC2(resampler->X, 2, overshot < 1, src, pos+1); - } else if (diff >= 2) { - COPYSRC(resampler->X, 0, resampler->X, 2); - COPYSRC2(resampler->X, 1, overshot < 2, src, pos+2); - COPYSRC2(resampler->X, 2, overshot < 1, src, pos+1); - } else if (diff >= 1) { - COPYSRC(resampler->X, 0, resampler->X, 1); - COPYSRC(resampler->X, 1, resampler->X, 2); - COPYSRC2(resampler->X, 2, overshot < 1, src, pos+1); - } - } else { - if (!dst) { - /* Silence or simulation */ - LONG_LONG new_subpos = subpos + (LONG_LONG)dt * todo; - pos += (long)(new_subpos >> 16); - subpos = (long)new_subpos & 65535; - } else { - /* FIR resampling, forwards */ - SRCTYPE *x; - if ( resampler->fir_resampler_ratio != delta ) { - resampler_set_rate( resampler->fir_resampler[0], delta ); - resampler_set_rate( resampler->fir_resampler[1], delta ); - resampler->fir_resampler_ratio = delta; - } - x = &src[pos*SRC_CHANNELS]; - while ( todo ) { - while ( ( resampler_get_free_count( resampler->fir_resampler[0] ) || - (!resampler_get_sample_count( resampler->fir_resampler[0] ) + )) && + pos >= resampler->start) { + POKE_FIR(0); + pos--; + x -= SRC_CHANNELS; + } + if (!resampler_get_sample_count( + resampler->fir_resampler[0])) + break; + MIX_FIR; + ADVANCE_FIR; + --todo; + } + done -= todo; + } + diff = diff - pos; + overshot = resampler->start - pos - 1; + if (diff >= 3) { + COPYSRC2(resampler->X, 0, overshot < 3, src, pos + 3); + COPYSRC2(resampler->X, 1, overshot < 2, src, pos + 2); + COPYSRC2(resampler->X, 2, overshot < 1, src, pos + 1); + } else if (diff >= 2) { + COPYSRC(resampler->X, 0, resampler->X, 2); + COPYSRC2(resampler->X, 1, overshot < 2, src, pos + 2); + COPYSRC2(resampler->X, 2, overshot < 1, src, pos + 1); + } else if (diff >= 1) { + COPYSRC(resampler->X, 0, resampler->X, 1); + COPYSRC(resampler->X, 1, resampler->X, 2); + COPYSRC2(resampler->X, 2, overshot < 1, src, pos + 1); + } + } else { + if (!dst) { + /* Silence or simulation */ + LONG_LONG new_subpos = subpos + (LONG_LONG)dt * todo; + pos += (long)(new_subpos >> 16); + subpos = (long)new_subpos & 65535; + } else { + /* FIR resampling, forwards */ + SRCTYPE *x; + if (resampler->fir_resampler_ratio != delta) { + resampler_set_rate(resampler->fir_resampler[0], delta); + resampler_set_rate(resampler->fir_resampler[1], delta); + resampler->fir_resampler_ratio = delta; + } + x = &src[pos * SRC_CHANNELS]; + while (todo) { + while ((resampler_get_free_count( + resampler->fir_resampler[0]) || + (!resampler_get_sample_count( + resampler->fir_resampler[0]) #if SRC_CHANNELS == 2 - && !resampler_get_sample_count( resampler->fir_resampler[1] ) + && !resampler_get_sample_count( + resampler->fir_resampler[1]) #endif - ) ) && pos < resampler->end ) - { - POKE_FIR(0); - pos++; - x += SRC_CHANNELS; - } - if ( !resampler_get_sample_count( resampler->fir_resampler[0] ) ) break; - MIX_FIR; - ADVANCE_FIR; - --todo; - } - done -= todo; - } - diff = pos - diff; - overshot = pos - resampler->end; - if (diff >= 3) { - COPYSRC2(resampler->X, 0, overshot < 3, src, pos-3); - COPYSRC2(resampler->X, 1, overshot < 2, src, pos-2); - COPYSRC2(resampler->X, 2, overshot < 1, src, pos-1); - } else if (diff >= 2) { - COPYSRC(resampler->X, 0, resampler->X, 2); - COPYSRC2(resampler->X, 1, overshot < 2, src, pos-2); - COPYSRC2(resampler->X, 2, overshot < 1, src, pos-1); - } else if (diff >= 1) { - COPYSRC(resampler->X, 0, resampler->X, 1); - COPYSRC(resampler->X, 1, resampler->X, 2); - COPYSRC2(resampler->X, 2, overshot < 1, src, pos-1); - } - } - resampler->pos = pos; - resampler->subpos = subpos; - } - } + )) && + pos < resampler->end) { + POKE_FIR(0); + pos++; + x += SRC_CHANNELS; + } + if (!resampler_get_sample_count( + resampler->fir_resampler[0])) + break; + MIX_FIR; + ADVANCE_FIR; + --todo; + } + done -= todo; + } + diff = pos - diff; + overshot = pos - resampler->end; + if (diff >= 3) { + COPYSRC2(resampler->X, 0, overshot < 3, src, pos - 3); + COPYSRC2(resampler->X, 1, overshot < 2, src, pos - 2); + COPYSRC2(resampler->X, 2, overshot < 1, src, pos - 1); + } else if (diff >= 2) { + COPYSRC(resampler->X, 0, resampler->X, 2); + COPYSRC2(resampler->X, 1, overshot < 2, src, pos - 2); + COPYSRC2(resampler->X, 2, overshot < 1, src, pos - 1); + } else if (diff >= 1) { + COPYSRC(resampler->X, 0, resampler->X, 1); + COPYSRC(resampler->X, 1, resampler->X, 2); + COPYSRC2(resampler->X, 2, overshot < 1, src, pos - 1); + } + } + resampler->pos = pos; + resampler->subpos = subpos; + } + } - RETURN_VOLUME_VARIABLES; - return done; + RETURN_VOLUME_VARIABLES; + return done; } +void dumb_resample_get_current_sample(DUMB_RESAMPLER *resampler, + VOLUME_PARAMETERS, sample_t *dst) { + float VOLUME_VARIABLES; + SRCTYPE *src; + long pos; + int subpos; + int quality; + SRCTYPE *x; + if (!resampler || resampler->dir == 0) { + MIX_ZEROS(=); + return; + } + ASSERT(resampler->dir == -1 || resampler->dir == 1); -void dumb_resample_get_current_sample(DUMB_RESAMPLER *resampler, VOLUME_PARAMETERS, sample_t *dst) -{ - float VOLUME_VARIABLES; - SRCTYPE *src; - long pos; - int subpos; - int quality; - SRCTYPE *x; + if (process_pickup(resampler)) { + MIX_ZEROS(=); + return; + } - if (!resampler || resampler->dir == 0) { MIX_ZEROS(=); return; } - ASSERT(resampler->dir == -1 || resampler->dir == 1); + SET_VOLUME_VARIABLES; - if (process_pickup(resampler)) { MIX_ZEROS(=); return; } + if (VOLUMES_ARE_ZERO) { + MIX_ZEROS(=); + return; + } - SET_VOLUME_VARIABLES; + _dumb_init_cubic(); - if (VOLUMES_ARE_ZERO) { MIX_ZEROS(=); return; } + quality = resampler->quality; - _dumb_init_cubic(); + src = resampler->src; + pos = resampler->pos; + subpos = resampler->subpos; + x = resampler->X; - quality = resampler->quality; - - src = resampler->src; - pos = resampler->pos; - subpos = resampler->subpos; - x = resampler->X; - - if (resampler->dir < 0) { - HEAVYASSERT(pos >= resampler->start); - /* FIR resampling, backwards */ - PEEK_FIR; - } else { - HEAVYASSERT(pos < resampler->end); - /* FIR resampling, forwards */ - PEEK_FIR; - } + if (resampler->dir < 0) { + HEAVYASSERT(pos >= resampler->start); + /* FIR resampling, backwards */ + PEEK_FIR; + } else { + HEAVYASSERT(pos < resampler->end); + /* FIR resampling, forwards */ + PEEK_FIR; + } } - - #undef MIX_ZEROS #undef MIX_FIR #undef PEEK_FIR diff --git a/Frameworks/Dumb/dumb/src/helpers/resample.c b/Frameworks/Dumb/dumb/src/helpers/resample.c index 7a7bfacb0..b26c9a142 100644 --- a/Frameworks/Dumb/dumb/src/helpers/resample.c +++ b/Frameworks/Dumb/dumb/src/helpers/resample.c @@ -43,11 +43,8 @@ */ #include -#include "dumb.h" - #include "internal/resampler.h" - - +#include "internal/dumb.h" /* Compile with -DHEAVYDEBUG if you want to make sure the pick-up function is * called when it should be. There will be a considerable performance hit, @@ -59,15 +56,12 @@ #define HEAVYASSERT(cond) #endif - - -/* Make MSVC shut the hell up about if ( upd ) UPDATE_VOLUME() conditions being constant */ +/* Make MSVC shut the hell up about if ( upd ) UPDATE_VOLUME() conditions being + * constant */ #ifdef _MSC_VER -#pragma warning(disable:4127 4701) +#pragma warning(disable : 4127 4701) #endif - - /* A global variable for controlling resampling quality wherever a local * specification doesn't override it. The following values are valid: * @@ -83,68 +77,60 @@ */ int dumb_resampling_quality = DUMB_RQ_CUBIC; - - //#define MULSC(a, b) ((int)((LONG_LONG)(a) * (b) >> 16)) //#define MULSC(a, b) ((a) * ((b) >> 2) >> 14) #define MULSCV(a, b) ((int)((LONG_LONG)(a) * (b) >> 32)) #define MULSC(a, b) ((int)((LONG_LONG)((a) << 4) * ((b) << 12) >> 32)) #define MULSC16(a, b) ((int)((LONG_LONG)((a) << 12) * ((b) << 12) >> 32)) - - /* Executes the content 'iterator' times. * Clobbers the 'iterator' variable. * The loop is unrolled by four. */ #if 0 -#define LOOP4(iterator, CONTENT) \ -{ \ - if ((iterator) & 2) { \ - CONTENT; \ - CONTENT; \ - } \ - if ((iterator) & 1) { \ - CONTENT; \ - } \ - (iterator) >>= 2; \ - while (iterator) { \ - CONTENT; \ - CONTENT; \ - CONTENT; \ - CONTENT; \ - (iterator)--; \ - } \ -} +#define LOOP4(iterator, CONTENT) \ + { \ + if ((iterator)&2) { \ + CONTENT; \ + CONTENT; \ + } \ + if ((iterator)&1) { \ + CONTENT; \ + } \ + (iterator) >>= 2; \ + while (iterator) { \ + CONTENT; \ + CONTENT; \ + CONTENT; \ + CONTENT; \ + (iterator)--; \ + } \ + } #else -#define LOOP4(iterator, CONTENT) \ -{ \ - while ( (iterator)-- ) \ - { \ - CONTENT; \ - } \ -} +#define LOOP4(iterator, CONTENT) \ + { \ + while ((iterator)--) { \ + CONTENT; \ + } \ + } #endif -#define PASTERAW(a, b) a ## b /* This does not expand macros in b ... */ -#define PASTE(a, b) PASTERAW(a, b) /* ... but b is expanded during this substitution. */ +#define PASTERAW(a, b) a##b /* This does not expand macros in b ... */ +#define PASTE(a, b) \ + PASTERAW(a, b) /* ... but b is expanded during this substitution. */ #define X PASTE(x.x, SRCBITS) +void _dumb_init_cubic(void) { + static int done = 0; + if (done) + return; + resampler_init(); -void _dumb_init_cubic(void) -{ - static int done = 0; - if (done) return; - - resampler_init(); - - done = 1; + done = 1; } - - /* Create resamplers for 24-in-32-bit source samples. */ /* #define SUFFIX @@ -154,7 +140,8 @@ void _dumb_init_cubic(void) */ #define process_pickup PASTE(process_pickup, SUFFIX2) #define dumb_resample PASTE(PASTE(dumb_resample, SUFFIX2), SUFFIX3) -#define dumb_resample_get_current_sample PASTE(PASTE(dumb_resample_get_current_sample, SUFFIX2), SUFFIX3) +#define dumb_resample_get_current_sample \ + PASTE(PASTE(dumb_resample_get_current_sample, SUFFIX2), SUFFIX3) #define SRCTYPE sample_t #define SRCBITS 24 @@ -166,13 +153,15 @@ void _dumb_init_cubic(void) #undef dumb_resample #undef process_pickup - /* Now define the proper ones that use SUFFIX. */ #define dumb_reset_resampler PASTE(dumb_reset_resampler, SUFFIX) #define dumb_start_resampler PASTE(dumb_start_resampler, SUFFIX) #define process_pickup PASTE(PASTE(process_pickup, SUFFIX), SUFFIX2) -#define dumb_resample PASTE(PASTE(PASTE(dumb_resample, SUFFIX), SUFFIX2), SUFFIX3) -#define dumb_resample_get_current_sample PASTE(PASTE(PASTE(dumb_resample_get_current_sample, SUFFIX), SUFFIX2), SUFFIX3) +#define dumb_resample \ + PASTE(PASTE(PASTE(dumb_resample, SUFFIX), SUFFIX2), SUFFIX3) +#define dumb_resample_get_current_sample \ + PASTE(PASTE(PASTE(dumb_resample_get_current_sample, SUFFIX), SUFFIX2), \ + SUFFIX3) #define dumb_end_resampler PASTE(dumb_end_resampler, SUFFIX) /* Create resamplers for 16-bit source samples. */ @@ -189,7 +178,6 @@ void _dumb_init_cubic(void) #define FIR(x) (x * (1.0f / 256.0f)) #include "resample.inc" - #undef dumb_reset_resampler #undef dumb_start_resampler #undef process_pickup @@ -197,134 +185,148 @@ void _dumb_init_cubic(void) #undef dumb_resample_get_current_sample #undef dumb_end_resampler - - -void dumb_reset_resampler_n(int n, DUMB_RESAMPLER *resampler, void *src, int src_channels, long pos, long start, long end, int quality) -{ - if (n == 8) - dumb_reset_resampler_8(resampler, src, src_channels, pos, start, end, quality); - else if (n == 16) - dumb_reset_resampler_16(resampler, src, src_channels, pos, start, end, quality); - else - dumb_reset_resampler(resampler, src, src_channels, pos, start, end, quality); +void dumb_reset_resampler_n(int n, DUMB_RESAMPLER *resampler, void *src, + int src_channels, long pos, long start, long end, + int quality) { + if (n == 8) + dumb_reset_resampler_8(resampler, src, src_channels, pos, start, end, + quality); + else if (n == 16) + dumb_reset_resampler_16(resampler, src, src_channels, pos, start, end, + quality); + else + dumb_reset_resampler(resampler, src, src_channels, pos, start, end, + quality); } - - -DUMB_RESAMPLER *dumb_start_resampler_n(int n, void *src, int src_channels, long pos, long start, long end, int quality) -{ - if (n == 8) - return dumb_start_resampler_8(src, src_channels, pos, start, end, quality); - else if (n == 16) - return dumb_start_resampler_16(src, src_channels, pos, start, end, quality); - else - return dumb_start_resampler(src, src_channels, pos, start, end, quality); +DUMB_RESAMPLER *dumb_start_resampler_n(int n, void *src, int src_channels, + long pos, long start, long end, + int quality) { + if (n == 8) + return dumb_start_resampler_8(src, src_channels, pos, start, end, + quality); + else if (n == 16) + return dumb_start_resampler_16(src, src_channels, pos, start, end, + quality); + else + return dumb_start_resampler(src, src_channels, pos, start, end, + quality); } - - -long dumb_resample_n_1_1(int n, DUMB_RESAMPLER *resampler, sample_t *dst, long dst_size, DUMB_VOLUME_RAMP_INFO * volume, float delta) -{ - if (n == 8) - return dumb_resample_8_1_1(resampler, dst, dst_size, volume, delta); - else if (n == 16) - return dumb_resample_16_1_1(resampler, dst, dst_size, volume, delta); - else - return dumb_resample_1_1(resampler, dst, dst_size, volume, delta); +long dumb_resample_n_1_1(int n, DUMB_RESAMPLER *resampler, sample_t *dst, + long dst_size, DUMB_VOLUME_RAMP_INFO *volume, + float delta) { + if (n == 8) + return dumb_resample_8_1_1(resampler, dst, dst_size, volume, delta); + else if (n == 16) + return dumb_resample_16_1_1(resampler, dst, dst_size, volume, delta); + else + return dumb_resample_1_1(resampler, dst, dst_size, volume, delta); } - - -long dumb_resample_n_1_2(int n, DUMB_RESAMPLER *resampler, sample_t *dst, long dst_size, DUMB_VOLUME_RAMP_INFO * volume_left, DUMB_VOLUME_RAMP_INFO * volume_right, float delta) -{ - if (n == 8) - return dumb_resample_8_1_2(resampler, dst, dst_size, volume_left, volume_right, delta); - else if (n == 16) - return dumb_resample_16_1_2(resampler, dst, dst_size, volume_left, volume_right, delta); - else - return dumb_resample_1_2(resampler, dst, dst_size, volume_left, volume_right, delta); +long dumb_resample_n_1_2(int n, DUMB_RESAMPLER *resampler, sample_t *dst, + long dst_size, DUMB_VOLUME_RAMP_INFO *volume_left, + DUMB_VOLUME_RAMP_INFO *volume_right, float delta) { + if (n == 8) + return dumb_resample_8_1_2(resampler, dst, dst_size, volume_left, + volume_right, delta); + else if (n == 16) + return dumb_resample_16_1_2(resampler, dst, dst_size, volume_left, + volume_right, delta); + else + return dumb_resample_1_2(resampler, dst, dst_size, volume_left, + volume_right, delta); } - - -long dumb_resample_n_2_1(int n, DUMB_RESAMPLER *resampler, sample_t *dst, long dst_size, DUMB_VOLUME_RAMP_INFO * volume_left, DUMB_VOLUME_RAMP_INFO * volume_right, float delta) -{ - if (n == 8) - return dumb_resample_8_2_1(resampler, dst, dst_size, volume_left, volume_right, delta); - else if (n == 16) - return dumb_resample_16_2_1(resampler, dst, dst_size, volume_left, volume_right, delta); - else - return dumb_resample_2_1(resampler, dst, dst_size, volume_left, volume_right, delta); +long dumb_resample_n_2_1(int n, DUMB_RESAMPLER *resampler, sample_t *dst, + long dst_size, DUMB_VOLUME_RAMP_INFO *volume_left, + DUMB_VOLUME_RAMP_INFO *volume_right, float delta) { + if (n == 8) + return dumb_resample_8_2_1(resampler, dst, dst_size, volume_left, + volume_right, delta); + else if (n == 16) + return dumb_resample_16_2_1(resampler, dst, dst_size, volume_left, + volume_right, delta); + else + return dumb_resample_2_1(resampler, dst, dst_size, volume_left, + volume_right, delta); } - - -long dumb_resample_n_2_2(int n, DUMB_RESAMPLER *resampler, sample_t *dst, long dst_size, DUMB_VOLUME_RAMP_INFO * volume_left, DUMB_VOLUME_RAMP_INFO * volume_right, float delta) -{ - if (n == 8) - return dumb_resample_8_2_2(resampler, dst, dst_size, volume_left, volume_right, delta); - else if (n == 16) - return dumb_resample_16_2_2(resampler, dst, dst_size, volume_left, volume_right, delta); - else - return dumb_resample_2_2(resampler, dst, dst_size, volume_left, volume_right, delta); +long dumb_resample_n_2_2(int n, DUMB_RESAMPLER *resampler, sample_t *dst, + long dst_size, DUMB_VOLUME_RAMP_INFO *volume_left, + DUMB_VOLUME_RAMP_INFO *volume_right, float delta) { + if (n == 8) + return dumb_resample_8_2_2(resampler, dst, dst_size, volume_left, + volume_right, delta); + else if (n == 16) + return dumb_resample_16_2_2(resampler, dst, dst_size, volume_left, + volume_right, delta); + else + return dumb_resample_2_2(resampler, dst, dst_size, volume_left, + volume_right, delta); } - - -void dumb_resample_get_current_sample_n_1_1(int n, DUMB_RESAMPLER *resampler, DUMB_VOLUME_RAMP_INFO * volume, sample_t *dst) -{ - if (n == 8) - dumb_resample_get_current_sample_8_1_1(resampler, volume, dst); - else if (n == 16) - dumb_resample_get_current_sample_16_1_1(resampler, volume, dst); - else - dumb_resample_get_current_sample_1_1(resampler, volume, dst); +void dumb_resample_get_current_sample_n_1_1(int n, DUMB_RESAMPLER *resampler, + DUMB_VOLUME_RAMP_INFO *volume, + sample_t *dst) { + if (n == 8) + dumb_resample_get_current_sample_8_1_1(resampler, volume, dst); + else if (n == 16) + dumb_resample_get_current_sample_16_1_1(resampler, volume, dst); + else + dumb_resample_get_current_sample_1_1(resampler, volume, dst); } - - -void dumb_resample_get_current_sample_n_1_2(int n, DUMB_RESAMPLER *resampler, DUMB_VOLUME_RAMP_INFO * volume_left, DUMB_VOLUME_RAMP_INFO * volume_right, sample_t *dst) -{ - if (n == 8) - dumb_resample_get_current_sample_8_1_2(resampler, volume_left, volume_right, dst); - else if (n == 16) - dumb_resample_get_current_sample_16_1_2(resampler, volume_left, volume_right, dst); - else - dumb_resample_get_current_sample_1_2(resampler, volume_left, volume_right, dst); +void dumb_resample_get_current_sample_n_1_2(int n, DUMB_RESAMPLER *resampler, + DUMB_VOLUME_RAMP_INFO *volume_left, + DUMB_VOLUME_RAMP_INFO *volume_right, + sample_t *dst) { + if (n == 8) + dumb_resample_get_current_sample_8_1_2(resampler, volume_left, + volume_right, dst); + else if (n == 16) + dumb_resample_get_current_sample_16_1_2(resampler, volume_left, + volume_right, dst); + else + dumb_resample_get_current_sample_1_2(resampler, volume_left, + volume_right, dst); } - - -void dumb_resample_get_current_sample_n_2_1(int n, DUMB_RESAMPLER *resampler, DUMB_VOLUME_RAMP_INFO * volume_left, DUMB_VOLUME_RAMP_INFO * volume_right, sample_t *dst) -{ - if (n == 8) - dumb_resample_get_current_sample_8_2_1(resampler, volume_left, volume_right, dst); - else if (n == 16) - dumb_resample_get_current_sample_16_2_1(resampler, volume_left, volume_right, dst); - else - dumb_resample_get_current_sample_2_1(resampler, volume_left, volume_right, dst); +void dumb_resample_get_current_sample_n_2_1(int n, DUMB_RESAMPLER *resampler, + DUMB_VOLUME_RAMP_INFO *volume_left, + DUMB_VOLUME_RAMP_INFO *volume_right, + sample_t *dst) { + if (n == 8) + dumb_resample_get_current_sample_8_2_1(resampler, volume_left, + volume_right, dst); + else if (n == 16) + dumb_resample_get_current_sample_16_2_1(resampler, volume_left, + volume_right, dst); + else + dumb_resample_get_current_sample_2_1(resampler, volume_left, + volume_right, dst); } - - -void dumb_resample_get_current_sample_n_2_2(int n, DUMB_RESAMPLER *resampler, DUMB_VOLUME_RAMP_INFO * volume_left, DUMB_VOLUME_RAMP_INFO * volume_right, sample_t *dst) -{ - if (n == 8) - dumb_resample_get_current_sample_8_2_2(resampler, volume_left, volume_right, dst); - else if (n == 16) - dumb_resample_get_current_sample_16_2_2(resampler, volume_left, volume_right, dst); - else - dumb_resample_get_current_sample_2_2(resampler, volume_left, volume_right, dst); +void dumb_resample_get_current_sample_n_2_2(int n, DUMB_RESAMPLER *resampler, + DUMB_VOLUME_RAMP_INFO *volume_left, + DUMB_VOLUME_RAMP_INFO *volume_right, + sample_t *dst) { + if (n == 8) + dumb_resample_get_current_sample_8_2_2(resampler, volume_left, + volume_right, dst); + else if (n == 16) + dumb_resample_get_current_sample_16_2_2(resampler, volume_left, + volume_right, dst); + else + dumb_resample_get_current_sample_2_2(resampler, volume_left, + volume_right, dst); } - - -void dumb_end_resampler_n(int n, DUMB_RESAMPLER *resampler) -{ - if (n == 8) - dumb_end_resampler_8(resampler); - else if (n == 16) - dumb_end_resampler_16(resampler); - else - dumb_end_resampler(resampler); +void dumb_end_resampler_n(int n, DUMB_RESAMPLER *resampler) { + if (n == 8) + dumb_end_resampler_8(resampler); + else if (n == 16) + dumb_end_resampler_16(resampler); + else + dumb_end_resampler(resampler); } diff --git a/Frameworks/Dumb/dumb/src/helpers/resample.inc b/Frameworks/Dumb/dumb/src/helpers/resample.inc index fa63e843f..4723b6ad7 100644 --- a/Frameworks/Dumb/dumb/src/helpers/resample.inc +++ b/Frameworks/Dumb/dumb/src/helpers/resample.inc @@ -42,214 +42,246 @@ * FIXME: these comments are somewhat out of date now. */ - - -void dumb_reset_resampler(DUMB_RESAMPLER *resampler, SRCTYPE *src, int src_channels, long pos, long start, long end, int quality) -{ - int i; - resampler->src = src; - resampler->pos = pos; - resampler->subpos = 0; - resampler->start = start; - resampler->end = end; - resampler->dir = 1; - resampler->pickup = NULL; - resampler->pickup_data = NULL; - if (quality < 0) - { - resampler->quality = 0; - } - else if (quality > DUMB_RQ_N_LEVELS - 1) - { - resampler->quality = DUMB_RQ_N_LEVELS - 1; - } - else - { - resampler->quality = quality; - } - for (i = 0; i < src_channels*3; i++) resampler->X[i] = 0; - resampler->overshot = -1; - resampler->fir_resampler_ratio = 0; - resampler_clear(resampler->fir_resampler[0]); - resampler_clear(resampler->fir_resampler[1]); - resampler_set_quality(resampler->fir_resampler[0], resampler->quality); - resampler_set_quality(resampler->fir_resampler[1], resampler->quality); +void dumb_reset_resampler(DUMB_RESAMPLER *resampler, SRCTYPE *src, + int src_channels, long pos, long start, long end, + int quality) { + int i; + resampler->src = src; + resampler->pos = pos; + resampler->subpos = 0; + resampler->start = start; + resampler->end = end; + resampler->dir = 1; + resampler->pickup = NULL; + resampler->pickup_data = NULL; + if (quality < 0) { + resampler->quality = 0; + } else if (quality > DUMB_RQ_N_LEVELS - 1) { + resampler->quality = DUMB_RQ_N_LEVELS - 1; + } else { + resampler->quality = quality; + } + for (i = 0; i < src_channels * 3; i++) + resampler->X[i] = 0; + resampler->overshot = -1; + resampler->fir_resampler_ratio = 0; + resampler_clear(resampler->fir_resampler[0]); + resampler_clear(resampler->fir_resampler[1]); + resampler_set_quality(resampler->fir_resampler[0], resampler->quality); + resampler_set_quality(resampler->fir_resampler[1], resampler->quality); } - - -DUMB_RESAMPLER *dumb_start_resampler(SRCTYPE *src, int src_channels, long pos, long start, long end, int quality) -{ - DUMB_RESAMPLER *resampler = malloc(sizeof(*resampler)); - if (!resampler) return NULL; - dumb_reset_resampler(resampler, src, src_channels, pos, start, end, quality); - return resampler; +DUMB_RESAMPLER *dumb_start_resampler(SRCTYPE *src, int src_channels, long pos, + long start, long end, int quality) { + DUMB_RESAMPLER *resampler = malloc(sizeof(*resampler)); + if (!resampler) + return NULL; + dumb_reset_resampler(resampler, src, src_channels, pos, start, end, + quality); + return resampler; } - - -#define UPDATE_VOLUME( pvol, vol ) { \ - if (pvol) { \ - vol##r += vol##d; \ - if ((vol##d < 0 && vol##r <= vol##t) || \ - (vol##d > 0 && vol##r >= vol##t)) { \ - pvol->volume = pvol->target; \ - if ( pvol->declick_stage == 0 || \ - pvol->declick_stage >= 3) \ - pvol->declick_stage++; \ - pvol = NULL; \ - vol = vol##t * vol##m; \ - } else { \ - vol = vol##r * vol##m; \ - } \ - } \ -} - - +#define UPDATE_VOLUME(pvol, vol) \ + { \ + if (pvol) { \ + vol##r += vol##d; \ + if ((vol##d < 0 && vol##r <= vol##t) || \ + (vol##d > 0 && vol##r >= vol##t)) { \ + pvol->volume = pvol->target; \ + if (pvol->declick_stage == 0 || pvol->declick_stage >= 3) \ + pvol->declick_stage++; \ + pvol = NULL; \ + vol = vol##t * vol##m; \ + } else { \ + vol = vol##r * vol##m; \ + } \ + } \ + } /* Create mono source resampler. */ #define SUFFIX2 _1 #define SRC_CHANNELS 1 #define DIVIDE_BY_SRC_CHANNELS(x) (x) -#define COPYSRC(dstarray, dstindex, srcarray, srcindex) (dstarray)[dstindex] = (srcarray)[srcindex] -#define COPYSRC2(dstarray, dstindex, condition, srcarray, srcindex) (dstarray)[dstindex] = condition ? (srcarray)[srcindex] : 0 -#define MONO_DEST_VOLUME_PARAMETERS DUMB_VOLUME_RAMP_INFO * volume +#define COPYSRC(dstarray, dstindex, srcarray, srcindex) \ + (dstarray)[dstindex] = (srcarray)[srcindex] +#define COPYSRC2(dstarray, dstindex, condition, srcarray, srcindex) \ + (dstarray)[dstindex] = condition ? (srcarray)[srcindex] : 0 +#define MONO_DEST_VOLUME_PARAMETERS DUMB_VOLUME_RAMP_INFO *volume #define MONO_DEST_VOLUME_VARIABLES vol, volr, vold, volt, volm #define MONO_DEST_VOLUME_ZEROS 0 -#define SET_MONO_DEST_VOLUME_VARIABLES { \ - if ( volume ) { \ - volr = volume->volume; \ - vold = volume->delta; \ - volt = volume->target; \ - volm = volume->mix; \ - vol = volr * volm; \ - if ( volr == volt ) volume = NULL; \ - } else { \ - vol = 0; \ - vold = 0; \ - volt = 0; \ - volm = 0; \ - } \ -} -#define RETURN_MONO_DEST_VOLUME_VARIABLES if ( volume ) volume->volume = volr +#define SET_MONO_DEST_VOLUME_VARIABLES \ + { \ + if (volume) { \ + volr = volume->volume; \ + vold = volume->delta; \ + volt = volume->target; \ + volm = volume->mix; \ + vol = volr * volm; \ + if (volr == volt) \ + volume = NULL; \ + } else { \ + vol = 0; \ + volr = 0; \ + vold = 0; \ + volt = 0; \ + volm = 0; \ + } \ + } +#define RETURN_MONO_DEST_VOLUME_VARIABLES \ + if (volume) \ + volume->volume = volr #define MONO_DEST_VOLUMES_ARE_ZERO (vol == 0 && volt == 0) -#define POKE_FIR(offset) { \ - resampler_write_sample_float( resampler->fir_resampler[0], FIR(x[offset]) ); \ -} -#define MONO_DEST_PEEK_FIR *dst = resampler_get_sample_float( resampler->fir_resampler[0] ) * vol * 16777216.0f -#define MONO_DEST_MIX_FIR { \ - *dst++ += resampler_get_sample_float( resampler->fir_resampler[0] ) * vol * 16777216.0f; \ - UPDATE_VOLUME( volume, vol ); \ -} -#define ADVANCE_FIR resampler_remove_sample( resampler->fir_resampler[0], 1 ) -#define STEREO_DEST_PEEK_FIR { \ - float sample = resampler_get_sample_float( resampler->fir_resampler[0] ); \ - *dst++ = sample * lvol * 16777216.0f; \ - *dst++ = sample * rvol * 16777216.0f; \ -} -#define STEREO_DEST_MIX_FIR { \ - float sample = resampler_get_sample_float( resampler->fir_resampler[0] ); \ - *dst++ += sample * lvol * 16777216.0f; \ - *dst++ += sample * rvol * 16777216.0f; \ - UPDATE_VOLUME( volume_left, lvol ); \ - UPDATE_VOLUME( volume_right, rvol ); \ -} +#define POKE_FIR(offset) \ + { \ + resampler_write_sample_float(resampler->fir_resampler[0], \ + FIR(x[offset])); \ + } +#define MONO_DEST_PEEK_FIR \ + *dst = resampler_get_sample_float(resampler->fir_resampler[0]) * vol * \ + 16777216.0f +#define MONO_DEST_MIX_FIR \ + { \ + *dst++ += resampler_get_sample_float(resampler->fir_resampler[0]) * \ + vol * 16777216.0f; \ + UPDATE_VOLUME(volume, vol); \ + } +#define ADVANCE_FIR resampler_remove_sample(resampler->fir_resampler[0], 1) +#define STEREO_DEST_PEEK_FIR \ + { \ + float sample = \ + resampler_get_sample_float(resampler->fir_resampler[0]); \ + *dst++ = sample * lvol * 16777216.0f; \ + *dst++ = sample * rvol * 16777216.0f; \ + } +#define STEREO_DEST_MIX_FIR \ + { \ + float sample = \ + resampler_get_sample_float(resampler->fir_resampler[0]); \ + *dst++ += sample * lvol * 16777216.0f; \ + *dst++ += sample * rvol * 16777216.0f; \ + UPDATE_VOLUME(volume_left, lvol); \ + UPDATE_VOLUME(volume_right, rvol); \ + } #include "resamp2.inc" /* Create stereo source resampler. */ #define SUFFIX2 _2 #define SRC_CHANNELS 2 #define DIVIDE_BY_SRC_CHANNELS(x) ((x) >> 1) -#define COPYSRC(dstarray, dstindex, srcarray, srcindex) { \ - (dstarray)[(dstindex)*2] = (srcarray)[(srcindex)*2]; \ - (dstarray)[(dstindex)*2+1] = (srcarray)[(srcindex)*2+1]; \ -} -#define COPYSRC2(dstarray, dstindex, condition, srcarray, srcindex) { \ - if (condition) { \ - (dstarray)[(dstindex)*2] = (srcarray)[(srcindex)*2]; \ - (dstarray)[(dstindex)*2+1] = (srcarray)[(srcindex)*2+1]; \ - } else { \ - (dstarray)[(dstindex)*2] = 0; \ - (dstarray)[(dstindex)*2+1] = 0; \ - } \ -} +#define COPYSRC(dstarray, dstindex, srcarray, srcindex) \ + { \ + (dstarray)[(dstindex)*2] = (srcarray)[(srcindex)*2]; \ + (dstarray)[(dstindex)*2 + 1] = (srcarray)[(srcindex)*2 + 1]; \ + } +#define COPYSRC2(dstarray, dstindex, condition, srcarray, srcindex) \ + { \ + if (condition) { \ + (dstarray)[(dstindex)*2] = (srcarray)[(srcindex)*2]; \ + (dstarray)[(dstindex)*2 + 1] = (srcarray)[(srcindex)*2 + 1]; \ + } else { \ + (dstarray)[(dstindex)*2] = 0; \ + (dstarray)[(dstindex)*2 + 1] = 0; \ + } \ + } -#define MONO_DEST_VOLUME_PARAMETERS DUMB_VOLUME_RAMP_INFO * volume_left, DUMB_VOLUME_RAMP_INFO * volume_right -#define MONO_DEST_VOLUME_VARIABLES lvol, lvolr, lvold, lvolt, lvolm, rvol, rvolr, rvold, rvolt, rvolm +#define MONO_DEST_VOLUME_PARAMETERS \ + DUMB_VOLUME_RAMP_INFO *volume_left, DUMB_VOLUME_RAMP_INFO *volume_right +#define MONO_DEST_VOLUME_VARIABLES \ + lvol, lvolr, lvold, lvolt, lvolm, rvol, rvolr, rvold, rvolt, rvolm #define MONO_DEST_VOLUME_ZEROS 0, 0 -#define SET_MONO_DEST_VOLUME_VARIABLES { \ - if ( volume_left ) { \ - lvolr = volume_left->volume; \ - lvold = volume_left->delta; \ - lvolt = volume_left->target; \ - lvolm = volume_left->mix; \ - lvol = lvolr * lvolm; \ - if ( lvolr == lvolt ) volume_left = NULL; \ - } else { \ - lvol = 0; \ - lvold = 0; \ - lvolt = 0; \ - lvolm = 0; \ - } \ - if ( volume_right ) { \ - rvolr = volume_right->volume; \ - rvold = volume_right->delta; \ - rvolt = volume_right->target; \ - rvolm = volume_right->mix; \ - rvol = rvolr * rvolm; \ - if ( rvolr == rvolt ) volume_right = NULL; \ - } else { \ - rvol = 0; \ - rvold = 0; \ - rvolt = 0; \ - rvolm = 0; \ - } \ -} -#define RETURN_MONO_DEST_VOLUME_VARIABLES { \ - if ( volume_left ) volume_left->volume = lvolr; \ - if ( volume_right ) volume_right->volume = rvolr; \ -} -#define MONO_DEST_VOLUMES_ARE_ZERO (lvol == 0 && lvolt == 0 && rvol == 0 && rvolt == 0) -#define POKE_FIR(offset) { \ - resampler_write_sample_float( resampler->fir_resampler[0], FIR(x[(offset)*2+0]) ); \ - resampler_write_sample_float( resampler->fir_resampler[1], FIR(x[(offset)*2+1]) ); \ -} -#define MONO_DEST_PEEK_FIR { \ - *dst = (resampler_get_sample_float( resampler->fir_resampler[0] ) * lvol + \ - resampler_get_sample_float( resampler->fir_resampler[1] ) * rvol) * 16777216.0f; \ -} -#define MONO_DEST_MIX_FIR { \ - *dst++ += (resampler_get_sample_float( resampler->fir_resampler[0] ) * lvol + \ - resampler_get_sample_float( resampler->fir_resampler[1] ) * rvol) * 16777216.0f; \ - UPDATE_VOLUME( volume_left, lvol ); \ - UPDATE_VOLUME( volume_right, rvol ); \ -} -#define ADVANCE_FIR { \ - resampler_remove_sample( resampler->fir_resampler[0], 1 ); \ - resampler_remove_sample( resampler->fir_resampler[1], 1 ); \ -} -#define STEREO_DEST_PEEK_FIR { \ - *dst++ = resampler_get_sample_float( resampler->fir_resampler[0] ) * lvol * 16777216.0f; \ - *dst++ = resampler_get_sample_float( resampler->fir_resampler[1] ) * rvol * 16777216.0f; \ -} -#define STEREO_DEST_MIX_FIR { \ - *dst++ += resampler_get_sample_float( resampler->fir_resampler[0] ) * lvol * 16777216.0f; \ - *dst++ += resampler_get_sample_float( resampler->fir_resampler[1] ) * rvol * 16777216.0f; \ - UPDATE_VOLUME( volume_left, lvol ); \ - UPDATE_VOLUME( volume_right, rvol ); \ -} +#define SET_MONO_DEST_VOLUME_VARIABLES \ + { \ + if (volume_left) { \ + lvolr = volume_left->volume; \ + lvold = volume_left->delta; \ + lvolt = volume_left->target; \ + lvolm = volume_left->mix; \ + lvol = lvolr * lvolm; \ + if (lvolr == lvolt) \ + volume_left = NULL; \ + } else { \ + lvol = 0; \ + lvolr = 0; \ + lvold = 0; \ + lvolt = 0; \ + lvolm = 0; \ + } \ + if (volume_right) { \ + rvolr = volume_right->volume; \ + rvold = volume_right->delta; \ + rvolt = volume_right->target; \ + rvolm = volume_right->mix; \ + rvol = rvolr * rvolm; \ + if (rvolr == rvolt) \ + volume_right = NULL; \ + } else { \ + rvol = 0; \ + rvolr = 0; \ + rvold = 0; \ + rvolt = 0; \ + rvolm = 0; \ + } \ + } +#define RETURN_MONO_DEST_VOLUME_VARIABLES \ + { \ + if (volume_left) \ + volume_left->volume = lvolr; \ + if (volume_right) \ + volume_right->volume = rvolr; \ + } +#define MONO_DEST_VOLUMES_ARE_ZERO \ + (lvol == 0 && lvolt == 0 && rvol == 0 && rvolt == 0) +#define POKE_FIR(offset) \ + { \ + resampler_write_sample_float(resampler->fir_resampler[0], \ + FIR(x[(offset)*2 + 0])); \ + resampler_write_sample_float(resampler->fir_resampler[1], \ + FIR(x[(offset)*2 + 1])); \ + } +#define MONO_DEST_PEEK_FIR \ + { \ + *dst = \ + (resampler_get_sample_float(resampler->fir_resampler[0]) * lvol + \ + resampler_get_sample_float(resampler->fir_resampler[1]) * rvol) * \ + 16777216.0f; \ + } +#define MONO_DEST_MIX_FIR \ + { \ + *dst++ += \ + (resampler_get_sample_float(resampler->fir_resampler[0]) * lvol + \ + resampler_get_sample_float(resampler->fir_resampler[1]) * rvol) * \ + 16777216.0f; \ + UPDATE_VOLUME(volume_left, lvol); \ + UPDATE_VOLUME(volume_right, rvol); \ + } +#define ADVANCE_FIR \ + { \ + resampler_remove_sample(resampler->fir_resampler[0], 1); \ + resampler_remove_sample(resampler->fir_resampler[1], 1); \ + } +#define STEREO_DEST_PEEK_FIR \ + { \ + *dst++ = resampler_get_sample_float(resampler->fir_resampler[0]) * \ + lvol * 16777216.0f; \ + *dst++ = resampler_get_sample_float(resampler->fir_resampler[1]) * \ + rvol * 16777216.0f; \ + } +#define STEREO_DEST_MIX_FIR \ + { \ + *dst++ += resampler_get_sample_float(resampler->fir_resampler[0]) * \ + lvol * 16777216.0f; \ + *dst++ += resampler_get_sample_float(resampler->fir_resampler[1]) * \ + rvol * 16777216.0f; \ + UPDATE_VOLUME(volume_left, lvol); \ + UPDATE_VOLUME(volume_right, rvol); \ + } #include "resamp2.inc" - - -void dumb_end_resampler(DUMB_RESAMPLER *resampler) -{ - if (resampler) - free(resampler); +void dumb_end_resampler(DUMB_RESAMPLER *resampler) { + if (resampler) + free(resampler); } - - #undef FIR #undef SRCBITS #undef SRCTYPE diff --git a/Frameworks/Dumb/dumb/src/helpers/resampler.c b/Frameworks/Dumb/dumb/src/helpers/resampler.c index 9bbdc51bf..4c69a0ed7 100644 --- a/Frameworks/Dumb/dumb/src/helpers/resampler.c +++ b/Frameworks/Dumb/dumb/src/helpers/resampler.c @@ -2,7 +2,8 @@ #include #define _USE_MATH_DEFINES #include -#if defined(_USE_SSE) && (defined(_M_IX86) || defined(__i386__) || defined(_M_X64) || defined(__amd64__)) +#if defined(_USE_SSE) && (defined(_M_IX86) || defined(__i386__) || \ + defined(_M_X64) || defined(__amd64__)) #include #define RESAMPLER_SSE #endif @@ -19,9 +20,9 @@ #endif #ifdef _MSC_VER -#define ALIGNED _declspec(align(16)) +#define ALIGNED _declspec(align(16)) #else -#define ALIGNED __attribute__((aligned(16))) +#define ALIGNED __attribute__((aligned(16))) #endif #ifndef M_PI @@ -33,7 +34,9 @@ enum { RESAMPLER_SHIFT = 10 }; enum { RESAMPLER_SHIFT_EXTRA = 8 }; enum { RESAMPLER_RESOLUTION = 1 << RESAMPLER_SHIFT }; -enum { RESAMPLER_RESOLUTION_EXTRA = 1 << (RESAMPLER_SHIFT + RESAMPLER_SHIFT_EXTRA) }; +enum { + RESAMPLER_RESOLUTION_EXTRA = 1 << (RESAMPLER_SHIFT + RESAMPLER_SHIFT_EXTRA) +}; enum { SINC_WIDTH = 16 }; enum { SINC_SAMPLES = RESAMPLER_RESOLUTION * SINC_WIDTH }; enum { CUBIC_SAMPLES = RESAMPLER_RESOLUTION * 4 }; @@ -49,13 +52,9 @@ static float window_lut[SINC_SAMPLES + 1]; enum { resampler_buffer_size = SINC_WIDTH * 4 }; -static int fEqual(const float b, const float a) -{ - return fabs(a - b) < 1.0e-6; -} +static int fEqual(const float b, const float a) { return fabs(a - b) < 1.0e-6; } -static float sinc(float x) -{ +static float sinc(float x) { return fEqual(x, 0.0) ? 1.0 : sin(x * M_PI) / (x * M_PI); } @@ -63,62 +62,52 @@ static float sinc(float x) #ifdef _MSC_VER #include #elif defined(__clang__) || defined(__GNUC__) -static inline void -__cpuid(int *data, int selector) -{ +static inline void __cpuid(int *data, int selector) { #if defined(__PIC__) && defined(__i386__) - asm("xchgl %%ebx, %%esi; cpuid; xchgl %%ebx, %%esi" - : "=a" (data[0]), - "=S" (data[1]), - "=c" (data[2]), - "=d" (data[3]) - : "0" (selector)); + __asm("xchgl %%ebx, %%esi; cpuid; xchgl %%ebx, %%esi" + : "=a"(data[0]), "=S"(data[1]), "=c"(data[2]), "=d"(data[3]) + : "0"(selector)); #elif defined(__PIC__) && defined(__amd64__) - asm("xchg{q} {%%}rbx, %q1; cpuid; xchg{q} {%%}rbx, %q1" - : "=a" (data[0]), - "=&r" (data[1]), - "=c" (data[2]), - "=d" (data[3]) - : "0" (selector)); + __asm("xchg{q} {%%}rbx, %q1; cpuid; xchg{q} {%%}rbx, %q1" + : "=a"(data[0]), "=&r"(data[1]), "=c"(data[2]), "=d"(data[3]) + : "0"(selector)); #else - asm("cpuid" - : "=a" (data[0]), - "=b" (data[1]), - "=c" (data[2]), - "=d" (data[3]) - : "0" (selector)); + __asm("cpuid" + : "=a"(data[0]), "=b"(data[1]), "=c"(data[2]), "=d"(data[3]) + : "0"(selector)); #endif } #else -#define __cpuid(a,b) memset((a), 0, sizeof(int) * 4) +#define __cpuid(a, b) memset((a), 0, sizeof(int) * 4) #endif static int query_cpu_feature_sse() { int buffer[4]; - __cpuid(buffer,1); - if ((buffer[3]&(1<<25)) == 0) return 0; + __cpuid(buffer, 1); + if ((buffer[3] & (1 << 25)) == 0) + return 0; return 1; } static int resampler_has_sse = 0; #endif -void resampler_init(void) -{ +void resampler_init(void) { unsigned i; double dx = (float)(SINC_WIDTH) / SINC_SAMPLES, x = 0.0; - for (i = 0; i < SINC_SAMPLES + 1; ++i, x += dx) - { + for (i = 0; i < SINC_SAMPLES + 1; ++i, x += dx) { float y = x / SINC_WIDTH; #if 0 // Blackman float window = 0.42659 - 0.49656 * cos(M_PI + M_PI * y) + 0.076849 * cos(2.0 * M_PI * y); #elif 1 // Nuttal 3 term - float window = 0.40897 + 0.5 * cos(M_PI * y) + 0.09103 * cos(2.0 * M_PI * y); + float window = + 0.40897 + 0.5 * cos(M_PI * y) + 0.09103 * cos(2.0 * M_PI * y); #elif 0 // C.R.Helmrich's 2 term window - float window = 0.79445 * cos(0.5 * M_PI * y) + 0.20555 * cos(1.5 * M_PI * y); + float window = + 0.79445 * cos(0.5 * M_PI * y) + 0.20555 * cos(1.5 * M_PI * y); #elif 0 // Lanczos float window = sinc(y); @@ -128,20 +117,19 @@ void resampler_init(void) } dx = 1.0 / (float)(RESAMPLER_RESOLUTION); x = 0.0; - for (i = 0; i < RESAMPLER_RESOLUTION; ++i, x += dx) - { - cubic_lut[i*4] = (float)(-0.5 * x * x * x + x * x - 0.5 * x); - cubic_lut[i*4+1] = (float)( 1.5 * x * x * x - 2.5 * x * x + 1.0); - cubic_lut[i*4+2] = (float)(-1.5 * x * x * x + 2.0 * x * x + 0.5 * x); - cubic_lut[i*4+3] = (float)( 0.5 * x * x * x - 0.5 * x * x); + for (i = 0; i < RESAMPLER_RESOLUTION; ++i, x += dx) { + cubic_lut[i * 4] = (float)(-0.5 * x * x * x + x * x - 0.5 * x); + cubic_lut[i * 4 + 1] = (float)(1.5 * x * x * x - 2.5 * x * x + 1.0); + cubic_lut[i * 4 + 2] = + (float)(-1.5 * x * x * x + 2.0 * x * x + 0.5 * x); + cubic_lut[i * 4 + 3] = (float)(0.5 * x * x * x - 0.5 * x * x); } #ifdef RESAMPLER_SSE resampler_has_sse = query_cpu_feature_sse(); #endif } -typedef struct resampler -{ +typedef struct resampler { int write_pos, write_filled; int read_pos, read_filled; float phase; @@ -157,10 +145,10 @@ typedef struct resampler float buffer_out[resampler_buffer_size + SINC_WIDTH * 2 - 1]; } resampler; -void * resampler_create(void) -{ - resampler * r = ( resampler * ) malloc( sizeof(resampler) ); - if ( !r ) return 0; +void *resampler_create(void) { + resampler *r = (resampler *)malloc(sizeof(resampler)); + if (!r) + return 0; r->write_pos = SINC_WIDTH - 1; r->write_filled = 0; @@ -175,31 +163,27 @@ void * resampler_create(void) r->delay_removed = -1; r->last_amp = 0; r->accumulator = 0; - memset( r->buffer_in, 0, sizeof(r->buffer_in) ); - memset( r->buffer_out, 0, sizeof(r->buffer_out) ); + memset(r->buffer_in, 0, sizeof(r->buffer_in)); + memset(r->buffer_out, 0, sizeof(r->buffer_out)); return r; } -void resampler_delete(void * _r) -{ - free( _r ); -} +void resampler_delete(void *_r) { free(_r); } -void * resampler_dup(const void * _r) -{ - void * r_out = malloc( sizeof(resampler) ); - if ( !r_out ) return 0; +void *resampler_dup(const void *_r) { + void *r_out = malloc(sizeof(resampler)); + if (!r_out) + return 0; resampler_dup_inplace(r_out, _r); return r_out; } -void resampler_dup_inplace(void *_d, const void *_s) -{ - const resampler * r_in = ( const resampler * ) _s; - resampler * r_out = ( resampler * ) _d; +void resampler_dup_inplace(void *_d, const void *_s) { + const resampler *r_in = (const resampler *)_s; + resampler *r_out = (resampler *)_d; r_out->write_pos = r_in->write_pos; r_out->write_filled = r_in->write_filled; @@ -214,27 +198,26 @@ void resampler_dup_inplace(void *_d, const void *_s) r_out->delay_removed = r_in->delay_removed; r_out->last_amp = r_in->last_amp; r_out->accumulator = r_in->accumulator; - memcpy( r_out->buffer_in, r_in->buffer_in, sizeof(r_in->buffer_in) ); - memcpy( r_out->buffer_out, r_in->buffer_out, sizeof(r_in->buffer_out) ); + memcpy(r_out->buffer_in, r_in->buffer_in, sizeof(r_in->buffer_in)); + memcpy(r_out->buffer_out, r_in->buffer_out, sizeof(r_in->buffer_out)); } -void resampler_set_quality(void *_r, int quality) -{ - resampler * r = ( resampler * ) _r; +void resampler_set_quality(void *_r, int quality) { + resampler *r = (resampler *)_r; if (quality < RESAMPLER_QUALITY_MIN) quality = RESAMPLER_QUALITY_MIN; else if (quality > RESAMPLER_QUALITY_MAX) quality = RESAMPLER_QUALITY_MAX; - if ( r->quality != quality ) - { - if ( quality == RESAMPLER_QUALITY_BLEP || r->quality == RESAMPLER_QUALITY_BLEP || - quality == RESAMPLER_QUALITY_BLAM || r->quality == RESAMPLER_QUALITY_BLAM ) - { + if (r->quality != quality) { + if (quality == RESAMPLER_QUALITY_BLEP || + r->quality == RESAMPLER_QUALITY_BLEP || + quality == RESAMPLER_QUALITY_BLAM || + r->quality == RESAMPLER_QUALITY_BLAM) { r->read_pos = 0; r->read_filled = 0; r->last_amp = 0; r->accumulator = 0; - memset( r->buffer_out, 0, sizeof(r->buffer_out) ); + memset(r->buffer_out, 0, sizeof(r->buffer_out)); } r->delay_added = -1; r->delay_removed = -1; @@ -242,78 +225,69 @@ void resampler_set_quality(void *_r, int quality) r->quality = (unsigned char)quality; } -int resampler_get_free_count(void *_r) -{ - resampler * r = ( resampler * ) _r; +int resampler_get_free_count(void *_r) { + resampler *r = (resampler *)_r; return resampler_buffer_size - r->write_filled; } -static int resampler_min_filled(resampler *r) -{ - switch (r->quality) - { +static int resampler_min_filled(resampler *r) { + switch (r->quality) { default: case RESAMPLER_QUALITY_ZOH: case RESAMPLER_QUALITY_BLEP: return 1; - + case RESAMPLER_QUALITY_LINEAR: case RESAMPLER_QUALITY_BLAM: return 2; - + case RESAMPLER_QUALITY_CUBIC: return 4; - + case RESAMPLER_QUALITY_SINC: return SINC_WIDTH * 2; } } -static int resampler_input_delay(resampler *r) -{ - switch (r->quality) - { +static int resampler_input_delay(resampler *r) { + switch (r->quality) { default: case RESAMPLER_QUALITY_ZOH: case RESAMPLER_QUALITY_BLEP: case RESAMPLER_QUALITY_LINEAR: case RESAMPLER_QUALITY_BLAM: return 0; - + case RESAMPLER_QUALITY_CUBIC: return 1; - + case RESAMPLER_QUALITY_SINC: return SINC_WIDTH - 1; } } -static int resampler_output_delay(resampler *r) -{ - switch (r->quality) - { +static int resampler_output_delay(resampler *r) { + switch (r->quality) { default: case RESAMPLER_QUALITY_ZOH: case RESAMPLER_QUALITY_LINEAR: case RESAMPLER_QUALITY_CUBIC: case RESAMPLER_QUALITY_SINC: return 0; - + case RESAMPLER_QUALITY_BLEP: case RESAMPLER_QUALITY_BLAM: return SINC_WIDTH - 1; } } -int resampler_ready(void *_r) -{ - resampler * r = ( resampler * ) _r; +int resampler_ready(void *_r) { + resampler *r = (resampler *)_r; return r->write_filled > resampler_min_filled(r); } -void resampler_clear(void *_r) -{ - resampler * r = ( resampler * ) _r; +void resampler_clear(void *_r) { + resampler *r = (resampler *)_r; r->write_pos = SINC_WIDTH - 1; r->write_filled = 0; r->read_pos = 0; @@ -322,9 +296,10 @@ void resampler_clear(void *_r) r->delay_added = -1; r->delay_removed = -1; memset(r->buffer_in, 0, (SINC_WIDTH - 1) * sizeof(r->buffer_in[0])); - memset(r->buffer_in + resampler_buffer_size, 0, (SINC_WIDTH - 1) * sizeof(r->buffer_in[0])); - if (r->quality == RESAMPLER_QUALITY_BLEP || r->quality == RESAMPLER_QUALITY_BLAM) - { + memset(r->buffer_in + resampler_buffer_size, 0, + (SINC_WIDTH - 1) * sizeof(r->buffer_in[0])); + if (r->quality == RESAMPLER_QUALITY_BLEP || + r->quality == RESAMPLER_QUALITY_BLAM) { r->inv_phase = 0; r->last_amp = 0; r->accumulator = 0; @@ -332,862 +307,809 @@ void resampler_clear(void *_r) } } -void resampler_set_rate(void *_r, double new_factor) -{ - resampler * r = ( resampler * ) _r; +void resampler_set_rate(void *_r, double new_factor) { + resampler *r = (resampler *)_r; r->phase_inc = new_factor; new_factor = 1.0 / new_factor; r->inv_phase_inc = new_factor; } -void resampler_write_sample(void *_r, short s) -{ - resampler * r = ( resampler * ) _r; +void resampler_write_sample(void *_r, short s) { + resampler *r = (resampler *)_r; - if ( r->delay_added < 0 ) - { + if (r->delay_added < 0) { r->delay_added = 0; - r->write_filled = resampler_input_delay( r ); + r->write_filled = resampler_input_delay(r); } - - if ( r->write_filled < resampler_buffer_size ) - { + + if (r->write_filled < resampler_buffer_size) { float s32 = s; s32 *= 256.0; - r->buffer_in[ r->write_pos ] = s32; - r->buffer_in[ r->write_pos + resampler_buffer_size ] = s32; + r->buffer_in[r->write_pos] = s32; + r->buffer_in[r->write_pos + resampler_buffer_size] = s32; ++r->write_filled; - r->write_pos = ( r->write_pos + 1 ) % resampler_buffer_size; + r->write_pos = (r->write_pos + 1) % resampler_buffer_size; } } -void resampler_write_sample_fixed(void *_r, int s, unsigned char depth) -{ - resampler * r = ( resampler * ) _r; - - if ( r->delay_added < 0 ) - { +void resampler_write_sample_fixed(void *_r, int s, unsigned char depth) { + resampler *r = (resampler *)_r; + + if (r->delay_added < 0) { r->delay_added = 0; - r->write_filled = resampler_input_delay( r ); + r->write_filled = resampler_input_delay(r); } - - if ( r->write_filled < resampler_buffer_size ) - { + + if (r->write_filled < resampler_buffer_size) { float s32 = s; s32 /= (double)(1 << (depth - 1)); - - r->buffer_in[ r->write_pos ] = s32; - r->buffer_in[ r->write_pos + resampler_buffer_size ] = s32; - + + r->buffer_in[r->write_pos] = s32; + r->buffer_in[r->write_pos + resampler_buffer_size] = s32; + ++r->write_filled; - - r->write_pos = ( r->write_pos + 1 ) % resampler_buffer_size; + + r->write_pos = (r->write_pos + 1) % resampler_buffer_size; } } -void resampler_write_sample_float(void *_r, float s) -{ - resampler * r = ( resampler * ) _r; - - if ( r->delay_added < 0 ) - { - r->delay_added = 0; - r->write_filled = resampler_input_delay( r ); - } - - if ( r->write_filled < resampler_buffer_size ) - { - r->buffer_in[ r->write_pos ] = s; - r->buffer_in[ r->write_pos + resampler_buffer_size ] = s; - - ++r->write_filled; - - r->write_pos = ( r->write_pos + 1 ) % resampler_buffer_size; - } +void resampler_write_sample_float(void *_r, float s) { + resampler *r = (resampler *)_r; + + if (r->delay_added < 0) { + r->delay_added = 0; + r->write_filled = resampler_input_delay(r); + } + + if (r->write_filled < resampler_buffer_size) { + r->buffer_in[r->write_pos] = s; + r->buffer_in[r->write_pos + resampler_buffer_size] = s; + + ++r->write_filled; + + r->write_pos = (r->write_pos + 1) % resampler_buffer_size; + } } -static int resampler_run_zoh(resampler * r, float ** out_, float * out_end) -{ +static int resampler_run_zoh(resampler *r, float **out_, float *out_end) { int in_size = r->write_filled; - float const* in_ = r->buffer_in + resampler_buffer_size + r->write_pos - r->write_filled; + float const *in_ = + r->buffer_in + resampler_buffer_size + r->write_pos - r->write_filled; int used = 0; in_size -= 1; - if ( in_size > 0 ) - { - float* out = *out_; - float const* in = in_; - float const* const in_end = in + in_size; + if (in_size > 0) { + float *out = *out_; + float const *in = in_; + float const *const in_end = in + in_size; float phase = r->phase; float phase_inc = r->phase_inc; - - do - { + + do { float sample; - - if ( out >= out_end ) + + if (out >= out_end) break; sample = *in; *out++ = sample; - + phase += phase_inc; - + in += (int)phase; - + phase = fmod(phase, 1.0f); - } - while ( in < in_end ); - + } while (in < in_end); + r->phase = phase; *out_ = out; - + used = (int)(in - in_); - + r->write_filled -= used; } - + return used; } #ifndef RESAMPLER_NEON -static int resampler_run_blep(resampler * r, float ** out_, float * out_end) -{ +static int resampler_run_blep(resampler *r, float **out_, float *out_end) { int in_size = r->write_filled; - float const* in_ = r->buffer_in + resampler_buffer_size + r->write_pos - r->write_filled; + float const *in_ = + r->buffer_in + resampler_buffer_size + r->write_pos - r->write_filled; int used = 0; in_size -= 1; - if ( in_size > 0 ) - { - float* out = *out_; - float const* in = in_; - float const* const in_end = in + in_size; + if (in_size > 0) { + float *out = *out_; + float const *in = in_; + float const *const in_end = in + in_size; float last_amp = r->last_amp; float inv_phase = r->inv_phase; float inv_phase_inc = r->inv_phase_inc; - + const int step = RESAMPLER_BLEP_CUTOFF * RESAMPLER_RESOLUTION; const int window_step = RESAMPLER_RESOLUTION; - - do - { + + do { float sample; - - if ( out + SINC_WIDTH * 2 > out_end ) + + if (out + SINC_WIDTH * 2 > out_end) break; - + sample = *in++ - last_amp; - - if (sample) - { + + if (sample) { float kernel[SINC_WIDTH * 2], kernel_sum = 0.0f; int phase_reduced = (int)(inv_phase * RESAMPLER_RESOLUTION); int phase_adj = phase_reduced * step / RESAMPLER_RESOLUTION; int i = SINC_WIDTH; - for (; i >= -SINC_WIDTH + 1; --i) - { + for (; i >= -SINC_WIDTH + 1; --i) { int pos = i * step; int window_pos = i * window_step; - kernel_sum += kernel[i + SINC_WIDTH - 1] = sinc_lut[abs(phase_adj - pos)] * window_lut[abs(phase_reduced - window_pos)]; + kernel_sum += kernel[i + SINC_WIDTH - 1] = + sinc_lut[abs(phase_adj - pos)] * + window_lut[abs(phase_reduced - window_pos)]; } last_amp += sample; sample /= kernel_sum; for (i = 0; i < SINC_WIDTH * 2; ++i) out[i] += sample * kernel[i]; } - + inv_phase += inv_phase_inc; - + out += (int)inv_phase; - + inv_phase = fmod(inv_phase, 1.0f); - } - while ( in < in_end ); - + } while (in < in_end); + r->inv_phase = inv_phase; r->last_amp = last_amp; *out_ = out; - + used = (int)(in - in_); - + r->write_filled -= used; } - + return used; } #endif #ifdef RESAMPLER_SSE -static int resampler_run_blep_sse(resampler * r, float ** out_, float * out_end) -{ +static int resampler_run_blep_sse(resampler *r, float **out_, float *out_end) { int in_size = r->write_filled; - float const* in_ = r->buffer_in + resampler_buffer_size + r->write_pos - r->write_filled; + float const *in_ = + r->buffer_in + resampler_buffer_size + r->write_pos - r->write_filled; int used = 0; in_size -= 1; - if ( in_size > 0 ) - { - float* out = *out_; - float const* in = in_; - float const* const in_end = in + in_size; + if (in_size > 0) { + float *out = *out_; + float const *in = in_; + float const *const in_end = in + in_size; float last_amp = r->last_amp; float inv_phase = r->inv_phase; float inv_phase_inc = r->inv_phase_inc; - + const int step = RESAMPLER_BLEP_CUTOFF * RESAMPLER_RESOLUTION; const int window_step = RESAMPLER_RESOLUTION; - - do - { + + do { float sample; - - if ( out + SINC_WIDTH * 2 > out_end ) + + if (out + SINC_WIDTH * 2 > out_end) break; - + sample = *in++ - last_amp; - - if (sample) - { + + if (sample) { float kernel_sum = 0.0f; __m128 kernel[SINC_WIDTH / 2]; __m128 temp1, temp2; __m128 samplex; - float *kernelf = (float*)(&kernel); + float *kernelf = (float *)(&kernel); int phase_reduced = (int)(inv_phase * RESAMPLER_RESOLUTION); int phase_adj = phase_reduced * step / RESAMPLER_RESOLUTION; int i = SINC_WIDTH; - for (; i >= -SINC_WIDTH + 1; --i) - { + for (; i >= -SINC_WIDTH + 1; --i) { int pos = i * step; int window_pos = i * window_step; - kernel_sum += kernelf[i + SINC_WIDTH - 1] = sinc_lut[abs(phase_adj - pos)] * window_lut[abs(phase_reduced - window_pos)]; + kernel_sum += kernelf[i + SINC_WIDTH - 1] = + sinc_lut[abs(phase_adj - pos)] * + window_lut[abs(phase_reduced - window_pos)]; } last_amp += sample; sample /= kernel_sum; - samplex = _mm_set1_ps( sample ); - for (i = 0; i < SINC_WIDTH / 2; ++i) - { - temp1 = _mm_load_ps( (const float *)( kernel + i ) ); - temp1 = _mm_mul_ps( temp1, samplex ); - temp2 = _mm_loadu_ps( (const float *) out + i * 4 ); - temp1 = _mm_add_ps( temp1, temp2 ); - _mm_storeu_ps( (float *) out + i * 4, temp1 ); + samplex = _mm_set1_ps(sample); + for (i = 0; i < SINC_WIDTH / 2; ++i) { + temp1 = _mm_load_ps((const float *)(kernel + i)); + temp1 = _mm_mul_ps(temp1, samplex); + temp2 = _mm_loadu_ps((const float *)out + i * 4); + temp1 = _mm_add_ps(temp1, temp2); + _mm_storeu_ps((float *)out + i * 4, temp1); } } - + inv_phase += inv_phase_inc; - + out += (int)inv_phase; - + inv_phase = fmod(inv_phase, 1.0f); - } - while ( in < in_end ); - + } while (in < in_end); + r->inv_phase = inv_phase; r->last_amp = last_amp; *out_ = out; - + used = (int)(in - in_); - + r->write_filled -= used; } - + return used; } #endif #ifdef RESAMPLER_NEON -static int resampler_run_blep(resampler * r, float ** out_, float * out_end) -{ +static int resampler_run_blep(resampler *r, float **out_, float *out_end) { int in_size = r->write_filled; - float const* in_ = r->buffer_in + resampler_buffer_size + r->write_pos - r->write_filled; + float const *in_ = + r->buffer_in + resampler_buffer_size + r->write_pos - r->write_filled; int used = 0; in_size -= 1; - if ( in_size > 0 ) - { - float* out = *out_; - float const* in = in_; - float const* const in_end = in + in_size; + if (in_size > 0) { + float *out = *out_; + float const *in = in_; + float const *const in_end = in + in_size; float last_amp = r->last_amp; float inv_phase = r->inv_phase; float inv_phase_inc = r->inv_phase_inc; - + const int step = RESAMPLER_BLEP_CUTOFF * RESAMPLER_RESOLUTION; const int window_step = RESAMPLER_RESOLUTION; - - do - { + + do { float sample; - - if ( out + SINC_WIDTH * 2 > out_end ) + + if (out + SINC_WIDTH * 2 > out_end) break; - + sample = *in++ - last_amp; - - if (sample) - { + + if (sample) { float kernel_sum = 0.0f; float32x4_t kernel[SINC_WIDTH / 2]; float32x4_t temp1, temp2; float32x4_t samplex; - float *kernelf = (float*)(&kernel); + float *kernelf = (float *)(&kernel); int phase_reduced = (int)(inv_phase * RESAMPLER_RESOLUTION); int phase_adj = phase_reduced * step / RESAMPLER_RESOLUTION; int i = SINC_WIDTH; - for (; i >= -SINC_WIDTH + 1; --i) - { + for (; i >= -SINC_WIDTH + 1; --i) { int pos = i * step; int window_pos = i * window_step; - kernel_sum += kernelf[i + SINC_WIDTH - 1] = sinc_lut[abs(phase_adj - pos)] * window_lut[abs(phase_reduced - window_pos)]; + kernel_sum += kernelf[i + SINC_WIDTH - 1] = + sinc_lut[abs(phase_adj - pos)] * + window_lut[abs(phase_reduced - window_pos)]; } last_amp += sample; sample /= kernel_sum; samplex = vdupq_n_f32(sample); - for (i = 0; i < SINC_WIDTH / 2; ++i) - { - temp1 = vld1q_f32( (const float32_t *)( kernel + i ) ); - temp2 = vld1q_f32( (const float32_t *) out + i * 4 ); - temp2 = vmlaq_f32( temp2, temp1, samplex ); - vst1q_f32( (float32_t *) out + i * 4, temp2 ); + for (i = 0; i < SINC_WIDTH / 2; ++i) { + temp1 = vld1q_f32((const float32_t *)(kernel + i)); + temp2 = vld1q_f32((const float32_t *)out + i * 4); + temp2 = vmlaq_f32(temp2, temp1, samplex); + vst1q_f32((float32_t *)out + i * 4, temp2); } } - + inv_phase += inv_phase_inc; - + out += (int)inv_phase; - + inv_phase = fmod(inv_phase, 1.0f); - } - while ( in < in_end ); - + } while (in < in_end); + r->inv_phase = inv_phase; r->last_amp = last_amp; *out_ = out; - + used = (int)(in - in_); - + r->write_filled -= used; } - + return used; } #endif -static int resampler_run_linear(resampler * r, float ** out_, float * out_end) -{ +static int resampler_run_linear(resampler *r, float **out_, float *out_end) { int in_size = r->write_filled; - float const* in_ = r->buffer_in + resampler_buffer_size + r->write_pos - r->write_filled; + float const *in_ = + r->buffer_in + resampler_buffer_size + r->write_pos - r->write_filled; int used = 0; in_size -= 2; - if ( in_size > 0 ) - { - float* out = *out_; - float const* in = in_; - float const* const in_end = in + in_size; + if (in_size > 0) { + float *out = *out_; + float const *in = in_; + float const *const in_end = in + in_size; float phase = r->phase; float phase_inc = r->phase_inc; - - do - { + + do { float sample; - - if ( out >= out_end ) + + if (out >= out_end) break; - + sample = in[0] + (in[1] - in[0]) * phase; *out++ = sample; - + phase += phase_inc; - + in += (int)phase; - + phase = fmod(phase, 1.0f); - } - while ( in < in_end ); - + } while (in < in_end); + r->phase = phase; *out_ = out; - + used = (int)(in - in_); - + r->write_filled -= used; } - + return used; } #ifndef RESAMPLER_NEON -static int resampler_run_blam(resampler * r, float ** out_, float * out_end) -{ +static int resampler_run_blam(resampler *r, float **out_, float *out_end) { int in_size = r->write_filled; - float const* in_ = r->buffer_in + resampler_buffer_size + r->write_pos - r->write_filled; + float const *in_ = + r->buffer_in + resampler_buffer_size + r->write_pos - r->write_filled; int used = 0; in_size -= 2; - if ( in_size > 0 ) - { - float* out = *out_; - float const* in = in_; - float const* const in_end = in + in_size; + if (in_size > 0) { + float *out = *out_; + float const *in = in_; + float const *const in_end = in + in_size; float last_amp = r->last_amp; float phase = r->phase; float phase_inc = r->phase_inc; float inv_phase = r->inv_phase; float inv_phase_inc = r->inv_phase_inc; - + const int step = RESAMPLER_BLAM_CUTOFF * RESAMPLER_RESOLUTION; const int window_step = RESAMPLER_RESOLUTION; - do - { + do { float sample; - - if ( out + SINC_WIDTH * 2 > out_end ) + + if (out + SINC_WIDTH * 2 > out_end) break; - + sample = in[0]; if (phase_inc < 1.0f) sample += (in[1] - in[0]) * phase; sample -= last_amp; - - if (sample) - { + + if (sample) { float kernel[SINC_WIDTH * 2], kernel_sum = 0.0f; int phase_reduced = (int)(inv_phase * RESAMPLER_RESOLUTION); int phase_adj = phase_reduced * step / RESAMPLER_RESOLUTION; int i = SINC_WIDTH; - for (; i >= -SINC_WIDTH + 1; --i) - { + for (; i >= -SINC_WIDTH + 1; --i) { int pos = i * step; int window_pos = i * window_step; - kernel_sum += kernel[i + SINC_WIDTH - 1] = sinc_lut[abs(phase_adj - pos)] * window_lut[abs(phase_reduced - window_pos)]; + kernel_sum += kernel[i + SINC_WIDTH - 1] = + sinc_lut[abs(phase_adj - pos)] * + window_lut[abs(phase_reduced - window_pos)]; } last_amp += sample; sample /= kernel_sum; for (i = 0; i < SINC_WIDTH * 2; ++i) out[i] += sample * kernel[i]; } - - if (inv_phase_inc < 1.0f) - { + + if (inv_phase_inc < 1.0f) { ++in; inv_phase += inv_phase_inc; out += (int)inv_phase; inv_phase = fmod(inv_phase, 1.0f); - } - else - { + } else { phase += phase_inc; ++out; in += (int)phase; phase = fmod(phase, 1.0f); } - } - while ( in < in_end ); - + } while (in < in_end); + r->phase = phase; r->inv_phase = inv_phase; r->last_amp = last_amp; *out_ = out; - + used = (int)(in - in_); - + r->write_filled -= used; } - + return used; } #endif #ifdef RESAMPLER_SSE -static int resampler_run_blam_sse(resampler * r, float ** out_, float * out_end) -{ +static int resampler_run_blam_sse(resampler *r, float **out_, float *out_end) { int in_size = r->write_filled; - float const* in_ = r->buffer_in + resampler_buffer_size + r->write_pos - r->write_filled; + float const *in_ = + r->buffer_in + resampler_buffer_size + r->write_pos - r->write_filled; int used = 0; in_size -= 2; - if ( in_size > 0 ) - { - float* out = *out_; - float const* in = in_; - float const* const in_end = in + in_size; + if (in_size > 0) { + float *out = *out_; + float const *in = in_; + float const *const in_end = in + in_size; float last_amp = r->last_amp; float phase = r->phase; float phase_inc = r->phase_inc; float inv_phase = r->inv_phase; float inv_phase_inc = r->inv_phase_inc; - + const int step = RESAMPLER_BLAM_CUTOFF * RESAMPLER_RESOLUTION; const int window_step = RESAMPLER_RESOLUTION; - do - { + do { float sample; - - if ( out + SINC_WIDTH * 2 > out_end ) + + if (out + SINC_WIDTH * 2 > out_end) break; sample = in[0]; - if (phase_inc < 1.0f) - { + if (phase_inc < 1.0f) { sample += (in[1] - in[0]) * phase; } sample -= last_amp; - - if (sample) - { + + if (sample) { float kernel_sum = 0.0f; __m128 kernel[SINC_WIDTH / 2]; __m128 temp1, temp2; __m128 samplex; - float *kernelf = (float*)(&kernel); + float *kernelf = (float *)(&kernel); int phase_reduced = (int)(inv_phase * RESAMPLER_RESOLUTION); int phase_adj = phase_reduced * step / RESAMPLER_RESOLUTION; int i = SINC_WIDTH; - for (; i >= -SINC_WIDTH + 1; --i) - { + for (; i >= -SINC_WIDTH + 1; --i) { int pos = i * step; int window_pos = i * window_step; - kernel_sum += kernelf[i + SINC_WIDTH - 1] = sinc_lut[abs(phase_adj - pos)] * window_lut[abs(phase_reduced - window_pos)]; + kernel_sum += kernelf[i + SINC_WIDTH - 1] = + sinc_lut[abs(phase_adj - pos)] * + window_lut[abs(phase_reduced - window_pos)]; } last_amp += sample; sample /= kernel_sum; - samplex = _mm_set1_ps( sample ); - for (i = 0; i < SINC_WIDTH / 2; ++i) - { - temp1 = _mm_load_ps( (const float *)( kernel + i ) ); - temp1 = _mm_mul_ps( temp1, samplex ); - temp2 = _mm_loadu_ps( (const float *) out + i * 4 ); - temp1 = _mm_add_ps( temp1, temp2 ); - _mm_storeu_ps( (float *) out + i * 4, temp1 ); + samplex = _mm_set1_ps(sample); + for (i = 0; i < SINC_WIDTH / 2; ++i) { + temp1 = _mm_load_ps((const float *)(kernel + i)); + temp1 = _mm_mul_ps(temp1, samplex); + temp2 = _mm_loadu_ps((const float *)out + i * 4); + temp1 = _mm_add_ps(temp1, temp2); + _mm_storeu_ps((float *)out + i * 4, temp1); } } - - if (inv_phase_inc < 1.0f) - { + + if (inv_phase_inc < 1.0f) { ++in; inv_phase += inv_phase_inc; out += (int)inv_phase; inv_phase = fmod(inv_phase, 1.0f); - } - else - { + } else { phase += phase_inc; ++out; - - if (phase >= 1.0f) - { + + if (phase >= 1.0f) { ++in; phase = fmod(phase, 1.0f); } } - } - while ( in < in_end ); + } while (in < in_end); r->phase = phase; r->inv_phase = inv_phase; r->last_amp = last_amp; *out_ = out; - + used = (int)(in - in_); - + r->write_filled -= used; } - + return used; } #endif #ifdef RESAMPLER_NEON -static int resampler_run_blam(resampler * r, float ** out_, float * out_end) -{ +static int resampler_run_blam(resampler *r, float **out_, float *out_end) { int in_size = r->write_filled; - float const* in_ = r->buffer_in + resampler_buffer_size + r->write_pos - r->write_filled; + float const *in_ = + r->buffer_in + resampler_buffer_size + r->write_pos - r->write_filled; int used = 0; in_size -= 2; - if ( in_size > 0 ) - { - float* out = *out_; - float const* in = in_; - float const* const in_end = in + in_size; + if (in_size > 0) { + float *out = *out_; + float const *in = in_; + float const *const in_end = in + in_size; float last_amp = r->last_amp; float phase = r->phase; float phase_inc = r->phase_inc; float inv_phase = r->inv_phase; float inv_phase_inc = r->inv_phase_inc; - + const int step = RESAMPLER_BLAM_CUTOFF * RESAMPLER_RESOLUTION; const int window_step = RESAMPLER_RESOLUTION; - do - { + do { float sample; - - if ( out + SINC_WIDTH * 2 > out_end ) + + if (out + SINC_WIDTH * 2 > out_end) break; - + sample = in[0]; if (phase_inc < 1.0f) sample += (in[1] - in[0]) * phase; sample -= last_amp; - - if (sample) - { + + if (sample) { float kernel_sum = 0.0; float32x4_t kernel[SINC_WIDTH / 2]; float32x4_t temp1, temp2; float32x4_t samplex; - float *kernelf = (float*)(&kernel); + float *kernelf = (float *)(&kernel); int phase_reduced = (int)(inv_phase * RESAMPLER_RESOLUTION); int phase_adj = phase_reduced * step / RESAMPLER_RESOLUTION; int i = SINC_WIDTH; - for (; i >= -SINC_WIDTH + 1; --i) - { + for (; i >= -SINC_WIDTH + 1; --i) { int pos = i * step; int window_pos = i * window_step; - kernel_sum += kernelf[i + SINC_WIDTH - 1] = sinc_lut[abs(phase_adj - pos)] * window_lut[abs(phase_reduced - window_pos)]; + kernel_sum += kernelf[i + SINC_WIDTH - 1] = + sinc_lut[abs(phase_adj - pos)] * + window_lut[abs(phase_reduced - window_pos)]; } last_amp += sample; sample /= kernel_sum; samplex = vdupq_n_f32(sample); - for (i = 0; i < SINC_WIDTH / 2; ++i) - { - temp1 = vld1q_f32( (const float32_t *)( kernel + i ) ); - temp2 = vld1q_f32( (const float32_t *) out + i * 4 ); - temp2 = vmlaq_f32( temp2, temp1, samplex ); - vst1q_f32( (float32_t *) out + i * 4, temp2 ); + for (i = 0; i < SINC_WIDTH / 2; ++i) { + temp1 = vld1q_f32((const float32_t *)(kernel + i)); + temp2 = vld1q_f32((const float32_t *)out + i * 4); + temp2 = vmlaq_f32(temp2, temp1, samplex); + vst1q_f32((float32_t *)out + i * 4, temp2); } } - if (inv_phase_inc < 1.0f) - { + if (inv_phase_inc < 1.0f) { ++in; inv_phase += inv_phase_inc; out += (int)inv_phase; inv_phase = fmod(inv_phase, 1.0f); - } - else - { + } else { phase += phase_inc; ++out; - - if (phase >= 1.0f) - { + + if (phase >= 1.0f) { ++in; phase = fmod(phase, 1.0f); } } - } - while ( in < in_end ); - + } while (in < in_end); + r->phase = phase; r->inv_phase = inv_phase; r->last_amp = last_amp; *out_ = out; - + used = (int)(in - in_); - + r->write_filled -= used; } - + return used; } #endif #ifndef RESAMPLER_NEON -static int resampler_run_cubic(resampler * r, float ** out_, float * out_end) -{ +static int resampler_run_cubic(resampler *r, float **out_, float *out_end) { int in_size = r->write_filled; - float const* in_ = r->buffer_in + resampler_buffer_size + r->write_pos - r->write_filled; + float const *in_ = + r->buffer_in + resampler_buffer_size + r->write_pos - r->write_filled; int used = 0; in_size -= 4; - if ( in_size > 0 ) - { - float* out = *out_; - float const* in = in_; - float const* const in_end = in + in_size; + if (in_size > 0) { + float *out = *out_; + float const *in = in_; + float const *const in_end = in + in_size; float phase = r->phase; float phase_inc = r->phase_inc; - - do - { - float * kernel; + + do { + float *kernel; int i; float sample; - - if ( out >= out_end ) + + if (out >= out_end) break; - + kernel = cubic_lut + (int)(phase * RESAMPLER_RESOLUTION) * 4; - + for (sample = 0, i = 0; i < 4; ++i) sample += in[i] * kernel[i]; *out++ = sample; - + phase += phase_inc; - + in += (int)phase; - + phase = fmod(phase, 1.0f); - } - while ( in < in_end ); - + } while (in < in_end); + r->phase = phase; *out_ = out; - + used = (int)(in - in_); - + r->write_filled -= used; } - + return used; } #endif #ifdef RESAMPLER_SSE -static int resampler_run_cubic_sse(resampler * r, float ** out_, float * out_end) -{ +static int resampler_run_cubic_sse(resampler *r, float **out_, float *out_end) { int in_size = r->write_filled; - float const* in_ = r->buffer_in + resampler_buffer_size + r->write_pos - r->write_filled; + float const *in_ = + r->buffer_in + resampler_buffer_size + r->write_pos - r->write_filled; int used = 0; in_size -= 4; - if ( in_size > 0 ) - { - float* out = *out_; - float const* in = in_; - float const* const in_end = in + in_size; + if (in_size > 0) { + float *out = *out_; + float const *in = in_; + float const *const in_end = in + in_size; float phase = r->phase; float phase_inc = r->phase_inc; - - do - { + + do { __m128 temp1, temp2; __m128 samplex = _mm_setzero_ps(); - - if ( out >= out_end ) + + if (out >= out_end) break; - - temp1 = _mm_loadu_ps( (const float *)( in ) ); - temp2 = _mm_load_ps( (const float *)( cubic_lut + (int)(phase * RESAMPLER_RESOLUTION) * 4 ) ); - temp1 = _mm_mul_ps( temp1, temp2 ); - samplex = _mm_add_ps( samplex, temp1 ); - temp1 = _mm_movehl_ps( temp1, samplex ); - samplex = _mm_add_ps( samplex, temp1 ); + + temp1 = _mm_loadu_ps((const float *)(in)); + temp2 = _mm_load_ps( + (const float *)(cubic_lut + + (int)(phase * RESAMPLER_RESOLUTION) * 4)); + temp1 = _mm_mul_ps(temp1, temp2); + samplex = _mm_add_ps(samplex, temp1); + temp1 = _mm_movehl_ps(temp1, samplex); + samplex = _mm_add_ps(samplex, temp1); temp1 = samplex; - temp1 = _mm_shuffle_ps( temp1, samplex, _MM_SHUFFLE(0, 0, 0, 1) ); - samplex = _mm_add_ps( samplex, temp1 ); - _mm_store_ss( out, samplex ); + temp1 = _mm_shuffle_ps(temp1, samplex, _MM_SHUFFLE(0, 0, 0, 1)); + samplex = _mm_add_ps(samplex, temp1); + _mm_store_ss(out, samplex); ++out; - + phase += phase_inc; - + in += (int)phase; - + phase = fmod(phase, 1.0f); - } - while ( in < in_end ); - + } while (in < in_end); + r->phase = phase; *out_ = out; - + used = (int)(in - in_); - + r->write_filled -= used; } - + return used; } #endif #ifdef RESAMPLER_NEON -static int resampler_run_cubic(resampler * r, float ** out_, float * out_end) -{ +static int resampler_run_cubic(resampler *r, float **out_, float *out_end) { int in_size = r->write_filled; - float const* in_ = r->buffer_in + resampler_buffer_size + r->write_pos - r->write_filled; + float const *in_ = + r->buffer_in + resampler_buffer_size + r->write_pos - r->write_filled; int used = 0; in_size -= 4; - if ( in_size > 0 ) - { - float* out = *out_; - float const* in = in_; - float const* const in_end = in + in_size; + if (in_size > 0) { + float *out = *out_; + float const *in = in_; + float const *const in_end = in + in_size; float phase = r->phase; float phase_inc = r->phase_inc; - - do - { + + do { float32x4_t temp1, temp2; float32x2_t half; - - if ( out >= out_end ) + + if (out >= out_end) break; - - temp1 = vld1q_f32( (const float32_t *)( in ) ); - temp2 = vld1q_f32( (const float32_t *)( cubic_lut + (int)(phase * RESAMPLER_RESOLUTION) * 4 ) ); - temp1 = vmulq_f32( temp1, temp2 ); + + temp1 = vld1q_f32((const float32_t *)(in)); + temp2 = vld1q_f32( + (const float32_t *)(cubic_lut + + (int)(phase * RESAMPLER_RESOLUTION) * 4)); + temp1 = vmulq_f32(temp1, temp2); half = vadd_f32(vget_high_f32(temp1), vget_low_f32(temp1)); *out++ = vget_lane_f32(vpadd_f32(half, half), 0); - + phase += phase_inc; - + in += (int)phase; - + phase = fmod(phase, 1.0f); - } - while ( in < in_end ); - + } while (in < in_end); + r->phase = phase; *out_ = out; - + used = (int)(in - in_); - + r->write_filled -= used; } - + return used; } #endif #ifndef RESAMPLER_NEON -static int resampler_run_sinc(resampler * r, float ** out_, float * out_end) -{ +static int resampler_run_sinc(resampler *r, float **out_, float *out_end) { int in_size = r->write_filled; - float const* in_ = r->buffer_in + resampler_buffer_size + r->write_pos - r->write_filled; + float const *in_ = + r->buffer_in + resampler_buffer_size + r->write_pos - r->write_filled; int used = 0; in_size -= SINC_WIDTH * 2; - if ( in_size > 0 ) - { - float* out = *out_; - float const* in = in_; - float const* const in_end = in + in_size; + if (in_size > 0) { + float *out = *out_; + float const *in = in_; + float const *const in_end = in + in_size; float phase = r->phase; float phase_inc = r->phase_inc; - int step = phase_inc > 1.0f ? (int)(RESAMPLER_RESOLUTION / phase_inc * RESAMPLER_SINC_CUTOFF) : (int)(RESAMPLER_RESOLUTION * RESAMPLER_SINC_CUTOFF); + int step = phase_inc > 1.0f + ? (int)(RESAMPLER_RESOLUTION / phase_inc * + RESAMPLER_SINC_CUTOFF) + : (int)(RESAMPLER_RESOLUTION * RESAMPLER_SINC_CUTOFF); int window_step = RESAMPLER_RESOLUTION; - do - { + do { float kernel[SINC_WIDTH * 2], kernel_sum = 0.0; int i = SINC_WIDTH; int phase_reduced = (int)(phase * RESAMPLER_RESOLUTION); int phase_adj = phase_reduced * step / RESAMPLER_RESOLUTION; float sample; - if ( out >= out_end ) + if (out >= out_end) break; - for (; i >= -SINC_WIDTH + 1; --i) - { + for (; i >= -SINC_WIDTH + 1; --i) { int pos = i * step; int window_pos = i * window_step; - kernel_sum += kernel[i + SINC_WIDTH - 1] = sinc_lut[abs(phase_adj - pos)] * window_lut[abs(phase_reduced - window_pos)]; + kernel_sum += kernel[i + SINC_WIDTH - 1] = + sinc_lut[abs(phase_adj - pos)] * + window_lut[abs(phase_reduced - window_pos)]; } for (sample = 0, i = 0; i < SINC_WIDTH * 2; ++i) sample += in[i] * kernel[i]; @@ -1198,8 +1120,7 @@ static int resampler_run_sinc(resampler * r, float ** out_, float * out_end) in += (int)phase; phase = fmod(phase, 1.0f); - } - while ( in < in_end ); + } while (in < in_end); r->phase = phase; *out_ = out; @@ -1214,302 +1135,299 @@ static int resampler_run_sinc(resampler * r, float ** out_, float * out_end) #endif #ifdef RESAMPLER_SSE -static int resampler_run_sinc_sse(resampler * r, float ** out_, float * out_end) -{ +static int resampler_run_sinc_sse(resampler *r, float **out_, float *out_end) { int in_size = r->write_filled; - float const* in_ = r->buffer_in + resampler_buffer_size + r->write_pos - r->write_filled; + float const *in_ = + r->buffer_in + resampler_buffer_size + r->write_pos - r->write_filled; int used = 0; in_size -= SINC_WIDTH * 2; - if ( in_size > 0 ) - { - float* out = *out_; - float const* in = in_; - float const* const in_end = in + in_size; + if (in_size > 0) { + float *out = *out_; + float const *in = in_; + float const *const in_end = in + in_size; float phase = r->phase; float phase_inc = r->phase_inc; - - int step = phase_inc > 1.0f ? (int)(RESAMPLER_RESOLUTION / phase_inc * RESAMPLER_SINC_CUTOFF) : (int)(RESAMPLER_RESOLUTION * RESAMPLER_SINC_CUTOFF); + + int step = phase_inc > 1.0f + ? (int)(RESAMPLER_RESOLUTION / phase_inc * + RESAMPLER_SINC_CUTOFF) + : (int)(RESAMPLER_RESOLUTION * RESAMPLER_SINC_CUTOFF); int window_step = RESAMPLER_RESOLUTION; - - do - { + + do { // accumulate in extended precision float kernel_sum = 0.0; __m128 kernel[SINC_WIDTH / 2]; __m128 temp1, temp2; __m128 samplex = _mm_setzero_ps(); - float *kernelf = (float*)(&kernel); + float *kernelf = (float *)(&kernel); int i = SINC_WIDTH; int phase_reduced = (int)(phase * RESAMPLER_RESOLUTION); int phase_adj = phase_reduced * step / RESAMPLER_RESOLUTION; - - if ( out >= out_end ) + + if (out >= out_end) break; - - for (; i >= -SINC_WIDTH + 1; --i) - { + + for (; i >= -SINC_WIDTH + 1; --i) { int pos = i * step; int window_pos = i * window_step; - kernel_sum += kernelf[i + SINC_WIDTH - 1] = sinc_lut[abs(phase_adj - pos)] * window_lut[abs(phase_reduced - window_pos)]; + kernel_sum += kernelf[i + SINC_WIDTH - 1] = + sinc_lut[abs(phase_adj - pos)] * + window_lut[abs(phase_reduced - window_pos)]; } - for (i = 0; i < SINC_WIDTH / 2; ++i) - { - temp1 = _mm_loadu_ps( (const float *)( in + i * 4 ) ); - temp2 = _mm_load_ps( (const float *)( kernel + i ) ); - temp1 = _mm_mul_ps( temp1, temp2 ); - samplex = _mm_add_ps( samplex, temp1 ); + for (i = 0; i < SINC_WIDTH / 2; ++i) { + temp1 = _mm_loadu_ps((const float *)(in + i * 4)); + temp2 = _mm_load_ps((const float *)(kernel + i)); + temp1 = _mm_mul_ps(temp1, temp2); + samplex = _mm_add_ps(samplex, temp1); } kernel_sum = 1.0 / kernel_sum; - temp1 = _mm_movehl_ps( temp1, samplex ); - samplex = _mm_add_ps( samplex, temp1 ); + temp1 = _mm_movehl_ps(temp1, samplex); + samplex = _mm_add_ps(samplex, temp1); temp1 = samplex; - temp1 = _mm_shuffle_ps( temp1, samplex, _MM_SHUFFLE(0, 0, 0, 1) ); - samplex = _mm_add_ps( samplex, temp1 ); - temp1 = _mm_set_ss( kernel_sum ); - samplex = _mm_mul_ps( samplex, temp1 ); - _mm_store_ss( out, samplex ); + temp1 = _mm_shuffle_ps(temp1, samplex, _MM_SHUFFLE(0, 0, 0, 1)); + samplex = _mm_add_ps(samplex, temp1); + temp1 = _mm_set_ss(kernel_sum); + samplex = _mm_mul_ps(samplex, temp1); + _mm_store_ss(out, samplex); ++out; - + phase += phase_inc; - + in += (int)phase; - + phase = fmod(phase, 1.0f); - } - while ( in < in_end ); - + } while (in < in_end); + r->phase = phase; *out_ = out; - + used = (int)(in - in_); - + r->write_filled -= used; } - + return used; } #endif #ifdef RESAMPLER_NEON -static int resampler_run_sinc(resampler * r, float ** out_, float * out_end) -{ +static int resampler_run_sinc(resampler *r, float **out_, float *out_end) { int in_size = r->write_filled; - float const* in_ = r->buffer_in + resampler_buffer_size + r->write_pos - r->write_filled; + float const *in_ = + r->buffer_in + resampler_buffer_size + r->write_pos - r->write_filled; int used = 0; in_size -= SINC_WIDTH * 2; - if ( in_size > 0 ) - { - float* out = *out_; - float const* in = in_; - float const* const in_end = in + in_size; + if (in_size > 0) { + float *out = *out_; + float const *in = in_; + float const *const in_end = in + in_size; float phase = r->phase; float phase_inc = r->phase_inc; - - int step = phase_inc > 1.0f ? (int)(RESAMPLER_RESOLUTION / phase_inc * RESAMPLER_SINC_CUTOFF) : (int)(RESAMPLER_RESOLUTION * RESAMPLER_SINC_CUTOFF); + + int step = phase_inc > 1.0f + ? (int)(RESAMPLER_RESOLUTION / phase_inc * + RESAMPLER_SINC_CUTOFF) + : (int)(RESAMPLER_RESOLUTION * RESAMPLER_SINC_CUTOFF); int window_step = RESAMPLER_RESOLUTION; - - do - { + + do { // accumulate in extended precision float kernel_sum = 0.0; float32x4_t kernel[SINC_WIDTH / 2]; float32x4_t temp1, temp2; float32x4_t samplex = {0}; float32x2_t half; - float *kernelf = (float*)(&kernel); + float *kernelf = (float *)(&kernel); int i = SINC_WIDTH; int phase_reduced = (int)(phase * RESAMPLER_RESOLUTION); int phase_adj = phase_reduced * step / RESAMPLER_RESOLUTION; - - if ( out >= out_end ) + + if (out >= out_end) break; - - for (; i >= -SINC_WIDTH + 1; --i) - { + + for (; i >= -SINC_WIDTH + 1; --i) { int pos = i * step; int window_pos = i * window_step; - kernel_sum += kernelf[i + SINC_WIDTH - 1] = sinc_lut[abs(phase_adj - pos)] * window_lut[abs(phase_reduced - window_pos)]; + kernel_sum += kernelf[i + SINC_WIDTH - 1] = + sinc_lut[abs(phase_adj - pos)] * + window_lut[abs(phase_reduced - window_pos)]; } - for (i = 0; i < SINC_WIDTH / 2; ++i) - { - temp1 = vld1q_f32( (const float32_t *)( in + i * 4 ) ); - temp2 = vld1q_f32( (const float32_t *)( kernel + i ) ); - samplex = vmlaq_f32( samplex, temp1, temp2 ); + for (i = 0; i < SINC_WIDTH / 2; ++i) { + temp1 = vld1q_f32((const float32_t *)(in + i * 4)); + temp2 = vld1q_f32((const float32_t *)(kernel + i)); + samplex = vmlaq_f32(samplex, temp1, temp2); } kernel_sum = 1.0 / kernel_sum; samplex = vmulq_f32(samplex, vmovq_n_f32(kernel_sum)); half = vadd_f32(vget_high_f32(samplex), vget_low_f32(samplex)); *out++ = vget_lane_f32(vpadd_f32(half, half), 0); - + phase += phase_inc; - + in += (int)phase; - + phase = fmod(phase, 1.0f); - } - while ( in < in_end ); - + } while (in < in_end); + r->phase = phase; *out_ = out; - + used = (int)(in - in_); - + r->write_filled -= used; } - + return used; } #endif -static void resampler_fill(resampler * r) -{ +static void resampler_fill(resampler *r) { int min_filled = resampler_min_filled(r); int quality = r->quality; - while ( r->write_filled > min_filled && - r->read_filled < resampler_buffer_size ) - { - int write_pos = ( r->read_pos + r->read_filled ) % resampler_buffer_size; + while (r->write_filled > min_filled && + r->read_filled < resampler_buffer_size) { + int write_pos = (r->read_pos + r->read_filled) % resampler_buffer_size; int write_size = resampler_buffer_size - write_pos; - float * out = r->buffer_out + write_pos; - if ( write_size > ( resampler_buffer_size - r->read_filled ) ) + float *out = r->buffer_out + write_pos; + if (write_size > (resampler_buffer_size - r->read_filled)) write_size = resampler_buffer_size - r->read_filled; - switch (quality) - { + switch (quality) { case RESAMPLER_QUALITY_ZOH: - resampler_run_zoh( r, &out, out + write_size ); + resampler_run_zoh(r, &out, out + write_size); break; - - case RESAMPLER_QUALITY_BLEP: - { + + case RESAMPLER_QUALITY_BLEP: { int used; int write_extra = 0; - if ( write_pos >= r->read_pos ) + if (write_pos >= r->read_pos) write_extra = r->read_pos; - if ( write_extra > SINC_WIDTH * 2 - 1 ) + if (write_extra > SINC_WIDTH * 2 - 1) write_extra = SINC_WIDTH * 2 - 1; - memcpy( r->buffer_out + resampler_buffer_size, r->buffer_out, write_extra * sizeof(r->buffer_out[0]) ); + memcpy(r->buffer_out + resampler_buffer_size, r->buffer_out, + write_extra * sizeof(r->buffer_out[0])); #ifdef RESAMPLER_SSE - if ( resampler_has_sse ) - used = resampler_run_blep_sse( r, &out, out + write_size + write_extra ); + if (resampler_has_sse) + used = resampler_run_blep_sse(r, &out, + out + write_size + write_extra); else #endif - used = resampler_run_blep( r, &out, out + write_size + write_extra ); - memcpy( r->buffer_out, r->buffer_out + resampler_buffer_size, write_extra * sizeof(r->buffer_out[0]) ); + used = + resampler_run_blep(r, &out, out + write_size + write_extra); + memcpy(r->buffer_out, r->buffer_out + resampler_buffer_size, + write_extra * sizeof(r->buffer_out[0])); if (!used) return; break; } - + case RESAMPLER_QUALITY_LINEAR: - resampler_run_linear( r, &out, out + write_size ); + resampler_run_linear(r, &out, out + write_size); break; - - case RESAMPLER_QUALITY_BLAM: - { - float * out_ = out; + + case RESAMPLER_QUALITY_BLAM: { + float *out_ = out; int write_extra = 0; - if ( write_pos >= r->read_pos ) + if (write_pos >= r->read_pos) write_extra = r->read_pos; - if ( write_extra > SINC_WIDTH * 2 - 1 ) + if (write_extra > SINC_WIDTH * 2 - 1) write_extra = SINC_WIDTH * 2 - 1; - memcpy( r->buffer_out + resampler_buffer_size, r->buffer_out, write_extra * sizeof(r->buffer_out[0]) ); + memcpy(r->buffer_out + resampler_buffer_size, r->buffer_out, + write_extra * sizeof(r->buffer_out[0])); #ifdef RESAMPLER_SSE - if ( resampler_has_sse ) - resampler_run_blam_sse( r, &out, out + write_size + write_extra ); + if (resampler_has_sse) + resampler_run_blam_sse(r, &out, out + write_size + write_extra); else #endif - resampler_run_blam( r, &out, out + write_size + write_extra ); - memcpy( r->buffer_out, r->buffer_out + resampler_buffer_size, write_extra * sizeof(r->buffer_out[0]) ); - if ( out == out_ ) + resampler_run_blam(r, &out, out + write_size + write_extra); + memcpy(r->buffer_out, r->buffer_out + resampler_buffer_size, + write_extra * sizeof(r->buffer_out[0])); + if (out == out_) return; break; } case RESAMPLER_QUALITY_CUBIC: #ifdef RESAMPLER_SSE - if ( resampler_has_sse ) - resampler_run_cubic_sse( r, &out, out + write_size ); + if (resampler_has_sse) + resampler_run_cubic_sse(r, &out, out + write_size); else #endif - resampler_run_cubic( r, &out, out + write_size ); + resampler_run_cubic(r, &out, out + write_size); break; - + case RESAMPLER_QUALITY_SINC: #ifdef RESAMPLER_SSE - if ( resampler_has_sse ) - resampler_run_sinc_sse( r, &out, out + write_size ); + if (resampler_has_sse) + resampler_run_sinc_sse(r, &out, out + write_size); else #endif - resampler_run_sinc( r, &out, out + write_size ); + resampler_run_sinc(r, &out, out + write_size); break; } r->read_filled += out - r->buffer_out - write_pos; } } -static void resampler_fill_and_remove_delay(resampler * r) -{ - resampler_fill( r ); - if ( r->delay_removed < 0 ) - { - int delay = resampler_output_delay( r ); +static void resampler_fill_and_remove_delay(resampler *r) { + resampler_fill(r); + if (r->delay_removed < 0) { + int delay = resampler_output_delay(r); r->delay_removed = 0; - while ( delay-- ) - resampler_remove_sample( r, 1 ); + while (delay--) + resampler_remove_sample(r, 1); } } -int resampler_get_sample_count(void *_r) -{ - resampler * r = ( resampler * ) _r; - if ( r->read_filled < 1 && ((r->quality != RESAMPLER_QUALITY_BLEP && r->quality != RESAMPLER_QUALITY_BLAM) || r->inv_phase_inc)) - resampler_fill_and_remove_delay( r ); +int resampler_get_sample_count(void *_r) { + resampler *r = (resampler *)_r; + if (r->read_filled < 1 && ((r->quality != RESAMPLER_QUALITY_BLEP && + r->quality != RESAMPLER_QUALITY_BLAM) || + r->inv_phase_inc)) + resampler_fill_and_remove_delay(r); return r->read_filled; } -int resampler_get_sample(void *_r) -{ - resampler * r = ( resampler * ) _r; - if ( r->read_filled < 1 && r->phase_inc) - resampler_fill_and_remove_delay( r ); - if ( r->read_filled < 1 ) +int resampler_get_sample(void *_r) { + resampler *r = (resampler *)_r; + if (r->read_filled < 1 && r->phase_inc) + resampler_fill_and_remove_delay(r); + if (r->read_filled < 1) return 0; - if ( r->quality == RESAMPLER_QUALITY_BLEP || r->quality == RESAMPLER_QUALITY_BLAM ) - return (int)(r->buffer_out[ r->read_pos ] + r->accumulator); + if (r->quality == RESAMPLER_QUALITY_BLEP || + r->quality == RESAMPLER_QUALITY_BLAM) + return (int)(r->buffer_out[r->read_pos] + r->accumulator); else - return (int)r->buffer_out[ r->read_pos ]; + return (int)r->buffer_out[r->read_pos]; } -float resampler_get_sample_float(void *_r) -{ - resampler * r = ( resampler * ) _r; - if ( r->read_filled < 1 && r->phase_inc) - resampler_fill_and_remove_delay( r ); - if ( r->read_filled < 1 ) +float resampler_get_sample_float(void *_r) { + resampler *r = (resampler *)_r; + if (r->read_filled < 1 && r->phase_inc) + resampler_fill_and_remove_delay(r); + if (r->read_filled < 1) return 0; - if ( r->quality == RESAMPLER_QUALITY_BLEP || r->quality == RESAMPLER_QUALITY_BLAM ) - return r->buffer_out[ r->read_pos ] + r->accumulator; + if (r->quality == RESAMPLER_QUALITY_BLEP || + r->quality == RESAMPLER_QUALITY_BLAM) + return r->buffer_out[r->read_pos] + r->accumulator; else - return r->buffer_out[ r->read_pos ]; + return r->buffer_out[r->read_pos]; } -void resampler_remove_sample(void *_r, int decay) -{ - resampler * r = ( resampler * ) _r; - if ( r->read_filled > 0 ) - { - if ( r->quality == RESAMPLER_QUALITY_BLEP || r->quality == RESAMPLER_QUALITY_BLAM ) - { - r->accumulator += r->buffer_out[ r->read_pos ]; - r->buffer_out[ r->read_pos ] = 0; - if (decay) - { +void resampler_remove_sample(void *_r, int decay) { + resampler *r = (resampler *)_r; + if (r->read_filled > 0) { + if (r->quality == RESAMPLER_QUALITY_BLEP || + r->quality == RESAMPLER_QUALITY_BLAM) { + r->accumulator += r->buffer_out[r->read_pos]; + r->buffer_out[r->read_pos] = 0; + if (decay) { r->accumulator -= r->accumulator * (1.0f / 8192.0f); if (fabs(r->accumulator) < 1e-20f) r->accumulator = 0; } } --r->read_filled; - r->read_pos = ( r->read_pos + 1 ) % resampler_buffer_size; + r->read_pos = (r->read_pos + 1) % resampler_buffer_size; } } diff --git a/Frameworks/Dumb/dumb/src/helpers/riff.c b/Frameworks/Dumb/dumb/src/helpers/riff.c index 188139a2e..f6e1dc2ea 100644 --- a/Frameworks/Dumb/dumb/src/helpers/riff.c +++ b/Frameworks/Dumb/dumb/src/helpers/riff.c @@ -3,83 +3,86 @@ #include -struct riff * riff_parse( DUMBFILE * f, long offset, long size, unsigned proper ) -{ - unsigned stream_size; - struct riff * stream; +struct riff *riff_parse(DUMBFILE *f, long offset, long size, unsigned proper) { + unsigned stream_size; + struct riff *stream; - if ( size < 8 ) return 0; + if (size < 8) + return 0; - if ( dumbfile_seek(f, offset, DFS_SEEK_SET) ) return 0; - if ( dumbfile_mgetl(f) != DUMB_ID('R','I','F','F') ) return 0; + if (dumbfile_seek(f, offset, DFS_SEEK_SET)) + return 0; + if (dumbfile_mgetl(f) != DUMB_ID('R', 'I', 'F', 'F')) + return 0; - stream_size = (int) dumbfile_igetl(f); - if ( stream_size + 8 > size ) return 0; - if ( stream_size < 4 ) return 0; + stream_size = (int)dumbfile_igetl(f); + if (stream_size + 8 > size) + return 0; + if (stream_size < 4) + return 0; - stream = (struct riff *) malloc( sizeof( struct riff ) ); - if ( ! stream ) return 0; + stream = (struct riff *)malloc(sizeof(struct riff)); + if (!stream) + return 0; - stream->type = (int) dumbfile_mgetl(f); - stream->chunk_count = 0; - stream->chunks = 0; + stream->type = (int)dumbfile_mgetl(f); + stream->chunk_count = 0; + stream->chunks = 0; - stream_size -= 4; + stream_size -= 4; - while ( stream_size && !dumbfile_error(f) ) - { - struct riff_chunk * chunk; - if ( stream_size < 8 ) break; - stream->chunks = ( struct riff_chunk * ) realloc( stream->chunks, ( stream->chunk_count + 1 ) * sizeof( struct riff_chunk ) ); - if ( ! stream->chunks ) break; - chunk = stream->chunks + stream->chunk_count; - chunk->type = (int) dumbfile_mgetl(f); - chunk->size = (int) dumbfile_igetl(f); + while (stream_size && !dumbfile_error(f)) { + struct riff_chunk *chunk; + if (stream_size < 8) + break; + stream->chunks = (struct riff_chunk *)realloc( + stream->chunks, + (stream->chunk_count + 1) * sizeof(struct riff_chunk)); + if (!stream->chunks) + break; + chunk = stream->chunks + stream->chunk_count; + chunk->type = (int)dumbfile_mgetl(f); + chunk->size = (int)dumbfile_igetl(f); chunk->offset = dumbfile_pos(f); - stream_size -= 8; - if ( stream_size < chunk->size ) break; - if ( chunk->type == DUMB_ID('R','I','F','F') ) - { - chunk->nested = riff_parse( f, chunk->offset - 8, chunk->size + 8, proper ); - if ( ! chunk->nested ) break; - } - else - { + stream_size -= 8; + if (stream_size < chunk->size) + break; + if (chunk->type == DUMB_ID('R', 'I', 'F', 'F')) { + chunk->nested = + riff_parse(f, chunk->offset - 8, chunk->size + 8, proper); + if (!chunk->nested) + break; + } else { chunk->nested = 0; - } + } dumbfile_seek(f, chunk->offset + chunk->size, DFS_SEEK_SET); - stream_size -= chunk->size; - if ( proper && ( chunk->size & 1 ) ) - { + stream_size -= chunk->size; + if (proper && (chunk->size & 1)) { dumbfile_skip(f, 1); - -- stream_size; - } - ++stream->chunk_count; - } - - if ( stream_size ) - { - riff_free( stream ); - stream = 0; - } + --stream_size; + } + ++stream->chunk_count; + } - return stream; + if (stream_size) { + riff_free(stream); + stream = 0; + } + + return stream; } -void riff_free( struct riff * stream ) -{ - if ( stream ) - { - if ( stream->chunks ) - { - unsigned i; - for ( i = 0; i < stream->chunk_count; ++i ) - { - struct riff_chunk * chunk = stream->chunks + i; - if ( chunk->nested ) riff_free( chunk->nested ); - } - free( stream->chunks ); - } - free( stream ); - } +void riff_free(struct riff *stream) { + if (stream) { + if (stream->chunks) { + unsigned i; + for (i = 0; i < stream->chunk_count; ++i) { + struct riff_chunk *chunk = stream->chunks + i; + if (chunk->nested) + riff_free(chunk->nested); + } + free(stream->chunks); + } + free(stream); + } } diff --git a/Frameworks/Dumb/dumb/src/helpers/sampbuf.c b/Frameworks/Dumb/dumb/src/helpers/sampbuf.c index 488db4490..bf031f1c9 100644 --- a/Frameworks/Dumb/dumb/src/helpers/sampbuf.c +++ b/Frameworks/Dumb/dumb/src/helpers/sampbuf.c @@ -20,45 +20,24 @@ #include #include "dumb.h" - - -/* DEPRECATED */ -sample_t **create_sample_buffer(int n_channels, long length) -{ - int i; - sample_t **samples = malloc(n_channels * sizeof(*samples)); - if (!samples) return NULL; - samples[0] = malloc(n_channels * length * sizeof(*samples[0])); - if (!samples[0]) { - free(samples); - return NULL; - } - for (i = 1; i < n_channels; i++) samples[i] = samples[i-1] + length; - return samples; +sample_t **allocate_sample_buffer(int n_channels, long length) { + int i; + sample_t **samples = malloc(((n_channels + 1) >> 1) * sizeof(*samples)); + if (!samples) + return NULL; + samples[0] = malloc(n_channels * length * sizeof(*samples[0])); + if (!samples[0]) { + free(samples); + return NULL; + } + for (i = 1; i<(n_channels + 1)>> 1; i++) + samples[i] = samples[i - 1] + length * 2; + return samples; } - - -sample_t **allocate_sample_buffer(int n_channels, long length) -{ - int i; - sample_t **samples = malloc(((n_channels + 1) >> 1) * sizeof(*samples)); - if (!samples) return NULL; - samples[0] = malloc(n_channels * length * sizeof(*samples[0])); - if (!samples[0]) { - free(samples); - return NULL; - } - for (i = 1; i < (n_channels + 1) >> 1; i++) samples[i] = samples[i-1] + length*2; - return samples; -} - - - -void destroy_sample_buffer(sample_t **samples) -{ - if (samples) { - free(samples[0]); - free(samples); - } +void destroy_sample_buffer(sample_t **samples) { + if (samples) { + free(samples[0]); + free(samples); + } } diff --git a/Frameworks/Dumb/dumb/src/helpers/silence.c b/Frameworks/Dumb/dumb/src/helpers/silence.c index 794ae8315..5bd841ca6 100644 --- a/Frameworks/Dumb/dumb/src/helpers/silence.c +++ b/Frameworks/Dumb/dumb/src/helpers/silence.c @@ -20,10 +20,6 @@ #include #include "dumb.h" - - -void dumb_silence(sample_t *samples, long length) -{ - memset(samples, 0, length * sizeof(*samples)); +void dumb_silence(sample_t *samples, long length) { + memset(samples, 0, length * sizeof(*samples)); } - diff --git a/Frameworks/Dumb/dumb/src/helpers/stdfile.c b/Frameworks/Dumb/dumb/src/helpers/stdfile.c index 0da786924..df9d49dfb 100644 --- a/Frameworks/Dumb/dumb/src/helpers/stdfile.c +++ b/Frameworks/Dumb/dumb/src/helpers/stdfile.c @@ -21,131 +21,93 @@ #include "dumb.h" - - -typedef struct dumb_stdfile -{ - FILE * file; - long size; +typedef struct dumb_stdfile { + FILE *file; + dumb_off_t size; } dumb_stdfile; - - -static void *dumb_stdfile_open(const char *filename) -{ - dumb_stdfile * file = ( dumb_stdfile * ) malloc( sizeof(dumb_stdfile) ); - if ( !file ) return 0; +static void *dumb_stdfile_open(const char *filename) { + dumb_stdfile *file = (dumb_stdfile *)malloc(sizeof(dumb_stdfile)); + if (!file) + return 0; file->file = fopen(filename, "rb"); - if ( !file->file ) - { - free( file ); + if (!file->file) { + free(file); return 0; } fseek(file->file, 0, SEEK_END); file->size = ftell(file->file); + if (file->size < 0) { + fclose(file->file); + free(file); + return 0; + } fseek(file->file, 0, SEEK_SET); return file; } - - -static int dumb_stdfile_skip(void *f, long n) -{ - dumb_stdfile * file = ( dumb_stdfile * ) f; +static int dumb_stdfile_skip(void *f, dumb_off_t n) { + dumb_stdfile *file = (dumb_stdfile *)f; return fseek(file->file, n, SEEK_CUR); } - - -static int dumb_stdfile_getc(void *f) -{ - dumb_stdfile * file = ( dumb_stdfile * ) f; +static int dumb_stdfile_getc(void *f) { + dumb_stdfile *file = (dumb_stdfile *)f; return fgetc(file->file); } - - -static long dumb_stdfile_getnc(char *ptr, long n, void *f) -{ - dumb_stdfile * file = ( dumb_stdfile * ) f; +static dumb_ssize_t dumb_stdfile_getnc(char *ptr, size_t n, void *f) { + dumb_stdfile *file = (dumb_stdfile *)f; return fread(ptr, 1, n, file->file); } - - -static void dumb_stdfile_close(void *f) -{ - dumb_stdfile * file = ( dumb_stdfile * ) f; +static void dumb_stdfile_close(void *f) { + dumb_stdfile *file = (dumb_stdfile *)f; fclose(file->file); free(f); } +static void dumb_stdfile_noclose(void *f) { free(f); } - -static void dumb_stdfile_noclose(void *f) -{ - free(f); -} - - - -static int dumb_stdfile_seek(void *f, long n) -{ - dumb_stdfile * file = ( dumb_stdfile * ) f; +static int dumb_stdfile_seek(void *f, dumb_off_t n) { + dumb_stdfile *file = (dumb_stdfile *)f; return fseek(file->file, n, SEEK_SET); } - - -static long dumb_stdfile_get_size(void *f) -{ - dumb_stdfile * file = ( dumb_stdfile * ) f; +static dumb_off_t dumb_stdfile_get_size(void *f) { + dumb_stdfile *file = (dumb_stdfile *)f; return file->size; } - - static const DUMBFILE_SYSTEM stdfile_dfs = { - &dumb_stdfile_open, - &dumb_stdfile_skip, - &dumb_stdfile_getc, - &dumb_stdfile_getnc, - &dumb_stdfile_close, - &dumb_stdfile_seek, - &dumb_stdfile_get_size -}; + &dumb_stdfile_open, &dumb_stdfile_skip, &dumb_stdfile_getc, + &dumb_stdfile_getnc, &dumb_stdfile_close, &dumb_stdfile_seek, + &dumb_stdfile_get_size}; +void dumb_register_stdfiles(void) { register_dumbfile_system(&stdfile_dfs); } +static const DUMBFILE_SYSTEM stdfile_dfs_leave_open = {NULL, + &dumb_stdfile_skip, + &dumb_stdfile_getc, + &dumb_stdfile_getnc, + &dumb_stdfile_noclose, + &dumb_stdfile_seek, + &dumb_stdfile_get_size}; -void dumb_register_stdfiles(void) -{ - register_dumbfile_system(&stdfile_dfs); -} - - - -static const DUMBFILE_SYSTEM stdfile_dfs_leave_open = { - NULL, - &dumb_stdfile_skip, - &dumb_stdfile_getc, - &dumb_stdfile_getnc, - &dumb_stdfile_noclose, - &dumb_stdfile_seek, - &dumb_stdfile_get_size -}; - - - -DUMBFILE *dumbfile_open_stdfile(FILE *p) -{ - dumb_stdfile * file = ( dumb_stdfile * ) malloc( sizeof(dumb_stdfile) ); - DUMBFILE *d; - if ( !file ) return 0; +DUMBFILE *dumbfile_open_stdfile(FILE *p) { + dumb_stdfile *file = (dumb_stdfile *)malloc(sizeof(dumb_stdfile)); + DUMBFILE *d; + if (!file) + return 0; file->file = p; fseek(p, 0, SEEK_END); file->size = ftell(p); + if (file->size < 0) { + free(file); + return 0; + } fseek(p, 0, SEEK_SET); d = dumbfile_open_ex(file, &stdfile_dfs_leave_open); - return d; + return d; } diff --git a/Frameworks/Dumb/dumb/src/helpers/tarray.c b/Frameworks/Dumb/dumb/src/helpers/tarray.c index f3ba422d8..d9b0ad1a8 100644 --- a/Frameworks/Dumb/dumb/src/helpers/tarray.c +++ b/Frameworks/Dumb/dumb/src/helpers/tarray.c @@ -2,174 +2,179 @@ #include - /* - Structures which contain the play times of each pattern and row combination in the song, - not guaranteed to be valid for the whole song until the loop status is no longer zero. - The initial count and restart count will both be zero on song start, then both will be - incremented until the song loops. Restart count will be reset to zero on loop for all - rows which have a time equal to or greater than the loop start point, so time keeping - functions will know which timestamp the song is currently located at. +/* + Structures which contain the play times of each pattern and row combination + in the song, not guaranteed to be valid for the whole song until the loop + status is no longer zero. The initial count and restart count will both be + zero on song start, then both will be incremented until the song loops. + Restart count will be reset to zero on loop for all rows which have a time + equal to or greater than the loop start point, so time keeping functions will + know which timestamp the song is currently located at. - Timestamp lists are guaranteed to be allocated in blocks of 16 timestamps at a time. - */ + Timestamp lists are guaranteed to be allocated in blocks of 16 timestamps at + a time. +*/ - /* - We don't need full timekeeping because the player loop only wants the first play time - of the loop start order/row. We also don't really want full timekeeping because it - involves a lot of memory allocations, which is also slow. - */ +/* + We don't need full timekeeping because the player loop only wants the first + play time of the loop start order/row. We also don't really want full + timekeeping because it involves a lot of memory allocations, which is also + slow. +*/ #undef FULL_TIMEKEEPING -typedef struct DUMB_IT_ROW_TIME -{ - unsigned int count, restart_count; +typedef struct DUMB_IT_ROW_TIME { + unsigned int count, restart_count; #ifndef FULL_TIMEKEEPING - LONG_LONG first_time; + LONG_LONG first_time; #else - LONG_LONG * times; + LONG_LONG *times; #endif } DUMB_IT_ROW_TIME; -void * timekeeping_array_create(size_t size) -{ - size_t * _size = (size_t *) calloc( 1, sizeof(size_t) + sizeof(DUMB_IT_ROW_TIME) * size ); - if ( _size ) { - *_size = size; - } - return _size; +void *timekeeping_array_create(size_t size) { + size_t *_size = + (size_t *)calloc(1, sizeof(size_t) + sizeof(DUMB_IT_ROW_TIME) * size); + if (_size) { + *_size = size; + } + return _size; } -void timekeeping_array_destroy(void * array) -{ +void timekeeping_array_destroy(void *array) { #ifdef FULL_TIMEKEEPING - size_t i; - size_t * size = (size_t *) array; - DUMB_IT_ROW_TIME * s = (DUMB_IT_ROW_TIME *)(size + 1); + size_t i; + size_t *size = (size_t *)array; + DUMB_IT_ROW_TIME *s = (DUMB_IT_ROW_TIME *)(size + 1); - for (i = 0; i < *size; i++) { - if (s[i].times) free(s[i].times); - } + for (i = 0; i < *size; i++) { + if (s[i].times) + free(s[i].times); + } #endif free(array); } -void * timekeeping_array_dup(void * array) -{ - size_t i; - size_t * size = (size_t *) array; - DUMB_IT_ROW_TIME * s = (DUMB_IT_ROW_TIME *)(size + 1); - size_t * new_size = (size_t *) calloc( 1, sizeof(size_t) + sizeof(DUMB_IT_ROW_TIME) * *size ); - if ( new_size ) { - DUMB_IT_ROW_TIME * new_s = (DUMB_IT_ROW_TIME *)(new_size + 1); +void *timekeeping_array_dup(void *array) { + size_t i; + size_t *size = (size_t *)array; + DUMB_IT_ROW_TIME *s = (DUMB_IT_ROW_TIME *)(size + 1); + size_t *new_size = + (size_t *)calloc(1, sizeof(size_t) + sizeof(DUMB_IT_ROW_TIME) * *size); + if (new_size) { + DUMB_IT_ROW_TIME *new_s = (DUMB_IT_ROW_TIME *)(new_size + 1); - *new_size = *size; + *new_size = *size; - for (i = 0; i < *size; i++) { - new_s[i].count = s[i].count; - new_s[i].restart_count = s[i].restart_count; + for (i = 0; i < *size; i++) { + new_s[i].count = s[i].count; + new_s[i].restart_count = s[i].restart_count; #ifndef FULL_TIMEKEEPING - new_s[i].first_time = s[i].first_time; + new_s[i].first_time = s[i].first_time; #else - if ( s[i].times ) { - size_t time_count = ( s[i].count + 15 ) & ~15; - new_s[i].times = (LONG_LONG *) malloc( sizeof(LONG_LONG) * time_count ); - if ( new_s[i].times == (void *)0 ) { - timekeeping_array_destroy( new_size ); - return (void *) 0; - } - memcpy( new_s[i].times, s[i].times, sizeof(LONG_LONG) * s[i].count ); - } + if (s[i].times) { + size_t time_count = (s[i].count + 15) & ~15; + new_s[i].times = + (LONG_LONG *)malloc(sizeof(LONG_LONG) * time_count); + if (new_s[i].times == (void *)0) { + timekeeping_array_destroy(new_size); + return (void *)0; + } + memcpy(new_s[i].times, s[i].times, + sizeof(LONG_LONG) * s[i].count); + } #endif - } - } + } + } - return new_size; + return new_size; } -void timekeeping_array_reset(void * array, size_t loop_start) -{ - size_t i; - size_t * size = (size_t *) array; - DUMB_IT_ROW_TIME * s = (DUMB_IT_ROW_TIME *)(size + 1); +void timekeeping_array_reset(void *array, size_t loop_start) { + size_t i; + size_t *size = (size_t *)array; + DUMB_IT_ROW_TIME *s = (DUMB_IT_ROW_TIME *)(size + 1); - DUMB_IT_ROW_TIME * s_loop_start = s + loop_start; - LONG_LONG loop_start_time; + DUMB_IT_ROW_TIME *s_loop_start = s + loop_start; + LONG_LONG loop_start_time; - if ( loop_start >= *size || s_loop_start->count < 1 ) return; + if (loop_start >= *size || s_loop_start->count < 1) + return; #ifndef FULL_TIMEKEEPING - loop_start_time = s_loop_start->first_time; + loop_start_time = s_loop_start->first_time; #else - loop_start_time = s_loop_start->times[0]; + loop_start_time = s_loop_start->times[0]; #endif - for ( i = 0; i < *size; i++ ) { + for (i = 0; i < *size; i++) { #ifndef FULL_TIMEKEEPING - if ( s[i].count && s[i].first_time >= loop_start_time ) { + if (s[i].count && s[i].first_time >= loop_start_time) { #else - if ( s[i].count && s[i].times[0] >= loop_start_time ) { + if (s[i].count && s[i].times[0] >= loop_start_time) { #endif - s[i].restart_count = 0; - } - } + s[i].restart_count = 0; + } + } } -void timekeeping_array_push(void * array, size_t index, LONG_LONG time) -{ +void timekeeping_array_push(void *array, size_t index, LONG_LONG time) { #ifdef FULL_TIMEKEEPING - size_t i; + size_t i; size_t time_count; #endif - size_t * size = (size_t *) array; - DUMB_IT_ROW_TIME * s = (DUMB_IT_ROW_TIME *)(size + 1); + size_t *size = (size_t *)array; + DUMB_IT_ROW_TIME *s = (DUMB_IT_ROW_TIME *)(size + 1); - if (index >= *size) return; + if (index >= *size) + return; #ifndef FULL_TIMEKEEPING - if ( !s[index].count++ ) - s[index].first_time = time; + if (!s[index].count++) + s[index].first_time = time; #else - time_count = ( s[index].count + 16 ) & ~15; + time_count = (s[index].count + 16) & ~15; - s[index].times = (LONG_LONG *) realloc( s[index].times, sizeof(LONG_LONG) * time_count ); + s[index].times = + (LONG_LONG *)realloc(s[index].times, sizeof(LONG_LONG) * time_count); - s[index].times[s[index].count++] = time; + s[index].times[s[index].count++] = time; #endif } -void timekeeping_array_bump(void * array, size_t index) -{ - size_t * size = (size_t *) array; - DUMB_IT_ROW_TIME * s = (DUMB_IT_ROW_TIME *)(size + 1); +void timekeeping_array_bump(void *array, size_t index) { + size_t *size = (size_t *)array; + DUMB_IT_ROW_TIME *s = (DUMB_IT_ROW_TIME *)(size + 1); - if (index >= *size) return; + if (index >= *size) + return; - s[index].restart_count++; + s[index].restart_count++; } -unsigned int timekeeping_array_get_count(void * array, size_t index) -{ - size_t * size = (size_t *) array; - DUMB_IT_ROW_TIME * s = (DUMB_IT_ROW_TIME *)(size + 1); +unsigned int timekeeping_array_get_count(void *array, size_t index) { + size_t *size = (size_t *)array; + DUMB_IT_ROW_TIME *s = (DUMB_IT_ROW_TIME *)(size + 1); - if (index >= *size) return 0; + if (index >= *size) + return 0; - return s[index].count; + return s[index].count; } -LONG_LONG timekeeping_array_get_item(void * array, size_t index) -{ - size_t * size = (size_t *) array; - DUMB_IT_ROW_TIME * s = (DUMB_IT_ROW_TIME *)(size + 1); +LONG_LONG timekeeping_array_get_item(void *array, size_t index) { + size_t *size = (size_t *)array; + DUMB_IT_ROW_TIME *s = (DUMB_IT_ROW_TIME *)(size + 1); - if (index >= *size || s[index].restart_count >= s[index].count) return 0; + if (index >= *size || s[index].restart_count >= s[index].count) + return 0; #ifndef FULL_TIMEKEEPING - return s[index].first_time; + return s[index].first_time; #else - return s[index].times[s[index].restart_count]; + return s[index].times[s[index].restart_count]; #endif } diff --git a/Frameworks/Dumb/dumb/src/it/itload.c b/Frameworks/Dumb/dumb/src/it/itload.c index 300042330..c0d274f21 100644 --- a/Frameworks/Dumb/dumb/src/it/itload.c +++ b/Frameworks/Dumb/dumb/src/it/itload.c @@ -20,24 +20,20 @@ #include "dumb.h" #include "internal/it.h" - - /* dumb_load_it_quick(): loads an IT file into a DUH struct, returning a * pointer to the DUH struct. When you have finished with it, you must pass * the pointer to unload_duh() so that the memory can be freed. */ -DUH *dumb_load_it_quick(const char *filename) -{ - DUH *duh; - DUMBFILE *f = dumbfile_open(filename); +DUH *dumb_load_it_quick(const char *filename) { + DUH *duh; + DUMBFILE *f = dumbfile_open(filename); - if (!f) - return NULL; + if (!f) + return NULL; - duh = dumb_read_it_quick(f); + duh = dumb_read_it_quick(f); - dumbfile_close(f); + dumbfile_close(f); - return duh; + return duh; } - diff --git a/Frameworks/Dumb/dumb/src/it/itload2.c b/Frameworks/Dumb/dumb/src/it/itload2.c index 15cff1d0a..a9050ba1a 100644 --- a/Frameworks/Dumb/dumb/src/it/itload2.c +++ b/Frameworks/Dumb/dumb/src/it/itload2.c @@ -19,11 +19,8 @@ #include "dumb.h" - - -DUH *dumb_load_it(const char *filename) -{ - DUH *duh = dumb_load_it_quick(filename); - dumb_it_do_initial_runthrough(duh); - return duh; +DUH *dumb_load_it(const char *filename) { + DUH *duh = dumb_load_it_quick(filename); + dumb_it_do_initial_runthrough(duh); + return duh; } diff --git a/Frameworks/Dumb/dumb/src/it/itmisc.c b/Frameworks/Dumb/dumb/src/it/itmisc.c index ea1170e4d..e88714b74 100644 --- a/Frameworks/Dumb/dumb/src/it/itmisc.c +++ b/Frameworks/Dumb/dumb/src/it/itmisc.c @@ -20,230 +20,150 @@ #include "dumb.h" #include "internal/it.h" - int dumb_it_default_panning_separation = 25; - -DUMB_IT_SIGDATA *duh_get_it_sigdata(DUH *duh) -{ - return duh_get_raw_sigdata(duh, -1, SIGTYPE_IT); +DUMB_IT_SIGDATA *duh_get_it_sigdata(DUH *duh) { + return duh_get_raw_sigdata(duh, -1, SIGTYPE_IT); } - - -const unsigned char *dumb_it_sd_get_song_message(DUMB_IT_SIGDATA *sd) -{ - return sd ? sd->song_message : NULL; +const unsigned char *dumb_it_sd_get_song_message(DUMB_IT_SIGDATA *sd) { + return sd ? sd->song_message : NULL; } - - -int dumb_it_sd_get_n_orders(DUMB_IT_SIGDATA *sd) -{ - return sd ? sd->n_orders : 0; +int dumb_it_sd_get_n_orders(DUMB_IT_SIGDATA *sd) { + return sd ? sd->n_orders : 0; } - - -int dumb_it_sd_get_n_samples(DUMB_IT_SIGDATA *sd) -{ - return sd ? sd->n_samples : 0; +int dumb_it_sd_get_n_samples(DUMB_IT_SIGDATA *sd) { + return sd ? sd->n_samples : 0; } - - -int dumb_it_sd_get_n_instruments(DUMB_IT_SIGDATA *sd) -{ - return sd ? sd->n_instruments : 0; +int dumb_it_sd_get_n_instruments(DUMB_IT_SIGDATA *sd) { + return sd ? sd->n_instruments : 0; } - - -const unsigned char *dumb_it_sd_get_sample_name(DUMB_IT_SIGDATA *sd, int i) -{ - ASSERT(sd && sd->sample && i >= 0 && i < sd->n_samples); - return sd->sample[i].name; +const unsigned char *dumb_it_sd_get_sample_name(DUMB_IT_SIGDATA *sd, int i) { + ASSERT(sd && sd->sample && i >= 0 && i < sd->n_samples); + return sd->sample[i].name; } - - -const unsigned char *dumb_it_sd_get_sample_filename(DUMB_IT_SIGDATA *sd, int i) -{ - ASSERT(sd && sd->sample && i >= 0 && i < sd->n_samples); - return sd->sample[i].filename; +const unsigned char *dumb_it_sd_get_sample_filename(DUMB_IT_SIGDATA *sd, + int i) { + ASSERT(sd && sd->sample && i >= 0 && i < sd->n_samples); + return sd->sample[i].filename; } - - -const unsigned char *dumb_it_sd_get_instrument_name(DUMB_IT_SIGDATA *sd, int i) -{ - ASSERT(sd && sd->instrument && i >= 0 && i < sd->n_instruments); - return sd->instrument[i].name; +const unsigned char *dumb_it_sd_get_instrument_name(DUMB_IT_SIGDATA *sd, + int i) { + ASSERT(sd && sd->instrument && i >= 0 && i < sd->n_instruments); + return sd->instrument[i].name; } - - -const unsigned char *dumb_it_sd_get_instrument_filename(DUMB_IT_SIGDATA *sd, int i) -{ - ASSERT(sd && sd->instrument && i >= 0 && i < sd->n_instruments); - return sd->instrument[i].filename; +const unsigned char *dumb_it_sd_get_instrument_filename(DUMB_IT_SIGDATA *sd, + int i) { + ASSERT(sd && sd->instrument && i >= 0 && i < sd->n_instruments); + return sd->instrument[i].filename; } - - -int dumb_it_sd_get_initial_global_volume(DUMB_IT_SIGDATA *sd) -{ - return sd ? sd->global_volume : 0; +int dumb_it_sd_get_initial_global_volume(DUMB_IT_SIGDATA *sd) { + return sd ? sd->global_volume : 0; } - - -void dumb_it_sd_set_initial_global_volume(DUMB_IT_SIGDATA *sd, int gv) -{ - if (sd) sd->global_volume = gv; +void dumb_it_sd_set_initial_global_volume(DUMB_IT_SIGDATA *sd, int gv) { + if (sd) + sd->global_volume = gv; } - - -int dumb_it_sd_get_mixing_volume(DUMB_IT_SIGDATA *sd) -{ - return sd ? sd->mixing_volume : 0; +int dumb_it_sd_get_mixing_volume(DUMB_IT_SIGDATA *sd) { + return sd ? sd->mixing_volume : 0; } - - -void dumb_it_sd_set_mixing_volume(DUMB_IT_SIGDATA *sd, int mv) -{ - if (sd) sd->mixing_volume = mv; +void dumb_it_sd_set_mixing_volume(DUMB_IT_SIGDATA *sd, int mv) { + if (sd) + sd->mixing_volume = mv; } - - -int dumb_it_sd_get_initial_speed(DUMB_IT_SIGDATA *sd) -{ - return sd ? sd->speed : 0; +int dumb_it_sd_get_initial_speed(DUMB_IT_SIGDATA *sd) { + return sd ? sd->speed : 0; } - - -void dumb_it_sd_set_initial_speed(DUMB_IT_SIGDATA *sd, int speed) -{ - if (sd) sd->speed = speed; +void dumb_it_sd_set_initial_speed(DUMB_IT_SIGDATA *sd, int speed) { + if (sd) + sd->speed = speed; } - - -int dumb_it_sd_get_initial_tempo(DUMB_IT_SIGDATA *sd) -{ - return sd ? sd->tempo : 0; +int dumb_it_sd_get_initial_tempo(DUMB_IT_SIGDATA *sd) { + return sd ? sd->tempo : 0; } - - -void dumb_it_sd_set_initial_tempo(DUMB_IT_SIGDATA *sd, int tempo) -{ - if (sd) sd->tempo = tempo; +void dumb_it_sd_set_initial_tempo(DUMB_IT_SIGDATA *sd, int tempo) { + if (sd) + sd->tempo = tempo; } - - -int dumb_it_sd_get_initial_channel_volume(DUMB_IT_SIGDATA *sd, int channel) -{ - ASSERT(channel >= 0 && channel < DUMB_IT_N_CHANNELS); - return sd ? sd->channel_volume[channel] : 0; +int dumb_it_sd_get_initial_channel_volume(DUMB_IT_SIGDATA *sd, int channel) { + ASSERT(channel >= 0 && channel < DUMB_IT_N_CHANNELS); + return sd ? sd->channel_volume[channel] : 0; } -void dumb_it_sd_set_initial_channel_volume(DUMB_IT_SIGDATA *sd, int channel, int volume) -{ - ASSERT(channel >= 0 && channel < DUMB_IT_N_CHANNELS); - if (sd) sd->channel_volume[channel] = volume; +void dumb_it_sd_set_initial_channel_volume(DUMB_IT_SIGDATA *sd, int channel, + int volume) { + ASSERT(channel >= 0 && channel < DUMB_IT_N_CHANNELS); + if (sd) + sd->channel_volume[channel] = volume; } - - -int dumb_it_sr_get_current_order(DUMB_IT_SIGRENDERER *sr) -{ - return sr ? sr->order : -1; +int dumb_it_sr_get_current_order(DUMB_IT_SIGRENDERER *sr) { + return sr ? sr->order : -1; } - - -int dumb_it_sr_get_current_row(DUMB_IT_SIGRENDERER *sr) -{ - return sr ? sr->row : -1; +int dumb_it_sr_get_current_row(DUMB_IT_SIGRENDERER *sr) { + return sr ? sr->row : -1; } - - -int dumb_it_sr_get_global_volume(DUMB_IT_SIGRENDERER *sr) -{ - return sr ? sr->globalvolume : 0; +int dumb_it_sr_get_global_volume(DUMB_IT_SIGRENDERER *sr) { + return sr ? sr->globalvolume : 0; } - - -void dumb_it_sr_set_global_volume(DUMB_IT_SIGRENDERER *sr, int gv) -{ - if (sr) sr->globalvolume = gv; +void dumb_it_sr_set_global_volume(DUMB_IT_SIGRENDERER *sr, int gv) { + if (sr) + sr->globalvolume = gv; } +int dumb_it_sr_get_tempo(DUMB_IT_SIGRENDERER *sr) { return sr ? sr->tempo : 0; } - -int dumb_it_sr_get_tempo(DUMB_IT_SIGRENDERER *sr) -{ - return sr ? sr->tempo : 0; +void dumb_it_sr_set_tempo(DUMB_IT_SIGRENDERER *sr, int tempo) { + if (sr) + sr->tempo = tempo; } +int dumb_it_sr_get_speed(DUMB_IT_SIGRENDERER *sr) { return sr ? sr->speed : 0; } - -void dumb_it_sr_set_tempo(DUMB_IT_SIGRENDERER *sr, int tempo) -{ - if (sr) sr->tempo = tempo; +void dumb_it_sr_set_speed(DUMB_IT_SIGRENDERER *sr, int speed) { + if (sr) + sr->speed = speed; } - - -int dumb_it_sr_get_speed(DUMB_IT_SIGRENDERER *sr) -{ - return sr ? sr->speed : 0; +int dumb_it_sr_get_channel_volume(DUMB_IT_SIGRENDERER *sr, int channel) { + return sr ? sr->channel[channel].channelvolume : 0; } - - -void dumb_it_sr_set_speed(DUMB_IT_SIGRENDERER *sr, int speed) -{ - if (sr) sr->speed = speed; +void dumb_it_sr_set_channel_volume(DUMB_IT_SIGRENDERER *sr, int channel, + int volume) { + if (sr) + sr->channel[channel].channelvolume = volume; } - - -int dumb_it_sr_get_channel_volume(DUMB_IT_SIGRENDERER *sr, int channel) -{ - return sr ? sr->channel[channel].channelvolume : 0; +void dumb_it_sr_set_channel_muted(DUMB_IT_SIGRENDERER *sr, int channel, + int muted) { + if (sr) { + if (muted) + sr->channel[channel].flags |= IT_CHANNEL_MUTED; + else + sr->channel[channel].flags &= ~IT_CHANNEL_MUTED; + } } - - -void dumb_it_sr_set_channel_volume(DUMB_IT_SIGRENDERER *sr, int channel, int volume) -{ - if (sr) sr->channel[channel].channelvolume = volume; -} - - - -void dumb_it_sr_set_channel_muted(DUMB_IT_SIGRENDERER *sr, int channel, int muted) -{ - if (sr) { - if (muted) - sr->channel[channel].flags |= IT_CHANNEL_MUTED; - else - sr->channel[channel].flags &= ~IT_CHANNEL_MUTED; - } -} - - - -int dumb_it_sr_get_channel_muted(DUMB_IT_SIGRENDERER *sr, int channel) -{ - return sr ? (sr->channel[channel].flags & IT_CHANNEL_MUTED) != 0 : 0; +int dumb_it_sr_get_channel_muted(DUMB_IT_SIGRENDERER *sr, int channel) { + return sr ? (sr->channel[channel].flags & IT_CHANNEL_MUTED) != 0 : 0; } diff --git a/Frameworks/Dumb/dumb/src/it/itorder.c b/Frameworks/Dumb/dumb/src/it/itorder.c index c3fe51cbe..1fa5ed31c 100644 --- a/Frameworks/Dumb/dumb/src/it/itorder.c +++ b/Frameworks/Dumb/dumb/src/it/itorder.c @@ -17,47 +17,45 @@ * \__/ */ - - #include #include "dumb.h" #include "internal/it.h" - - /* This function ensures that any pattern mentioned in the order table but * not present in the pattern table is treated as an empty 64 rows pattern. * This is done by adding such a dummy pattern at the end of the pattern * table, and redirect invalid orders to it. * Patterns 254 and 255 are left untouched, unless the signal is an XM. */ -int _dumb_it_fix_invalid_orders(DUMB_IT_SIGDATA *sigdata) -{ - int i; - int found_some = 0; +int _dumb_it_fix_invalid_orders(DUMB_IT_SIGDATA *sigdata) { + int i; + int found_some = 0; - int first_invalid = sigdata->n_patterns; - int last_invalid = (sigdata->flags & IT_WAS_AN_XM) ? 255 : 253; + int first_invalid = sigdata->n_patterns; + int last_invalid = (sigdata->flags & IT_WAS_AN_XM) ? 255 : 253; - for (i = 0; i < sigdata->n_orders; i++) { - if (sigdata->order[i] >= first_invalid && sigdata->order[i] <= last_invalid) { - sigdata->order[i] = sigdata->n_patterns; - found_some = 1; - } - } + for (i = 0; i < sigdata->n_orders; i++) { + if (sigdata->order[i] >= first_invalid && + sigdata->order[i] <= last_invalid) { + sigdata->order[i] = sigdata->n_patterns; + found_some = 1; + } + } - if (found_some) { - IT_PATTERN *new_pattern = realloc(sigdata->pattern, sizeof(*sigdata->pattern) * (sigdata->n_patterns + 1)); - if (!new_pattern) - return -1; - - new_pattern[sigdata->n_patterns].n_rows = 64; - new_pattern[sigdata->n_patterns].n_entries = 0; - new_pattern[sigdata->n_patterns].entry = NULL; - sigdata->pattern = new_pattern; - sigdata->n_patterns++; - } + if (found_some) { + IT_PATTERN *new_pattern = + realloc(sigdata->pattern, + sizeof(*sigdata->pattern) * (sigdata->n_patterns + 1)); + if (!new_pattern) + return -1; - return 0; + new_pattern[sigdata->n_patterns].n_rows = 64; + new_pattern[sigdata->n_patterns].n_entries = 0; + new_pattern[sigdata->n_patterns].entry = NULL; + sigdata->pattern = new_pattern; + sigdata->n_patterns++; + } + + return 0; } diff --git a/Frameworks/Dumb/dumb/src/it/itread.c b/Frameworks/Dumb/dumb/src/it/itread.c index b9a2d02bc..33b6c6e6b 100644 --- a/Frameworks/Dumb/dumb/src/it/itread.c +++ b/Frameworks/Dumb/dumb/src/it/itread.c @@ -18,7 +18,7 @@ */ #include -#include //might not be necessary later; required for memset +#include //might not be necessary later; required for memset #include "dumb.h" #include "internal/it.h" @@ -27,11 +27,8 @@ #define min(a, b) (((a) < (b)) ? (a) : (b)) #endif - //#define INVESTIGATE_OLD_INSTRUMENTS - - typedef unsigned char byte; typedef unsigned short word; typedef unsigned long dword; @@ -39,1324 +36,1361 @@ typedef unsigned long dword; typedef struct readblock_crap readblock_crap; struct readblock_crap { - unsigned char *sourcebuf; - unsigned char *sourcepos; - unsigned char *sourceend; - int rembits; + unsigned char *sourcebuf; + unsigned char *sourcepos; + unsigned char *sourceend; + int rembits; }; +static int readblock(DUMBFILE *f, readblock_crap *crap) { + long size; + int c; -static int readblock(DUMBFILE *f, readblock_crap * crap) -{ - long size; - int c; + size = dumbfile_igetw(f); + if (size < 0) + return (int)size; - size = dumbfile_igetw(f); - if (size < 0) - return (int)size; + crap->sourcebuf = malloc(size); + if (!crap->sourcebuf) + return -1; - crap->sourcebuf = malloc(size); - if (!crap->sourcebuf) - return -1; + c = (int)dumbfile_getnc((char *)crap->sourcebuf, size, f); + if (c < size) { + free(crap->sourcebuf); + crap->sourcebuf = NULL; + return -1; + } - c = (int)dumbfile_getnc((char *)crap->sourcebuf, size, f); - if (c < size) { - free(crap->sourcebuf); - crap->sourcebuf = NULL; - return -1; - } - - crap->sourcepos = crap->sourcebuf; - crap->sourceend = crap->sourcebuf + size; - crap->rembits = 8; - return 0; + crap->sourcepos = crap->sourcebuf; + crap->sourceend = crap->sourcebuf + size; + crap->rembits = 8; + return 0; } - - -static void freeblock(readblock_crap * crap) -{ - free(crap->sourcebuf); - crap->sourcebuf = NULL; +static void freeblock(readblock_crap *crap) { + free(crap->sourcebuf); + crap->sourcebuf = NULL; } +static int readbits(int bitwidth, readblock_crap *crap) { + int val = 0; + int b = 0; + if (crap->sourcepos >= crap->sourceend) + return val; -static int readbits(int bitwidth, readblock_crap * crap) -{ - int val = 0; - int b = 0; + while (bitwidth > crap->rembits) { + val |= *crap->sourcepos++ << b; + if (crap->sourcepos >= crap->sourceend) + return val; + b += crap->rembits; + bitwidth -= crap->rembits; + crap->rembits = 8; + } - if (crap->sourcepos >= crap->sourceend) return val; + val |= (*crap->sourcepos & ((1 << bitwidth) - 1)) << b; + *crap->sourcepos >>= bitwidth; + crap->rembits -= bitwidth; - while (bitwidth > crap->rembits) { - val |= *crap->sourcepos++ << b; - if (crap->sourcepos >= crap->sourceend) return val; - b += crap->rembits; - bitwidth -= crap->rembits; - crap->rembits = 8; - } - - val |= (*crap->sourcepos & ((1 << bitwidth) - 1)) << b; - *crap->sourcepos >>= bitwidth; - crap->rembits -= bitwidth; - - return val; + return val; } - - /** WARNING - do we even need to pass `right`? */ /** WARNING - why bother memsetting at all? The whole array is written... */ // if we do memset, dumb_silence() would be neater... -static int decompress8(DUMBFILE *f, signed char *data, int len, int it215, int stereo) -{ - int blocklen, blockpos; - byte bitwidth; - word val; - signed char d1, d2; - readblock_crap crap; +static int decompress8(DUMBFILE *f, signed char *data, int len, int it215, + int stereo) { + int blocklen, blockpos; + byte bitwidth; + word val; + signed char d1, d2; + readblock_crap crap; - memset(&crap, 0, sizeof(crap)); + memset(&crap, 0, sizeof(crap)); - for (blocklen = 0, blockpos = 0; blocklen < len; blocklen++, blockpos += 1 + stereo) - data[ blockpos ] = 0; + for (blocklen = 0, blockpos = 0; blocklen < len; + blocklen++, blockpos += 1 + stereo) + data[blockpos] = 0; - while (len > 0) { - //Read a block of compressed data: - if (readblock(f, &crap)) - return -1; - //Set up a few variables - blocklen = (len < 0x8000) ? len : 0x8000; //Max block length is 0x8000 bytes - blockpos = 0; - bitwidth = 9; - d1 = d2 = 0; - //Start the decompression: - while (blockpos < blocklen) { - //Read a value: - val = (word)readbits(bitwidth, &crap); - //Check for bit width change: + while (len > 0) { + // Read a block of compressed data: + if (readblock(f, &crap)) + return -1; + // Set up a few variables + blocklen = + (len < 0x8000) ? len : 0x8000; // Max block length is 0x8000 bytes + blockpos = 0; + bitwidth = 9; + d1 = d2 = 0; + // Start the decompression: + while (blockpos < blocklen) { + // Read a value: + val = (word)readbits(bitwidth, &crap); + // Check for bit width change: - if (bitwidth < 7) { //Method 1: - if (val == (1 << (bitwidth - 1))) { - val = (word)readbits(3, &crap) + 1; - bitwidth = (val < bitwidth) ? val : val + 1; - continue; - } - } - else if (bitwidth < 9) { //Method 2 - byte border = (0xFF >> (9 - bitwidth)) - 4; + if (bitwidth < 7) { // Method 1: + if (val == (1 << (bitwidth - 1))) { + val = (word)readbits(3, &crap) + 1; + bitwidth = (val < bitwidth) ? val : val + 1; + continue; + } + } else if (bitwidth < 9) { // Method 2 + byte border = (0xFF >> (9 - bitwidth)) - 4; - if (val > border && val <= (border + 8)) { - val -= border; - bitwidth = (val < bitwidth) ? val : val + 1; - continue; - } - } - else if (bitwidth == 9) { //Method 3 - if (val & 0x100) { - bitwidth = (val + 1) & 0xFF; - continue; - } - } - else { //Illegal width, abort ? - freeblock(&crap); - return -1; - } + if (val > border && val <= (border + 8)) { + val -= border; + bitwidth = (val < bitwidth) ? val : val + 1; + continue; + } + } else if (bitwidth == 9) { // Method 3 + if (val & 0x100) { + bitwidth = (val + 1) & 0xFF; + continue; + } + } else { // Illegal width, abort ? + freeblock(&crap); + return -1; + } - //Expand the value to signed byte: - { - signed char v; //The sample value: - if (bitwidth < 8) { - byte shift = 8 - bitwidth; - v = (val << shift); - v >>= shift; - } - else - v = (signed char)val; + // Expand the value to signed byte: + { + signed char v; // The sample value: + if (bitwidth < 8) { + byte shift = 8 - bitwidth; + v = (val << shift); + v >>= shift; + } else + v = (signed char)val; - //And integrate the sample value - //(It always has to end with integration doesn't it ? ;-) - d1 += v; - d2 += d1; - } + // And integrate the sample value + //(It always has to end with integration doesn't it ? ;-) + d1 += v; + d2 += d1; + } - //Store ! - /* Version 2.15 was an unofficial version with hacked compression - * code. Yay, better compression :D - */ - *data++ = it215 ? d2 : d1; - data += stereo; - len--; - blockpos++; - } - freeblock(&crap); - } - return 0; + // Store ! + /* Version 2.15 was an unofficial version with hacked compression + * code. Yay, better compression :D + */ + *data++ = it215 ? d2 : d1; + data += stereo; + len--; + blockpos++; + } + freeblock(&crap); + } + return 0; } +static int decompress16(DUMBFILE *f, short *data, int len, int it215, + int stereo) { + int blocklen, blockpos; + byte bitwidth; + long val; + signed short d1, d2; + readblock_crap crap; + memset(&crap, 0, sizeof(crap)); -static int decompress16(DUMBFILE *f, short *data, int len, int it215, int stereo) -{ - int blocklen, blockpos; - byte bitwidth; - long val; - signed short d1, d2; - readblock_crap crap; + for (blocklen = 0, blockpos = 0; blocklen < len; + blocklen++, blockpos += 1 + stereo) + data[blockpos] = 0; - memset(&crap, 0, sizeof(crap)); + while (len > 0) { + // Read a block of compressed data: + if (readblock(f, &crap)) + return -1; + // Set up a few variables + blocklen = + (len < 0x4000) ? len : 0x4000; // Max block length is 0x4000 bytes + blockpos = 0; + bitwidth = 17; + d1 = d2 = 0; + // Start the decompression: + while (blockpos < blocklen) { + val = readbits(bitwidth, &crap); + // Check for bit width change: - for ( blocklen = 0, blockpos = 0; blocklen < len; blocklen++, blockpos += 1 + stereo ) - data[ blockpos ] = 0; + if (bitwidth < 7) { // Method 1: + if (val == (1 << (bitwidth - 1))) { + val = readbits(4, &crap) + 1; + bitwidth = (val < bitwidth) ? val : val + 1; + continue; + } + } else if (bitwidth < 17) { // Method 2 + word border = (0xFFFF >> (17 - bitwidth)) - 8; - while (len > 0) { - //Read a block of compressed data: - if (readblock(f, &crap)) - return -1; - //Set up a few variables - blocklen = (len < 0x4000) ? len : 0x4000; // Max block length is 0x4000 bytes - blockpos = 0; - bitwidth = 17; - d1 = d2 = 0; - //Start the decompression: - while (blockpos < blocklen) { - val = readbits(bitwidth, &crap); - //Check for bit width change: + if (val > border && val <= (border + 16)) { + val -= border; + bitwidth = val < bitwidth ? val : val + 1; + continue; + } + } else if (bitwidth == 17) { // Method 3 + if (val & 0x10000) { + bitwidth = (val + 1) & 0xFF; + continue; + } + } else { // Illegal width, abort ? + freeblock(&crap); + return -1; + } - if (bitwidth < 7) { //Method 1: - if (val == (1 << (bitwidth - 1))) { - val = readbits(4, &crap) + 1; - bitwidth = (val < bitwidth) ? val : val + 1; - continue; - } - } - else if (bitwidth < 17) { //Method 2 - word border = (0xFFFF >> (17 - bitwidth)) - 8; + // Expand the value to signed byte: + { + short v; // The sample value: + if (bitwidth < 16) { + byte shift = 16 - bitwidth; + v = (short)(val << shift); + v >>= shift; + } else + v = (short)val; - if (val > border && val <= (border + 16)) { - val -= border; - bitwidth = val < bitwidth ? val : val + 1; - continue; - } - } - else if (bitwidth == 17) { //Method 3 - if (val & 0x10000) { - bitwidth = (val + 1) & 0xFF; - continue; - } - } - else { //Illegal width, abort ? - freeblock(&crap); - return -1; - } + // And integrate the sample value + //(It always has to end with integration doesn't it ? ;-) + d1 += v; + d2 += d1; + } - //Expand the value to signed byte: - { - short v; //The sample value: - if (bitwidth < 16) { - byte shift = 16 - bitwidth; - v = (short)(val << shift); - v >>= shift; - } - else - v = (short)val; - - //And integrate the sample value - //(It always has to end with integration doesn't it ? ;-) - d1 += v; - d2 += d1; - } - - //Store ! - /* Version 2.15 was an unofficial version with hacked compression - * code. Yay, better compression :D - */ - *data++ = it215 ? d2 : d1; - data += stereo; - len--; - blockpos++; - } - freeblock(&crap); - } - return 0; + // Store ! + /* Version 2.15 was an unofficial version with hacked compression + * code. Yay, better compression :D + */ + *data++ = it215 ? d2 : d1; + data += stereo; + len--; + blockpos++; + } + freeblock(&crap); + } + return 0; } +static int it_read_envelope(IT_ENVELOPE *envelope, DUMBFILE *f) { + int n; + envelope->flags = dumbfile_getc(f); + envelope->n_nodes = dumbfile_getc(f); + if (envelope->n_nodes > 25) { + TRACE("IT error: wrong number of envelope nodes (%d)\n", + envelope->n_nodes); + envelope->n_nodes = 0; + return -1; + } + envelope->loop_start = dumbfile_getc(f); + envelope->loop_end = dumbfile_getc(f); + envelope->sus_loop_start = dumbfile_getc(f); + envelope->sus_loop_end = dumbfile_getc(f); + for (n = 0; n < envelope->n_nodes; n++) { + envelope->node_y[n] = dumbfile_getc(f); + envelope->node_t[n] = dumbfile_igetw(f); + } + dumbfile_skip(f, 75 - envelope->n_nodes * 3 + 1); -static int it_read_envelope(IT_ENVELOPE *envelope, DUMBFILE *f) -{ - int n; + if (envelope->n_nodes <= 0) + envelope->flags &= ~IT_ENVELOPE_ON; + else { + if (envelope->loop_end >= envelope->n_nodes || + envelope->loop_start > envelope->loop_end) + envelope->flags &= ~IT_ENVELOPE_LOOP_ON; + if (envelope->sus_loop_end >= envelope->n_nodes || + envelope->sus_loop_start > envelope->sus_loop_end) + envelope->flags &= ~IT_ENVELOPE_SUSTAIN_LOOP; + } - envelope->flags = dumbfile_getc(f); - envelope->n_nodes = dumbfile_getc(f); - if(envelope->n_nodes > 25) { - TRACE("IT error: wrong number of envelope nodes (%d)\n", envelope->n_nodes); - envelope->n_nodes = 0; - return -1; - } - envelope->loop_start = dumbfile_getc(f); - envelope->loop_end = dumbfile_getc(f); - envelope->sus_loop_start = dumbfile_getc(f); - envelope->sus_loop_end = dumbfile_getc(f); - for (n = 0; n < envelope->n_nodes; n++) { - envelope->node_y[n] = dumbfile_getc(f); - envelope->node_t[n] = dumbfile_igetw(f); - } - dumbfile_skip(f, 75 - envelope->n_nodes * 3 + 1); - - if (envelope->n_nodes <= 0) - envelope->flags &= ~IT_ENVELOPE_ON; - else { - if (envelope->loop_end >= envelope->n_nodes || envelope->loop_start > envelope->loop_end) envelope->flags &= ~IT_ENVELOPE_LOOP_ON; - if (envelope->sus_loop_end >= envelope->n_nodes || envelope->sus_loop_start > envelope->sus_loop_end) envelope->flags &= ~IT_ENVELOPE_SUSTAIN_LOOP; - } - - return dumbfile_error(f); + return dumbfile_error(f); } +static int it_read_old_instrument(IT_INSTRUMENT *instrument, DUMBFILE *f) { + int n; - -static int it_read_old_instrument(IT_INSTRUMENT *instrument, DUMBFILE *f) -{ - int n; - - /*if (dumbfile_mgetl(f) != IT_INSTRUMENT_SIGNATURE) - return -1;*/ - // XXX - dumbfile_skip(f, 4); + /*if (dumbfile_mgetl(f) != IT_INSTRUMENT_SIGNATURE) + return -1;*/ + // XXX + dumbfile_skip(f, 4); dumbfile_getnc((char *)instrument->filename, 13, f); - instrument->filename[13] = 0; + instrument->filename[13] = 0; - instrument->volume_envelope.flags = dumbfile_getc(f); - instrument->volume_envelope.loop_start = dumbfile_getc(f); - instrument->volume_envelope.loop_end = dumbfile_getc(f); - instrument->volume_envelope.sus_loop_start = dumbfile_getc(f); - instrument->volume_envelope.sus_loop_end = dumbfile_getc(f); + instrument->volume_envelope.flags = dumbfile_getc(f); + instrument->volume_envelope.loop_start = dumbfile_getc(f); + instrument->volume_envelope.loop_end = dumbfile_getc(f); + instrument->volume_envelope.sus_loop_start = dumbfile_getc(f); + instrument->volume_envelope.sus_loop_end = dumbfile_getc(f); - /* Skip two unused bytes. */ - dumbfile_skip(f, 2); + /* Skip two unused bytes. */ + dumbfile_skip(f, 2); - /* In the old instrument format, fadeout ranges from 0 to 64, and is - * subtracted at intervals from a value starting at 512. In the new - * format, all these values are doubled. Therefore we double when loading - * from the old instrument format - that way we don't have to think about - * it later. - */ - instrument->fadeout = dumbfile_igetw(f) << 1; - instrument->new_note_action = dumbfile_getc(f); - instrument->dup_check_type = dumbfile_getc(f); - instrument->dup_check_action = DCA_NOTE_CUT; // This might be wrong! - /** WARNING - what is the duplicate check action for old-style instruments? */ + /* In the old instrument format, fadeout ranges from 0 to 64, and is + * subtracted at intervals from a value starting at 512. In the new + * format, all these values are doubled. Therefore we double when loading + * from the old instrument format - that way we don't have to think about + * it later. + */ + instrument->fadeout = dumbfile_igetw(f) << 1; + instrument->new_note_action = dumbfile_getc(f); + instrument->dup_check_type = dumbfile_getc(f); + instrument->dup_check_action = DCA_NOTE_CUT; // This might be wrong! + /** WARNING - what is the duplicate check action for old-style instruments? + */ - /* Skip Tracker Version and Number of Samples. These are only used in - * separate instrument files. Also skip unused byte. - */ - dumbfile_skip(f, 4); + /* Skip Tracker Version and Number of Samples. These are only used in + * separate instrument files. Also skip unused byte. + */ + dumbfile_skip(f, 4); dumbfile_getnc((char *)instrument->name, 26, f); - instrument->name[26] = 0; + instrument->name[26] = 0; - /* Skip unused bytes following the Instrument Name. */ - dumbfile_skip(f, 6); + /* Skip unused bytes following the Instrument Name. */ + dumbfile_skip(f, 6); - instrument->pp_separation = 0; - instrument->pp_centre = 60; - instrument->global_volume = 128; - /** WARNING - should global_volume be 64 or something? */ - instrument->default_pan = 32; - /** WARNING - should default_pan be 128, meaning don`t use? */ - instrument->random_volume = 0; - instrument->random_pan = 0; + instrument->pp_separation = 0; + instrument->pp_centre = 60; + instrument->global_volume = 128; + /** WARNING - should global_volume be 64 or something? */ + instrument->default_pan = 32; + /** WARNING - should default_pan be 128, meaning don`t use? */ + instrument->random_volume = 0; + instrument->random_pan = 0; - for (n = 0; n < 120; n++) { - instrument->map_note[n] = dumbfile_getc(f); - instrument->map_sample[n] = dumbfile_getc(f); - } + for (n = 0; n < 120; n++) { + instrument->map_note[n] = dumbfile_getc(f); + instrument->map_sample[n] = dumbfile_getc(f); + } - /* Skip "Volume envelope (200 bytes)". */ - // - need to know better what this is for though. - dumbfile_skip(f, 200); + /* Skip "Volume envelope (200 bytes)". */ + // - need to know better what this is for though. + dumbfile_skip(f, 200); #ifdef INVESTIGATE_OLD_INSTRUMENTS - fprintf(stderr, "Inst %02d Env:", n); + fprintf(stderr, "Inst %02d Env:", n); #endif - for (n = 0; n < 25; n++) - { - instrument->volume_envelope.node_t[n] = dumbfile_getc(f); - instrument->volume_envelope.node_y[n] = dumbfile_getc(f); + for (n = 0; n < 25; n++) { + instrument->volume_envelope.node_t[n] = dumbfile_getc(f); + instrument->volume_envelope.node_y[n] = dumbfile_getc(f); #ifdef INVESTIGATE_OLD_INSTRUMENTS - fprintf(stderr, " %d,%d", - instrument->volume_envelope.node_t[n], - instrument->volume_envelope.node_y[n]); + fprintf(stderr, " %d,%d", instrument->volume_envelope.node_t[n], + instrument->volume_envelope.node_y[n]); #endif - // This loop is unfinished, as we can probably escape from it before - // the end if we want to. Hence the otherwise useless dumbfile_skip() - // call below. - } - dumbfile_skip(f, 50 - (n << 1)); - instrument->volume_envelope.n_nodes = n; + // This loop is unfinished, as we can probably escape from it before + // the end if we want to. Hence the otherwise useless dumbfile_skip() + // call below. + } + dumbfile_skip(f, 50 - (n << 1)); + instrument->volume_envelope.n_nodes = n; #ifdef INVESTIGATE_OLD_INSTRUMENTS - fprintf(stderr, "\n"); + fprintf(stderr, "\n"); #endif - if (dumbfile_error(f)) - return -1; + if (dumbfile_error(f)) + return -1; - { - IT_ENVELOPE *envelope = &instrument->volume_envelope; - if (envelope->n_nodes <= 0) - envelope->flags &= ~IT_ENVELOPE_ON; - else { - if (envelope->loop_end >= envelope->n_nodes || envelope->loop_start > envelope->loop_end) envelope->flags &= ~IT_ENVELOPE_LOOP_ON; - if (envelope->sus_loop_end >= envelope->n_nodes || envelope->sus_loop_start > envelope->sus_loop_end) envelope->flags &= ~IT_ENVELOPE_SUSTAIN_LOOP; - } - } + { + IT_ENVELOPE *envelope = &instrument->volume_envelope; + if (envelope->n_nodes <= 0) + envelope->flags &= ~IT_ENVELOPE_ON; + else { + if (envelope->loop_end >= envelope->n_nodes || + envelope->loop_start > envelope->loop_end) + envelope->flags &= ~IT_ENVELOPE_LOOP_ON; + if (envelope->sus_loop_end >= envelope->n_nodes || + envelope->sus_loop_start > envelope->sus_loop_end) + envelope->flags &= ~IT_ENVELOPE_SUSTAIN_LOOP; + } + } - instrument->filter_cutoff = 127; - instrument->filter_resonance = 0; + instrument->filter_cutoff = 127; + instrument->filter_resonance = 0; - instrument->pan_envelope.flags = 0; - instrument->pitch_envelope.flags = 0; + instrument->pan_envelope.flags = 0; + instrument->pitch_envelope.flags = 0; - return 0; + return 0; } - - -static int it_read_instrument(IT_INSTRUMENT *instrument, DUMBFILE *f, int maxlen) -{ +static int it_read_instrument(IT_INSTRUMENT *instrument, DUMBFILE *f, + int maxlen) { int n; long len; - /*if (dumbfile_mgetl(f) != IT_INSTRUMENT_SIGNATURE) - return -1;*/ - // XXX + /*if (dumbfile_mgetl(f) != IT_INSTRUMENT_SIGNATURE) + return -1;*/ + // XXX - if (maxlen) len = dumbfile_pos(f); - else len = 0; + if (maxlen) + len = dumbfile_pos(f); + else + len = 0; - dumbfile_skip(f, 4); + dumbfile_skip(f, 4); dumbfile_getnc((char *)instrument->filename, 13, f); - instrument->filename[13] = 0; + instrument->filename[13] = 0; - instrument->new_note_action = dumbfile_getc(f); - instrument->dup_check_type = dumbfile_getc(f); - instrument->dup_check_action = dumbfile_getc(f); - instrument->fadeout = dumbfile_igetw(f); - instrument->pp_separation = dumbfile_getc(f); - instrument->pp_centre = dumbfile_getc(f); - instrument->global_volume = dumbfile_getc(f); - instrument->default_pan = dumbfile_getc(f); - instrument->random_volume = dumbfile_getc(f); - instrument->random_pan = dumbfile_getc(f); + instrument->new_note_action = dumbfile_getc(f); + instrument->dup_check_type = dumbfile_getc(f); + instrument->dup_check_action = dumbfile_getc(f); + instrument->fadeout = dumbfile_igetw(f); + instrument->pp_separation = dumbfile_getc(f); + instrument->pp_centre = dumbfile_getc(f); + instrument->global_volume = dumbfile_getc(f); + instrument->default_pan = dumbfile_getc(f); + instrument->random_volume = dumbfile_getc(f); + instrument->random_pan = dumbfile_getc(f); - /* Skip Tracker Version and Number of Samples. These are only used in - * separate instrument files. Also skip unused byte. - */ - dumbfile_skip(f, 4); + /* Skip Tracker Version and Number of Samples. These are only used in + * separate instrument files. Also skip unused byte. + */ + dumbfile_skip(f, 4); dumbfile_getnc((char *)instrument->name, 26, f); - instrument->name[26] = 0; + instrument->name[26] = 0; - instrument->filter_cutoff = dumbfile_getc(f); - instrument->filter_resonance = dumbfile_getc(f); + instrument->filter_cutoff = dumbfile_getc(f); + instrument->filter_resonance = dumbfile_getc(f); - /* Skip MIDI Channel, Program and Bank. */ - //dumbfile_skip(f, 4); - /*instrument->output = dumbfile_getc(f); - if ( instrument->output > 16 ) { - instrument->output -= 128; - } else { - instrument->output = 0; - } - dumbfile_skip(f, 3);*/ - dumbfile_skip(f, 4); + /* Skip MIDI Channel, Program and Bank. */ + // dumbfile_skip(f, 4); + /*instrument->output = dumbfile_getc(f); + if ( instrument->output > 16 ) { + instrument->output -= 128; + } else { + instrument->output = 0; + } + dumbfile_skip(f, 3);*/ + dumbfile_skip(f, 4); - for (n = 0; n < 120; n++) { - instrument->map_note[n] = dumbfile_getc(f); - instrument->map_sample[n] = dumbfile_getc(f); - } + for (n = 0; n < 120; n++) { + instrument->map_note[n] = dumbfile_getc(f); + instrument->map_sample[n] = dumbfile_getc(f); + } - if (dumbfile_error(f)) - return -1; + if (dumbfile_error(f)) + return -1; - if (it_read_envelope(&instrument->volume_envelope, f)) return -1; - if (it_read_envelope(&instrument->pan_envelope, f)) return -1; - if (it_read_envelope(&instrument->pitch_envelope, f)) return -1; + if (it_read_envelope(&instrument->volume_envelope, f)) + return -1; + if (it_read_envelope(&instrument->pan_envelope, f)) + return -1; + if (it_read_envelope(&instrument->pitch_envelope, f)) + return -1; - if (maxlen) { - len = dumbfile_pos(f) - len; - if ( maxlen - len < 124 ) return 0; - } + if (maxlen) { + len = dumbfile_pos(f) - len; + if (maxlen - len < 124) + return 0; + } - if ( dumbfile_mgetl(f) == IT_MPTX_SIGNATURE ) { - for ( n = 0; n < 120; n++ ) { - instrument->map_sample[ n ] += dumbfile_getc( f ) << 8; - } + if (dumbfile_mgetl(f) == IT_MPTX_SIGNATURE) { + for (n = 0; n < 120; n++) { + instrument->map_sample[n] += dumbfile_getc(f) << 8; + } - if (dumbfile_error(f)) - return -1; - } + if (dumbfile_error(f)) + return -1; + } - /*if ( dumbfile_mgetl(f) == IT_INSM_SIGNATURE ) { - long end = dumbfile_igetl(f); - end += dumbfile_pos(f); - while ( dumbfile_pos(f) < end ) { - int chunkid = dumbfile_igetl(f); - switch ( chunkid ) { - case DUMB_ID('P','L','U','G'): - instrument->output = dumbfile_getc(f); - break; - default: - chunkid = chunkid / 0x100 + dumbfile_getc(f) * 0x1000000; - break; - } - } + /*if ( dumbfile_mgetl(f) == IT_INSM_SIGNATURE ) { + long end = dumbfile_igetl(f); + end += dumbfile_pos(f); + while ( dumbfile_pos(f) < end ) { + int chunkid = dumbfile_igetl(f); + switch ( chunkid ) { + case DUMB_ID('P','L','U','G'): + instrument->output = dumbfile_getc(f); + break; + default: + chunkid = chunkid / 0x100 + dumbfile_getc(f) + * 0x1000000; break; + } + } - if (dumbfile_error(f)) - return -1; - }*/ + if (dumbfile_error(f)) + return -1; + }*/ - return 0; + return 0; } - - -static int it_read_sample_header(IT_SAMPLE *sample, unsigned char *convert, long *offset, DUMBFILE *f) -{ - /* XXX - if (dumbfile_mgetl(f) != IT_SAMPLE_SIGNATURE) - return -1;*/ - int hax = 0; - long s = dumbfile_mgetl(f); - if (s != IT_SAMPLE_SIGNATURE) { - if ( s == ( IT_SAMPLE_SIGNATURE >> 16 ) ) { - s <<= 16; - s |= dumbfile_mgetw(f); - if ( s != IT_SAMPLE_SIGNATURE ) - return -1; - hax = 1; - } - } +static int it_read_sample_header(IT_SAMPLE *sample, unsigned char *convert, + long *offset, DUMBFILE *f) { + /* XXX + if (dumbfile_mgetl(f) != IT_SAMPLE_SIGNATURE) + return -1;*/ + int hax = 0; + long s = dumbfile_mgetl(f); + if (s != IT_SAMPLE_SIGNATURE) { + if (s == (IT_SAMPLE_SIGNATURE >> 16)) { + s <<= 16; + s |= dumbfile_mgetw(f); + if (s != IT_SAMPLE_SIGNATURE) + return -1; + hax = 1; + } + } dumbfile_getnc((char *)sample->filename, 13, f); - sample->filename[13] = 0; + sample->filename[13] = 0; - sample->global_volume = dumbfile_getc(f); - sample->flags = dumbfile_getc(f); - sample->default_volume = dumbfile_getc(f); + sample->global_volume = dumbfile_getc(f); + sample->flags = dumbfile_getc(f); + sample->default_volume = dumbfile_getc(f); dumbfile_getnc((char *)sample->name, 26, f); - sample->name[26] = 0; + sample->name[26] = 0; - *convert = dumbfile_getc(f); - sample->default_pan = dumbfile_getc(f); - sample->length = dumbfile_igetl(f); - sample->loop_start = dumbfile_igetl(f); - sample->loop_end = dumbfile_igetl(f); - sample->C5_speed = dumbfile_igetl(f); - sample->sus_loop_start = dumbfile_igetl(f); - sample->sus_loop_end = dumbfile_igetl(f); + *convert = dumbfile_getc(f); + sample->default_pan = dumbfile_getc(f); + sample->length = dumbfile_igetl(f); + sample->loop_start = dumbfile_igetl(f); + sample->loop_end = dumbfile_igetl(f); + sample->C5_speed = dumbfile_igetl(f); + sample->sus_loop_start = dumbfile_igetl(f); + sample->sus_loop_end = dumbfile_igetl(f); #ifdef STEREO_SAMPLES_COUNT_AS_TWO - if (sample->flags & IT_SAMPLE_STEREO) { - sample->length >>= 1; - sample->loop_start >>= 1; - sample->loop_end >>= 1; - sample->C5_speed >>= 1; - sample->sus_loop_start >>= 1; - sample->sus_loop_end >>= 1; - } + if (sample->flags & IT_SAMPLE_STEREO) { + sample->length >>= 1; + sample->loop_start >>= 1; + sample->loop_end >>= 1; + sample->C5_speed >>= 1; + sample->sus_loop_start >>= 1; + sample->sus_loop_end >>= 1; + } #endif - if (sample->flags & IT_SAMPLE_EXISTS) { - if (sample->length <= 0) - sample->flags &= ~IT_SAMPLE_EXISTS; - else { - if ((unsigned int)sample->loop_end > (unsigned int)sample->length) - sample->flags &= ~IT_SAMPLE_LOOP; - else if ((unsigned int)sample->loop_start >= (unsigned int)sample->loop_end) - sample->flags &= ~IT_SAMPLE_LOOP; + if (sample->flags & IT_SAMPLE_EXISTS) { + if (sample->length <= 0) + sample->flags &= ~IT_SAMPLE_EXISTS; + else { + if ((unsigned int)sample->loop_end > (unsigned int)sample->length) + sample->flags &= ~IT_SAMPLE_LOOP; + else if ((unsigned int)sample->loop_start >= + (unsigned int)sample->loop_end) + sample->flags &= ~IT_SAMPLE_LOOP; - if ((unsigned int)sample->sus_loop_end > (unsigned int)sample->length) - sample->flags &= ~IT_SAMPLE_SUS_LOOP; - else if ((unsigned int)sample->sus_loop_start >= (unsigned int)sample->sus_loop_end) - sample->flags &= ~IT_SAMPLE_SUS_LOOP; + if ((unsigned int)sample->sus_loop_end > + (unsigned int)sample->length) + sample->flags &= ~IT_SAMPLE_SUS_LOOP; + else if ((unsigned int)sample->sus_loop_start >= + (unsigned int)sample->sus_loop_end) + sample->flags &= ~IT_SAMPLE_SUS_LOOP; - /* We may be able to truncate the sample to save memory. */ - if (sample->flags & IT_SAMPLE_LOOP && - *convert != 0xFF) { /* not truncating compressed samples, for now... */ - if ((sample->flags & IT_SAMPLE_SUS_LOOP) && sample->sus_loop_end >= sample->loop_end) - sample->length = sample->sus_loop_end; - else - sample->length = sample->loop_end; - } - } - } + /* We may be able to truncate the sample to save memory. */ + if (sample->flags & IT_SAMPLE_LOOP && + *convert != + 0xFF) { /* not truncating compressed samples, for now... */ + if ((sample->flags & IT_SAMPLE_SUS_LOOP) && + sample->sus_loop_end >= sample->loop_end) + sample->length = sample->sus_loop_end; + else + sample->length = sample->loop_end; + } + } + } - *offset = dumbfile_igetl(f); + *offset = dumbfile_igetl(f); - sample->vibrato_speed = dumbfile_getc(f); - sample->vibrato_depth = dumbfile_getc(f); - if ( ! hax ) { - sample->vibrato_rate = dumbfile_getc(f); - sample->vibrato_waveform = dumbfile_getc(f); - } else { - sample->vibrato_rate = 0; - sample->vibrato_waveform = 0; - } - sample->finetune = 0; - sample->max_resampling_quality = -1; + sample->vibrato_speed = dumbfile_getc(f); + sample->vibrato_depth = dumbfile_getc(f); + if (!hax) { + sample->vibrato_rate = dumbfile_getc(f); + sample->vibrato_waveform = dumbfile_getc(f); + } else { + sample->vibrato_rate = 0; + sample->vibrato_waveform = 0; + } + sample->finetune = 0; + sample->max_resampling_quality = -1; - return dumbfile_error(f); + return dumbfile_error(f); } -long _dumb_it_read_sample_data_adpcm4(IT_SAMPLE *sample, DUMBFILE *f) -{ - long n, len, delta; - signed char * ptr, * end; - signed char compression_table[16]; - if (dumbfile_getnc((char *)compression_table, 16, f) != 16) - return -1; - ptr = (signed char *) sample->data; - delta = 0; +long _dumb_it_read_sample_data_adpcm4(IT_SAMPLE *sample, DUMBFILE *f) { + long n, len, delta; + signed char *ptr, *end; + signed char compression_table[16]; + if (dumbfile_getnc((char *)compression_table, 16, f) != 16) + return -1; + ptr = (signed char *)sample->data; + delta = 0; - end = ptr + sample->length; - len = (sample->length + 1) / 2; - for (n = 0; n < len; n++) { - int b = dumbfile_getc(f); - if (b < 0) return -1; - delta += compression_table[b & 0x0F]; - *ptr++ = delta; - if (ptr >= end) break; - delta += compression_table[b >> 4]; - *ptr++ = delta; - } + end = ptr + sample->length; + len = (sample->length + 1) / 2; + for (n = 0; n < len; n++) { + int b = dumbfile_getc(f); + if (b < 0) + return -1; + delta += compression_table[b & 0x0F]; + *ptr++ = delta; + if (ptr >= end) + break; + delta += compression_table[b >> 4]; + *ptr++ = delta; + } - return 0; + return 0; } +static long it_read_sample_data(IT_SAMPLE *sample, unsigned char convert, + DUMBFILE *f) { + long n; -static long it_read_sample_data(IT_SAMPLE *sample, unsigned char convert, DUMBFILE *f) -{ - long n; + long datasize = sample->length; + if (sample->flags & IT_SAMPLE_STEREO) + datasize <<= 1; - long datasize = sample->length; - if (sample->flags & IT_SAMPLE_STEREO) datasize <<= 1; + sample->data = malloc(datasize * (sample->flags & IT_SAMPLE_16BIT ? 2 : 1)); + if (!sample->data) + return -1; - sample->data = malloc(datasize * (sample->flags & IT_SAMPLE_16BIT ? 2 : 1)); - if (!sample->data) - return -1; + if (!(sample->flags & IT_SAMPLE_16BIT) && (convert == 0xFF)) { + if (_dumb_it_read_sample_data_adpcm4(sample, f) < 0) + return -1; + } else if (sample->flags & 8) { + /* If the sample is packed, then we must unpack it. */ - if (!(sample->flags & IT_SAMPLE_16BIT) && (convert == 0xFF)) { - if (_dumb_it_read_sample_data_adpcm4(sample, f) < 0) - return -1; - } else if (sample->flags & 8) { - /* If the sample is packed, then we must unpack it. */ + /* Behavior as defined by greasemonkey's munch.py and observed by XMPlay + * and OpenMPT */ - /* Behavior as defined by greasemonkey's munch.py and observed by XMPlay and OpenMPT */ + if (sample->flags & IT_SAMPLE_STEREO) { + if (sample->flags & IT_SAMPLE_16BIT) { + decompress16(f, (short *)sample->data, (int)(datasize >> 1), + convert & 4, 1); + decompress16(f, (short *)sample->data + 1, (int)(datasize >> 1), + convert & 4, 1); + } else { + decompress8(f, (signed char *)sample->data, + (int)(datasize >> 1), convert & 4, 1); + decompress8(f, (signed char *)sample->data + 1, + (int)(datasize >> 1), convert & 4, 1); + } + } else { + if (sample->flags & IT_SAMPLE_16BIT) + decompress16(f, (short *)sample->data, (int)datasize, + convert & 4, 0); + else + decompress8(f, (signed char *)sample->data, (int)datasize, + convert & 4, 0); + } + } else if (sample->flags & IT_SAMPLE_16BIT) { + if (sample->flags & IT_SAMPLE_STEREO) { + if (convert & 2) { + for (n = 0; n < datasize; n += 2) + ((short *)sample->data)[n] = dumbfile_mgetw(f); + for (n = 1; n < datasize; n += 2) + ((short *)sample->data)[n] = dumbfile_mgetw(f); + } else { + for (n = 0; n < datasize; n += 2) + ((short *)sample->data)[n] = dumbfile_igetw(f); + for (n = 1; n < datasize; n += 2) + ((short *)sample->data)[n] = dumbfile_igetw(f); + } + } else { + if (convert & 2) + for (n = 0; n < datasize; n++) + ((short *)sample->data)[n] = dumbfile_mgetw(f); + else + for (n = 0; n < datasize; n++) + ((short *)sample->data)[n] = dumbfile_igetw(f); + } + } else { + if (sample->flags & IT_SAMPLE_STEREO) { + for (n = 0; n < datasize; n += 2) + ((signed char *)sample->data)[n] = dumbfile_getc(f); + for (n = 1; n < datasize; n += 2) + ((signed char *)sample->data)[n] = dumbfile_getc(f); + } else + for (n = 0; n < datasize; n++) + ((signed char *)sample->data)[n] = dumbfile_getc(f); + } - if (sample->flags & IT_SAMPLE_STEREO) { - if (sample->flags & IT_SAMPLE_16BIT) { - decompress16(f, (short *) sample->data, (int)(datasize >> 1), convert & 4, 1); - decompress16(f, (short *) sample->data + 1, (int)(datasize >> 1), convert & 4, 1); - } else { - decompress8(f, (signed char *) sample->data, (int)(datasize >> 1), convert & 4, 1); - decompress8(f, (signed char *) sample->data + 1, (int)(datasize >> 1), convert & 4, 1); - } - } else { - if (sample->flags & IT_SAMPLE_16BIT) - decompress16(f, (short *) sample->data, (int)datasize, convert & 4, 0); - else - decompress8(f, (signed char *) sample->data, (int)datasize, convert & 4, 0); - } - } else if (sample->flags & IT_SAMPLE_16BIT) { - if (sample->flags & IT_SAMPLE_STEREO) { - if (convert & 2) { - for (n = 0; n < datasize; n += 2) - ((short *)sample->data)[n] = dumbfile_mgetw(f); - for (n = 1; n < datasize; n += 2) - ((short *)sample->data)[n] = dumbfile_mgetw(f); - } else { - for (n = 0; n < datasize; n += 2) - ((short *)sample->data)[n] = dumbfile_igetw(f); - for (n = 1; n < datasize; n += 2) - ((short *)sample->data)[n] = dumbfile_igetw(f); - } - } else { - if (convert & 2) - for (n = 0; n < datasize; n++) - ((short *)sample->data)[n] = dumbfile_mgetw(f); - else - for (n = 0; n < datasize; n++) - ((short *)sample->data)[n] = dumbfile_igetw(f); - } - } else { - if (sample->flags & IT_SAMPLE_STEREO) { - for (n = 0; n < datasize; n += 2) - ((signed char *)sample->data)[n] = dumbfile_getc(f); - for (n = 1; n < datasize; n += 2) - ((signed char *)sample->data)[n] = dumbfile_getc(f); - } else - for (n = 0; n < datasize; n++) - ((signed char *)sample->data)[n] = dumbfile_getc(f); - } + if (dumbfile_error(f)) + return -1; - if (dumbfile_error(f)) - return -1; + if (!(convert & 1)) { + /* Convert to signed. */ + if (sample->flags & IT_SAMPLE_16BIT) + for (n = 0; n < datasize; n++) + ((short *)sample->data)[n] ^= 0x8000; + else + for (n = 0; n < datasize; n++) + ((signed char *)sample->data)[n] ^= 0x80; + } - if (!(convert & 1)) { - /* Convert to signed. */ - if (sample->flags & IT_SAMPLE_16BIT) - for (n = 0; n < datasize; n++) - ((short *)sample->data)[n] ^= 0x8000; - else - for (n = 0; n < datasize; n++) - ((signed char *)sample->data)[n] ^= 0x80; - } + /* NOT SUPPORTED: + * + * convert & 4 - Samples stored as delta values + * convert & 16 - Samples stored as TX-Wave 12-bit values + * convert & 32 - Left/Right/All Stereo prompt + */ - /* NOT SUPPORTED: - * - * convert & 4 - Samples stored as delta values - * convert & 16 - Samples stored as TX-Wave 12-bit values - * convert & 32 - Left/Right/All Stereo prompt - */ - - return 0; + return 0; } - - //#define DETECT_DUPLICATE_CHANNELS #ifdef DETECT_DUPLICATE_CHANNELS #include #endif -static int it_read_pattern(IT_PATTERN *pattern, DUMBFILE *f, unsigned char *buffer) -{ - unsigned char cmask[DUMB_IT_N_CHANNELS]; - unsigned char cnote[DUMB_IT_N_CHANNELS]; - unsigned char cinstrument[DUMB_IT_N_CHANNELS]; - unsigned char cvolpan[DUMB_IT_N_CHANNELS]; - unsigned char ceffect[DUMB_IT_N_CHANNELS]; - unsigned char ceffectvalue[DUMB_IT_N_CHANNELS]; +static int it_read_pattern(IT_PATTERN *pattern, DUMBFILE *f, + unsigned char *buffer) { + unsigned char cmask[DUMB_IT_N_CHANNELS]; + unsigned char cnote[DUMB_IT_N_CHANNELS]; + unsigned char cinstrument[DUMB_IT_N_CHANNELS]; + unsigned char cvolpan[DUMB_IT_N_CHANNELS]; + unsigned char ceffect[DUMB_IT_N_CHANNELS]; + unsigned char ceffectvalue[DUMB_IT_N_CHANNELS]; #ifdef DETECT_DUPLICATE_CHANNELS - IT_ENTRY *dupentry[DUMB_IT_N_CHANNELS]; + IT_ENTRY *dupentry[DUMB_IT_N_CHANNELS]; #endif - int n_entries = 0; - int buflen; - int bufpos = 0; + int n_entries = 0; + int buflen; + int bufpos = 0; - IT_ENTRY *entry; + IT_ENTRY *entry; - unsigned char channel; - unsigned char mask; + unsigned char channel; + unsigned char mask; - memset(cmask, 0, sizeof(cmask)); - memset(cnote, 0, sizeof(cnote)); - memset(cinstrument, 0, sizeof(cinstrument)); - memset(cvolpan, 0, sizeof(cvolpan)); - memset(ceffect, 0, sizeof(ceffect)); - memset(ceffectvalue, 0, sizeof(ceffectvalue)); + memset(cmask, 0, sizeof(cmask)); + memset(cnote, 0, sizeof(cnote)); + memset(cinstrument, 0, sizeof(cinstrument)); + memset(cvolpan, 0, sizeof(cvolpan)); + memset(ceffect, 0, sizeof(ceffect)); + memset(ceffectvalue, 0, sizeof(ceffectvalue)); #ifdef DETECT_DUPLICATE_CHANNELS - { - int i; - for (i = 0; i < DUMB_IT_N_CHANNELS; i++) dupentry[i] = NULL; - } + { + int i; + for (i = 0; i < DUMB_IT_N_CHANNELS; i++) + dupentry[i] = NULL; + } #endif - buflen = dumbfile_igetw(f); - pattern->n_rows = dumbfile_igetw(f); + buflen = dumbfile_igetw(f); + pattern->n_rows = dumbfile_igetw(f); - /* Skip four unused bytes. */ - dumbfile_skip(f, 4); + /* Skip four unused bytes. */ + dumbfile_skip(f, 4); - if (dumbfile_error(f)) - return -1; + if (dumbfile_error(f)) + return -1; - /* Read in the pattern data. */ + /* Read in the pattern data. */ dumbfile_getnc((char *)buffer, buflen, f); - if (dumbfile_error(f)) - return -1; + if (dumbfile_error(f)) + return -1; - /* Scan the pattern data, and work out how many entries we need room for. */ - while (bufpos < buflen) { - unsigned char b = buffer[bufpos++]; + /* Scan the pattern data, and work out how many entries we need room for. */ + while (bufpos < buflen) { + unsigned char b = buffer[bufpos++]; - if (b == 0) { - /* End of row */ - n_entries++; - continue; - } + if (b == 0) { + /* End of row */ + n_entries++; + continue; + } - channel = (b - 1) & 63; + channel = (b - 1) & 63; - if (b & 128) - cmask[channel] = mask = buffer[bufpos++]; - else - mask = cmask[channel]; + if (b & 128) + cmask[channel] = mask = buffer[bufpos++]; + else + mask = cmask[channel]; - { - static const unsigned char used[16] = {0, 1, 1, 2, 1, 2, 2, 3, 2, 3, 3, 4, 3, 4, 4, 5}; - n_entries += (mask != 0); - bufpos += used[mask & 15]; - } - } + { + static const unsigned char used[16] = {0, 1, 1, 2, 1, 2, 2, 3, + 2, 3, 3, 4, 3, 4, 4, 5}; + n_entries += (mask != 0); + bufpos += used[mask & 15]; + } + } - pattern->n_entries = n_entries; + pattern->n_entries = n_entries; - pattern->entry = malloc(n_entries * sizeof(*pattern->entry)); + pattern->entry = malloc(n_entries * sizeof(*pattern->entry)); - if (!pattern->entry) - return -1; + if (!pattern->entry) + return -1; - bufpos = 0; - memset(cmask, 0, sizeof(cmask)); + bufpos = 0; + memset(cmask, 0, sizeof(cmask)); - entry = pattern->entry; + entry = pattern->entry; - while (bufpos < buflen) { - unsigned char b = buffer[bufpos++]; - - if (b == 0) { - /* End of row */ - IT_SET_END_ROW(entry); - entry++; + while (bufpos < buflen) { + unsigned char b = buffer[bufpos++]; + + if (b == 0) { + /* End of row */ + IT_SET_END_ROW(entry); + entry++; #ifdef DETECT_DUPLICATE_CHANNELS - { - int i; - for (i = 0; i < DUMB_IT_N_CHANNELS; i++) dupentry[i] = NULL; - } + { + int i; + for (i = 0; i < DUMB_IT_N_CHANNELS; i++) + dupentry[i] = NULL; + } #endif - continue; - } + continue; + } - channel = (b - 1) & 63; + channel = (b - 1) & 63; - if (b & 128) { - if (bufpos >= buflen) - return -1; - - cmask[channel] = mask = buffer[bufpos++]; - } else - mask = cmask[channel]; + if (b & 128) { + if (bufpos >= buflen) + return -1; - if (mask) { - entry->mask = (mask & 15) | (mask >> 4); - entry->channel = channel; + cmask[channel] = mask = buffer[bufpos++]; + } else + mask = cmask[channel]; - if (mask & IT_ENTRY_NOTE) { - if (bufpos >= buflen) - return -1; - - cnote[channel] = entry->note = buffer[bufpos++]; - } else if (mask & (IT_ENTRY_NOTE << 4)) - entry->note = cnote[channel]; + if (mask) { + entry->mask = (mask & 15) | (mask >> 4); + entry->channel = channel; - if (mask & IT_ENTRY_INSTRUMENT) { - if (bufpos >= buflen) - return -1; - - cinstrument[channel] = entry->instrument = buffer[bufpos++]; - } else if (mask & (IT_ENTRY_INSTRUMENT << 4)) - entry->instrument = cinstrument[channel]; + if (mask & IT_ENTRY_NOTE) { + if (bufpos >= buflen) + return -1; - if (mask & IT_ENTRY_VOLPAN) { - if (bufpos >= buflen) - return -1; - - cvolpan[channel] = entry->volpan = buffer[bufpos++]; - } else if (mask & (IT_ENTRY_VOLPAN << 4)) - entry->volpan = cvolpan[channel]; + cnote[channel] = entry->note = buffer[bufpos++]; + } else if (mask & (IT_ENTRY_NOTE << 4)) + entry->note = cnote[channel]; - if (mask & IT_ENTRY_EFFECT) { - if (bufpos + 1 >= buflen) - return -1; - - ceffect[channel] = entry->effect = buffer[bufpos++]; - ceffectvalue[channel] = entry->effectvalue = buffer[bufpos++]; - } else { - entry->effect = ceffect[channel]; - entry->effectvalue = ceffectvalue[channel]; - } + if (mask & IT_ENTRY_INSTRUMENT) { + if (bufpos >= buflen) + return -1; + + cinstrument[channel] = entry->instrument = buffer[bufpos++]; + } else if (mask & (IT_ENTRY_INSTRUMENT << 4)) + entry->instrument = cinstrument[channel]; + + if (mask & IT_ENTRY_VOLPAN) { + if (bufpos >= buflen) + return -1; + + cvolpan[channel] = entry->volpan = buffer[bufpos++]; + } else if (mask & (IT_ENTRY_VOLPAN << 4)) + entry->volpan = cvolpan[channel]; + + if (mask & IT_ENTRY_EFFECT) { + if (bufpos + 1 >= buflen) + return -1; + + ceffect[channel] = entry->effect = buffer[bufpos++]; + ceffectvalue[channel] = entry->effectvalue = buffer[bufpos++]; + } else { + entry->effect = ceffect[channel]; + entry->effectvalue = ceffectvalue[channel]; + } #ifdef DETECT_DUPLICATE_CHANNELS - if (dupentry[channel]) { - FILE *f = fopen("dupentry.txt", "a"); - if (!f) abort(); - fprintf(f, "Two events on channel %d:", channel); - fprintf(f, " Event #1:"); - if (dupentry[channel]->mask & IT_ENTRY_NOTE ) fprintf(f, " %03d", dupentry[channel]->note ); else fprintf(f, " ..."); - if (dupentry[channel]->mask & IT_ENTRY_INSTRUMENT) fprintf(f, " %03d", dupentry[channel]->instrument); else fprintf(f, " ..."); - if (dupentry[channel]->mask & IT_ENTRY_VOLPAN ) fprintf(f, " %03d", dupentry[channel]->volpan ); else fprintf(f, " ..."); - if (dupentry[channel]->mask & IT_ENTRY_EFFECT) fprintf(f, " %c%02X\n", 'A' - 1 + dupentry[channel]->effect, dupentry[channel]->effectvalue); else fprintf(f, " ...\n"); - fprintf(f, " Event #2:"); - if (entry->mask & IT_ENTRY_NOTE ) fprintf(f, " %03d", entry->note ); else fprintf(f, " ..."); - if (entry->mask & IT_ENTRY_INSTRUMENT) fprintf(f, " %03d", entry->instrument); else fprintf(f, " ..."); - if (entry->mask & IT_ENTRY_VOLPAN ) fprintf(f, " %03d", entry->volpan ); else fprintf(f, " ..."); - if (entry->mask & IT_ENTRY_EFFECT) fprintf(f, " %c%02X\n", 'A' - 1 + entry->effect, entry->effectvalue); else fprintf(f, " ...\n"); - fclose(f); - } - dupentry[channel] = entry; + if (dupentry[channel]) { + FILE *f = fopen("dupentry.txt", "a"); + if (!f) + abort(); + fprintf(f, "Two events on channel %d:", channel); + fprintf(f, " Event #1:"); + if (dupentry[channel]->mask & IT_ENTRY_NOTE) + fprintf(f, " %03d", dupentry[channel]->note); + else + fprintf(f, " ..."); + if (dupentry[channel]->mask & IT_ENTRY_INSTRUMENT) + fprintf(f, " %03d", dupentry[channel]->instrument); + else + fprintf(f, " ..."); + if (dupentry[channel]->mask & IT_ENTRY_VOLPAN) + fprintf(f, " %03d", dupentry[channel]->volpan); + else + fprintf(f, " ..."); + if (dupentry[channel]->mask & IT_ENTRY_EFFECT) + fprintf(f, " %c%02X\n", 'A' - 1 + dupentry[channel]->effect, + dupentry[channel]->effectvalue); + else + fprintf(f, " ...\n"); + fprintf(f, " Event #2:"); + if (entry->mask & IT_ENTRY_NOTE) + fprintf(f, " %03d", entry->note); + else + fprintf(f, " ..."); + if (entry->mask & IT_ENTRY_INSTRUMENT) + fprintf(f, " %03d", entry->instrument); + else + fprintf(f, " ..."); + if (entry->mask & IT_ENTRY_VOLPAN) + fprintf(f, " %03d", entry->volpan); + else + fprintf(f, " ..."); + if (entry->mask & IT_ENTRY_EFFECT) + fprintf(f, " %c%02X\n", 'A' - 1 + entry->effect, + entry->effectvalue); + else + fprintf(f, " ...\n"); + fclose(f); + } + dupentry[channel] = entry; #endif - entry++; - } - } + entry++; + } + } - ASSERT(entry == pattern->entry + n_entries); + ASSERT(entry == pattern->entry + n_entries); - return 0; + return 0; } - - /* Currently we assume the sample data are stored after the sample headers in * module files. This assumption may be unjustified; let me know if you have * trouble. */ #define IT_COMPONENT_SONG_MESSAGE 1 -#define IT_COMPONENT_INSTRUMENT 2 -#define IT_COMPONENT_PATTERN 3 -#define IT_COMPONENT_SAMPLE 4 +#define IT_COMPONENT_INSTRUMENT 2 +#define IT_COMPONENT_PATTERN 3 +#define IT_COMPONENT_SAMPLE 4 -typedef struct IT_COMPONENT -{ - unsigned char type; - unsigned short n; - long offset; - short sampfirst; /* component[sampfirst] = first sample data after this */ - short sampnext; /* sampnext is used to create linked lists of sample data */ -} -IT_COMPONENT; +typedef struct IT_COMPONENT { + unsigned char type; + unsigned short n; + long offset; + short sampfirst; /* component[sampfirst] = first sample data after this */ + short sampnext; /* sampnext is used to create linked lists of sample data */ +} IT_COMPONENT; - - -static int it_component_compare(const void *e1, const void *e2) -{ - return (int)(((const IT_COMPONENT *)e1)->offset - - ((const IT_COMPONENT *)e2)->offset); +static int it_component_compare(const void *e1, const void *e2) { + return (int)(((const IT_COMPONENT *)e1)->offset - + ((const IT_COMPONENT *)e2)->offset); } +static sigdata_t *it_load_sigdata(DUMBFILE *f) { + DUMB_IT_SIGDATA *sigdata; + int cwt, cmwt; + int special; + int message_length, message_offset; -static sigdata_t *it_load_sigdata(DUMBFILE *f) -{ - DUMB_IT_SIGDATA *sigdata; + IT_COMPONENT *component; + int min_components; + int n_components = 0; - int cwt, cmwt; - int special; - int message_length, message_offset; + unsigned char sample_convert[4096]; - IT_COMPONENT *component; - int min_components; - int n_components = 0; + int n; - unsigned char sample_convert[4096]; + unsigned char *buffer; - int n; - - unsigned char *buffer; - - if (dumbfile_mgetl(f) != IT_SIGNATURE) - { - return NULL; + if (dumbfile_mgetl(f) != IT_SIGNATURE) { + return NULL; } - sigdata = malloc(sizeof(*sigdata)); + sigdata = malloc(sizeof(*sigdata)); - if (!sigdata) - { - return NULL; + if (!sigdata) { + return NULL; } - sigdata->song_message = NULL; - sigdata->order = NULL; - sigdata->instrument = NULL; - sigdata->sample = NULL; - sigdata->pattern = NULL; - sigdata->midi = NULL; - sigdata->checkpoint = NULL; + sigdata->song_message = NULL; + sigdata->order = NULL; + sigdata->instrument = NULL; + sigdata->sample = NULL; + sigdata->pattern = NULL; + sigdata->midi = NULL; + sigdata->checkpoint = NULL; dumbfile_getnc((char *)sigdata->name, 26, f); - sigdata->name[26] = 0; + sigdata->name[26] = 0; - /* Skip pattern row highlight info. */ - dumbfile_skip(f, 2); + /* Skip pattern row highlight info. */ + dumbfile_skip(f, 2); - sigdata->n_orders = dumbfile_igetw(f); - sigdata->n_instruments = dumbfile_igetw(f); - sigdata->n_samples = dumbfile_igetw(f); - sigdata->n_patterns = dumbfile_igetw(f); + sigdata->n_orders = dumbfile_igetw(f); + sigdata->n_instruments = dumbfile_igetw(f); + sigdata->n_samples = dumbfile_igetw(f); + sigdata->n_patterns = dumbfile_igetw(f); - cwt = dumbfile_igetw(f); - cmwt = dumbfile_igetw(f); + cwt = dumbfile_igetw(f); + cmwt = dumbfile_igetw(f); - sigdata->flags = dumbfile_igetw(f); - special = dumbfile_igetw(f); + sigdata->flags = dumbfile_igetw(f); + special = dumbfile_igetw(f); - sigdata->global_volume = dumbfile_getc(f); - sigdata->mixing_volume = dumbfile_getc(f); - sigdata->speed = dumbfile_getc(f); - if (sigdata->speed == 0) sigdata->speed = 6; // Should we? What about tempo? - sigdata->tempo = dumbfile_getc(f); - sigdata->pan_separation = dumbfile_getc(f); /** WARNING: use this */ + sigdata->global_volume = dumbfile_getc(f); + sigdata->mixing_volume = dumbfile_getc(f); + sigdata->speed = dumbfile_getc(f); + if (sigdata->speed == 0) + sigdata->speed = 6; // Should we? What about tempo? + sigdata->tempo = dumbfile_getc(f); + sigdata->pan_separation = dumbfile_getc(f); /** WARNING: use this */ - /* Skip Pitch Wheel Depth */ - dumbfile_skip(f, 1); + /* Skip Pitch Wheel Depth */ + dumbfile_skip(f, 1); - message_length = dumbfile_igetw(f); - message_offset = (int)dumbfile_igetl(f); + message_length = dumbfile_igetw(f); + message_offset = (int)dumbfile_igetl(f); - /* Skip Reserved. */ - dumbfile_skip(f, 4); + /* Skip Reserved. */ + dumbfile_skip(f, 4); dumbfile_getnc((char *)sigdata->channel_pan, DUMB_IT_N_CHANNELS, f); dumbfile_getnc((char *)sigdata->channel_volume, DUMB_IT_N_CHANNELS, f); - // XXX sample count - if (dumbfile_error(f) || sigdata->n_orders <= 0 || sigdata->n_instruments > 256 || sigdata->n_samples > 4000 || sigdata->n_patterns > 256) { - _dumb_it_unload_sigdata(sigdata); - return NULL; - } + // XXX sample count + if (dumbfile_error(f) || sigdata->n_orders <= 0 || + sigdata->n_instruments > 256 || sigdata->n_samples > 4000 || + sigdata->n_patterns > 256) { + _dumb_it_unload_sigdata(sigdata); + return NULL; + } - sigdata->order = malloc(sigdata->n_orders); - if (!sigdata->order) { - _dumb_it_unload_sigdata(sigdata); - return NULL; - } + sigdata->order = malloc(sigdata->n_orders); + if (!sigdata->order) { + _dumb_it_unload_sigdata(sigdata); + return NULL; + } - if (sigdata->n_instruments) { - sigdata->instrument = malloc(sigdata->n_instruments * sizeof(*sigdata->instrument)); - if (!sigdata->instrument) { - _dumb_it_unload_sigdata(sigdata); - return NULL; - } - } + if (sigdata->n_instruments) { + sigdata->instrument = + malloc(sigdata->n_instruments * sizeof(*sigdata->instrument)); + if (!sigdata->instrument) { + _dumb_it_unload_sigdata(sigdata); + return NULL; + } + } - if (sigdata->n_samples) { - sigdata->sample = malloc(sigdata->n_samples * sizeof(*sigdata->sample)); - if (!sigdata->sample) { - _dumb_it_unload_sigdata(sigdata); - return NULL; - } - for (n = 0; n < sigdata->n_samples; n++) - sigdata->sample[n].data = NULL; - } + if (sigdata->n_samples) { + sigdata->sample = malloc(sigdata->n_samples * sizeof(*sigdata->sample)); + if (!sigdata->sample) { + _dumb_it_unload_sigdata(sigdata); + return NULL; + } + for (n = 0; n < sigdata->n_samples; n++) + sigdata->sample[n].data = NULL; + } - if (sigdata->n_patterns) { - sigdata->pattern = malloc(sigdata->n_patterns * sizeof(*sigdata->pattern)); - if (!sigdata->pattern) { - _dumb_it_unload_sigdata(sigdata); - return NULL; - } - for (n = 0; n < sigdata->n_patterns; n++) - sigdata->pattern[n].entry = NULL; - } + if (sigdata->n_patterns) { + sigdata->pattern = + malloc(sigdata->n_patterns * sizeof(*sigdata->pattern)); + if (!sigdata->pattern) { + _dumb_it_unload_sigdata(sigdata); + return NULL; + } + for (n = 0; n < sigdata->n_patterns; n++) + sigdata->pattern[n].entry = NULL; + } - if ( dumbfile_getnc((char *)sigdata->order, sigdata->n_orders, f) < sigdata->n_orders ) { - _dumb_it_unload_sigdata(sigdata); - return NULL; - } - sigdata->restart_position = 0; - - min_components = (special & 1) + sigdata->n_instruments + sigdata->n_samples + sigdata->n_patterns; + if (dumbfile_getnc((char *)sigdata->order, sigdata->n_orders, f) < + sigdata->n_orders) { + _dumb_it_unload_sigdata(sigdata); + return NULL; + } + sigdata->restart_position = 0; - component = malloc(min_components * sizeof(*component)); - if (!component) { - _dumb_it_unload_sigdata(sigdata); - return NULL; - } + min_components = (special & 1) + sigdata->n_instruments + + sigdata->n_samples + sigdata->n_patterns; - if (special & 1) { - component[n_components].type = IT_COMPONENT_SONG_MESSAGE; - component[n_components].offset = message_offset; - component[n_components].sampfirst = -1; - n_components++; - } + component = malloc(min_components * sizeof(*component)); + if (!component) { + _dumb_it_unload_sigdata(sigdata); + return NULL; + } - for (n = 0; n < sigdata->n_instruments; n++) { - component[n_components].type = IT_COMPONENT_INSTRUMENT; - component[n_components].n = n; - component[n_components].offset = dumbfile_igetl(f); - component[n_components].sampfirst = -1; - n_components++; - } + if (special & 1) { + component[n_components].type = IT_COMPONENT_SONG_MESSAGE; + component[n_components].offset = message_offset; + component[n_components].sampfirst = -1; + n_components++; + } - for (n = 0; n < sigdata->n_samples; n++) { - component[n_components].type = IT_COMPONENT_SAMPLE; - component[n_components].n = n; - component[n_components].offset = dumbfile_igetl(f); - component[n_components].sampfirst = -1; - n_components++; - } + for (n = 0; n < sigdata->n_instruments; n++) { + component[n_components].type = IT_COMPONENT_INSTRUMENT; + component[n_components].n = n; + component[n_components].offset = dumbfile_igetl(f); + component[n_components].sampfirst = -1; + n_components++; + } - for (n = 0; n < sigdata->n_patterns; n++) { - long offset = dumbfile_igetl(f); - if (offset) { - component[n_components].type = IT_COMPONENT_PATTERN; - component[n_components].n = n; - component[n_components].offset = offset; - component[n_components].sampfirst = -1; - n_components++; - } else { - /* Empty 64-row pattern */ - sigdata->pattern[n].n_rows = 64; - sigdata->pattern[n].n_entries = 0; - } - } + for (n = 0; n < sigdata->n_samples; n++) { + component[n_components].type = IT_COMPONENT_SAMPLE; + component[n_components].n = n; + component[n_components].offset = dumbfile_igetl(f); + component[n_components].sampfirst = -1; + n_components++; + } - if (dumbfile_error(f)) { - free(component); - _dumb_it_unload_sigdata(sigdata); - return NULL; - } + for (n = 0; n < sigdata->n_patterns; n++) { + long offset = dumbfile_igetl(f); + if (offset) { + component[n_components].type = IT_COMPONENT_PATTERN; + component[n_components].n = n; + component[n_components].offset = offset; + component[n_components].sampfirst = -1; + n_components++; + } else { + /* Empty 64-row pattern */ + sigdata->pattern[n].n_rows = 64; + sigdata->pattern[n].n_entries = 0; + } + } - /* - if (!(sigdata->flags & 128) != !(special & 8)) { - fprintf(stderr, "Flags Bit 7 (\"Request embedded MIDI configuration\"): %s\n", sigdata->flags & 128 ? "=SET=" : "clear"); - fprintf(stderr, "Special Bit 3 (\"MIDI configuration embedded\") : %s\n", special & 8 ? "=SET=" : "clear"); - fprintf(stderr, "entheh would like to investigate this IT file.\n"); - fprintf(stderr, "Please contact him! entheh@users.sf.net\n"); - } - */ + if (dumbfile_error(f)) { + free(component); + _dumb_it_unload_sigdata(sigdata); + return NULL; + } - if (special & 8) { - /* MIDI configuration is embedded. */ - unsigned char mididata[32]; - int i; - sigdata->midi = malloc(sizeof(*sigdata->midi)); - if (!sigdata->midi) { - free(component); - _dumb_it_unload_sigdata(sigdata); - return NULL; - // Should we be happy with this outcome in some situations? - } - // What are we skipping? - i = dumbfile_igetw(f); - if (dumbfile_error(f) || dumbfile_skip(f, 8*i)) { - free(component); - _dumb_it_unload_sigdata(sigdata); - return NULL; - } - /* Read embedded MIDI configuration */ - // What are the first 9 commands for? - if (dumbfile_skip(f, 32*9)) { - free(component); - _dumb_it_unload_sigdata(sigdata); - return NULL; - } - for (i = 0; i < 16; i++) { - unsigned char len = 0; - int j, leftdigit = -1; + /* + if (!(sigdata->flags & 128) != !(special & 8)) { + fprintf(stderr, "Flags Bit 7 (\"Request embedded MIDI + configuration\"): %s\n", sigdata->flags & 128 ? "=SET=" : "clear"); + fprintf(stderr, "Special Bit 3 (\"MIDI configuration embedded\") + : %s\n", special & 8 ? "=SET=" : "clear"); fprintf(stderr, "entheh + would like to investigate this IT file.\n"); fprintf(stderr, "Please contact + him! entheh@users.sf.net\n"); + } + */ + + if (special & 8) { + /* MIDI configuration is embedded. */ + unsigned char mididata[32]; + int i; + sigdata->midi = malloc(sizeof(*sigdata->midi)); + if (!sigdata->midi) { + free(component); + _dumb_it_unload_sigdata(sigdata); + return NULL; + // Should we be happy with this outcome in some situations? + } + // What are we skipping? + i = dumbfile_igetw(f); + if (dumbfile_error(f) || dumbfile_skip(f, 8 * i)) { + free(component); + _dumb_it_unload_sigdata(sigdata); + return NULL; + } + /* Read embedded MIDI configuration */ + // What are the first 9 commands for? + if (dumbfile_skip(f, 32 * 9)) { + free(component); + _dumb_it_unload_sigdata(sigdata); + return NULL; + } + for (i = 0; i < 16; i++) { + unsigned char len = 0; + int j, leftdigit = -1; if (dumbfile_getnc((char *)mididata, 32, f) < 32) { - free(component); - _dumb_it_unload_sigdata(sigdata); - return NULL; - } - sigdata->midi->SFmacroz[i] = 0; - for (j = 0; j < 32; j++) { - if (leftdigit >= 0) { - if (mididata[j] == 0) { - sigdata->midi->SFmacro[i][len++] = leftdigit; - break; - } else if (mididata[j] == ' ') - sigdata->midi->SFmacro[i][len++] = leftdigit; - else if (mididata[j] >= '0' && mididata[j] <= '9') - sigdata->midi->SFmacro[i][len++] = (leftdigit << 4) | (mididata[j] - '0'); - else if (mididata[j] >= 'A' && mididata[j] <= 'F') - sigdata->midi->SFmacro[i][len++] = (leftdigit << 4) | (mididata[j] - 'A' + 0xA); - leftdigit = -1; - } else if (mididata[j] == 0) - break; - else if (mididata[j] == 'z') - sigdata->midi->SFmacroz[i] |= 1 << len++; - else if (mididata[j] >= '0' && mididata[j] <= '9') - leftdigit = mididata[j] - '0'; - else if (mididata[j] >= 'A' && mididata[j] <= 'F') - leftdigit = mididata[j] - 'A' + 0xA; - } - sigdata->midi->SFmacrolen[i] = len; - } - for (i = 0; i < 128; i++) { - unsigned char len = 0; - int j, leftdigit = -1; + free(component); + _dumb_it_unload_sigdata(sigdata); + return NULL; + } + sigdata->midi->SFmacroz[i] = 0; + for (j = 0; j < 32; j++) { + if (leftdigit >= 0) { + if (mididata[j] == 0) { + sigdata->midi->SFmacro[i][len++] = leftdigit; + break; + } else if (mididata[j] == ' ') + sigdata->midi->SFmacro[i][len++] = leftdigit; + else if (mididata[j] >= '0' && mididata[j] <= '9') + sigdata->midi->SFmacro[i][len++] = + (leftdigit << 4) | (mididata[j] - '0'); + else if (mididata[j] >= 'A' && mididata[j] <= 'F') + sigdata->midi->SFmacro[i][len++] = + (leftdigit << 4) | (mididata[j] - 'A' + 0xA); + leftdigit = -1; + } else if (mididata[j] == 0) + break; + else if (mididata[j] == 'z') + sigdata->midi->SFmacroz[i] |= 1 << len++; + else if (mididata[j] >= '0' && mididata[j] <= '9') + leftdigit = mididata[j] - '0'; + else if (mididata[j] >= 'A' && mididata[j] <= 'F') + leftdigit = mididata[j] - 'A' + 0xA; + } + sigdata->midi->SFmacrolen[i] = len; + } + for (i = 0; i < 128; i++) { + unsigned char len = 0; + int j, leftdigit = -1; dumbfile_getnc((char *)mididata, 32, f); - for (j = 0; j < 32; j++) { - if (leftdigit >= 0) { - if (mididata[j] == 0) { - sigdata->midi->Zmacro[i][len++] = leftdigit; - break; - } else if (mididata[j] == ' ') - sigdata->midi->Zmacro[i][len++] = leftdigit; - else if (mididata[j] >= '0' && mididata[j] <= '9') - sigdata->midi->Zmacro[i][len++] = (leftdigit << 4) | (mididata[j] - '0'); - else if (mididata[j] >= 'A' && mididata[j] <= 'F') - sigdata->midi->Zmacro[i][len++] = (leftdigit << 4) | (mididata[j] - 'A' + 0xA); - leftdigit = -1; - } else if (mididata[j] == 0) - break; - else if (mididata[j] >= '0' && mididata[j] <= '9') - leftdigit = mididata[j] - '0'; - else if (mididata[j] >= 'A' && mididata[j] <= 'F') - leftdigit = mididata[j] - 'A' + 0xA; - } - sigdata->midi->Zmacrolen[i] = len; - } - } + for (j = 0; j < 32; j++) { + if (leftdigit >= 0) { + if (mididata[j] == 0) { + sigdata->midi->Zmacro[i][len++] = leftdigit; + break; + } else if (mididata[j] == ' ') + sigdata->midi->Zmacro[i][len++] = leftdigit; + else if (mididata[j] >= '0' && mididata[j] <= '9') + sigdata->midi->Zmacro[i][len++] = + (leftdigit << 4) | (mididata[j] - '0'); + else if (mididata[j] >= 'A' && mididata[j] <= 'F') + sigdata->midi->Zmacro[i][len++] = + (leftdigit << 4) | (mididata[j] - 'A' + 0xA); + leftdigit = -1; + } else if (mididata[j] == 0) + break; + else if (mididata[j] >= '0' && mididata[j] <= '9') + leftdigit = mididata[j] - '0'; + else if (mididata[j] >= 'A' && mididata[j] <= 'F') + leftdigit = mididata[j] - 'A' + 0xA; + } + sigdata->midi->Zmacrolen[i] = len; + } + } - sigdata->flags &= IT_REAL_FLAGS; + sigdata->flags &= IT_REAL_FLAGS; qsort(component, n_components, sizeof(IT_COMPONENT), &it_component_compare); - buffer = malloc(65536); - if (!buffer) { - free(component); - _dumb_it_unload_sigdata(sigdata); - return NULL; - } - - for (n = 0; n < n_components; n++) { - long offset; - int m; - - /* XXX */ - if ( component[n].offset == 0 ) { - switch (component[n].type) { - case IT_COMPONENT_INSTRUMENT: - memset( &sigdata->instrument[component[n].n], 0, sizeof(IT_INSTRUMENT) ); - break; - case IT_COMPONENT_SAMPLE: - memset( &sigdata->sample[component[n].n], 0, sizeof(IT_SAMPLE) ); - break; - case IT_COMPONENT_PATTERN: - { - IT_PATTERN * p = &sigdata->pattern[component[n].n]; - p->entry = 0; - p->n_rows = 64; - p->n_entries = 0; - } - break; - } - continue; - } - - if (dumbfile_seek(f, component[n].offset, DFS_SEEK_SET)) { - free(buffer); - free(component); - _dumb_it_unload_sigdata(sigdata); - return NULL; - } - - switch (component[n].type) { - - case IT_COMPONENT_SONG_MESSAGE: - if ( n+1 < n_components ) { - message_length = min( message_length, (int)(component[n+1].offset - component[n].offset) ); - } - sigdata->song_message = malloc(message_length + 1); - if (sigdata->song_message) { - if (dumbfile_getnc((char *)sigdata->song_message, message_length, f) < message_length) { - free(buffer); - free(component); - _dumb_it_unload_sigdata(sigdata); - return NULL; - } - sigdata->song_message[message_length] = 0; - } - break; - - case IT_COMPONENT_INSTRUMENT: - if (cmwt < 0x200) - m = it_read_old_instrument(&sigdata->instrument[component[n].n], f); - else - m = it_read_instrument(&sigdata->instrument[component[n].n], f, (n + 1 < n_components) ? (int)(component[n+1].offset - component[n].offset) : 0); - - if (m) { - free(buffer); - free(component); - _dumb_it_unload_sigdata(sigdata); - return NULL; - } - break; - - case IT_COMPONENT_PATTERN: - if (it_read_pattern(&sigdata->pattern[component[n].n], f, buffer)) { - free(buffer); - free(component); - _dumb_it_unload_sigdata(sigdata); - return NULL; - } - break; - - case IT_COMPONENT_SAMPLE: - if (it_read_sample_header(&sigdata->sample[component[n].n], &sample_convert[component[n].n], &offset, f)) { - free(buffer); - free(component); - _dumb_it_unload_sigdata(sigdata); - return NULL; - } - - if (sigdata->sample[component[n].n].flags & IT_SAMPLE_EXISTS) { - short *sample; - - for (m = n + 1; m < n_components; m++) - if (component[m].offset > offset) - break; - m--; - - sample = &component[m].sampfirst; - - while (*sample >= 0 && component[*sample].offset <= offset) - sample = &component[*sample].sampnext; - - component[n].sampnext = *sample; - *sample = n; - - component[n].offset = offset; - } - } - - m = component[n].sampfirst; - - while (m >= 0) { - if (dumbfile_seek(f, component[m].offset, DFS_SEEK_SET)) { - free(buffer); - free(component); - _dumb_it_unload_sigdata(sigdata); - return NULL; - } - - if (it_read_sample_data(&sigdata->sample[component[m].n], sample_convert[component[m].n], f)) { - free(buffer); - free(component); - _dumb_it_unload_sigdata(sigdata); - return NULL; - } - - m = component[m].sampnext; - } + buffer = malloc(65536); + if (!buffer) { + free(component); + _dumb_it_unload_sigdata(sigdata); + return NULL; } - for ( n = 0; n < 10; n++ ) - { - if ( dumbfile_getc( f ) == 'X' ) - { - if ( dumbfile_getc( f ) == 'T' ) - { - if ( dumbfile_getc( f ) == 'P' ) - { - if ( dumbfile_getc( f ) == 'M' ) - { + for (n = 0; n < n_components; n++) { + long offset; + int m; + + /* XXX */ + if (component[n].offset == 0) { + switch (component[n].type) { + case IT_COMPONENT_INSTRUMENT: + memset(&sigdata->instrument[component[n].n], 0, + sizeof(IT_INSTRUMENT)); + break; + case IT_COMPONENT_SAMPLE: + memset(&sigdata->sample[component[n].n], 0, sizeof(IT_SAMPLE)); + break; + case IT_COMPONENT_PATTERN: { + IT_PATTERN *p = &sigdata->pattern[component[n].n]; + p->entry = 0; + p->n_rows = 64; + p->n_entries = 0; + } break; + } + continue; + } + + if (dumbfile_seek(f, component[n].offset, DFS_SEEK_SET)) { + free(buffer); + free(component); + _dumb_it_unload_sigdata(sigdata); + return NULL; + } + + switch (component[n].type) { + + case IT_COMPONENT_SONG_MESSAGE: + if (n + 1 < n_components) { + message_length = + min(message_length, + (int)(component[n + 1].offset - component[n].offset)); + } + sigdata->song_message = malloc(message_length + 1); + if (sigdata->song_message) { + if (dumbfile_getnc((char *)sigdata->song_message, + message_length, f) < message_length) { + free(buffer); + free(component); + _dumb_it_unload_sigdata(sigdata); + return NULL; + } + sigdata->song_message[message_length] = 0; + } + break; + + case IT_COMPONENT_INSTRUMENT: + if (cmwt < 0x200) + m = it_read_old_instrument(&sigdata->instrument[component[n].n], + f); + else + m = it_read_instrument( + &sigdata->instrument[component[n].n], f, + (n + 1 < n_components) + ? (int)(component[n + 1].offset - component[n].offset) + : 0); + + if (m) { + free(buffer); + free(component); + _dumb_it_unload_sigdata(sigdata); + return NULL; + } + break; + + case IT_COMPONENT_PATTERN: + if (it_read_pattern(&sigdata->pattern[component[n].n], f, buffer)) { + free(buffer); + free(component); + _dumb_it_unload_sigdata(sigdata); + return NULL; + } + break; + + case IT_COMPONENT_SAMPLE: + if (it_read_sample_header(&sigdata->sample[component[n].n], + &sample_convert[component[n].n], &offset, + f)) { + free(buffer); + free(component); + _dumb_it_unload_sigdata(sigdata); + return NULL; + } + + if (sigdata->sample[component[n].n].flags & IT_SAMPLE_EXISTS) { + short *sample; + + for (m = n + 1; m < n_components; m++) + if (component[m].offset > offset) + break; + m--; + + sample = &component[m].sampfirst; + + while (*sample >= 0 && component[*sample].offset <= offset) + sample = &component[*sample].sampnext; + + component[n].sampnext = *sample; + *sample = n; + + component[n].offset = offset; + } + } + + m = component[n].sampfirst; + + while (m >= 0) { + if (dumbfile_seek(f, component[m].offset, DFS_SEEK_SET)) { + free(buffer); + free(component); + _dumb_it_unload_sigdata(sigdata); + return NULL; + } + + if (it_read_sample_data(&sigdata->sample[component[m].n], + sample_convert[component[m].n], f)) { + free(buffer); + free(component); + _dumb_it_unload_sigdata(sigdata); + return NULL; + } + + m = component[m].sampnext; + } + } + + for (n = 0; n < 10; n++) { + if (dumbfile_getc(f) == 'X') { + if (dumbfile_getc(f) == 'T') { + if (dumbfile_getc(f) == 'P') { + if (dumbfile_getc(f) == 'M') { break; } } @@ -1364,74 +1398,67 @@ static sigdata_t *it_load_sigdata(DUMBFILE *f) } } - if ( !dumbfile_error( f ) && n < 10 ) - { - unsigned int mptx_id = (unsigned int)dumbfile_igetl( f ); - while ( !dumbfile_error( f ) && mptx_id != DUMB_ID('M','P','T','S') ) - { - unsigned int size = dumbfile_igetw( f ); - switch (mptx_id) - { - /* TODO: Add instrument extension readers */ + if (!dumbfile_error(f) && n < 10) { + unsigned int mptx_id = (unsigned int)dumbfile_igetl(f); + while (!dumbfile_error(f) && mptx_id != DUMB_ID('M', 'P', 'T', 'S')) { + unsigned int size = dumbfile_igetw(f); + switch (mptx_id) { + /* TODO: Add instrument extension readers */ default: dumbfile_skip(f, size * sigdata->n_instruments); break; } - mptx_id = (unsigned int)dumbfile_igetl( f ); + mptx_id = (unsigned int)dumbfile_igetl(f); } - mptx_id = (unsigned int)dumbfile_igetl( f ); - while ( !dumbfile_error(f) && dumbfile_pos(f) < dumbfile_get_size(f) ) - { - unsigned int size = dumbfile_igetw( f ); - switch (mptx_id) - { - /* TODO: Add more song extension readers */ + mptx_id = (unsigned int)dumbfile_igetl(f); + while (!dumbfile_error(f) && dumbfile_pos(f) < dumbfile_get_size(f)) { + unsigned int size = dumbfile_igetw(f); + switch (mptx_id) { + /* TODO: Add more song extension readers */ - case DUMB_ID('D','T','.','.'): - if ( size == 2 ) - sigdata->tempo = dumbfile_igetw( f ); - else if ( size == 4 ) - sigdata->tempo = (int)dumbfile_igetl( f ); + case DUMB_ID('D', 'T', '.', '.'): + if (size == 2) + sigdata->tempo = dumbfile_igetw(f); + else if (size == 4) + sigdata->tempo = (int)dumbfile_igetl(f); break; default: dumbfile_skip(f, size); break; } - mptx_id = (unsigned int)dumbfile_igetl( f ); + mptx_id = (unsigned int)dumbfile_igetl(f); } } free(buffer); - free(component); + free(component); - _dumb_it_fix_invalid_orders(sigdata); + _dumb_it_fix_invalid_orders(sigdata); - return sigdata; + return sigdata; } +DUH *dumb_read_it_quick(DUMBFILE *f) { + sigdata_t *sigdata; + DUH_SIGTYPE_DESC *descptr = &_dumb_sigtype_it; -DUH *dumb_read_it_quick(DUMBFILE *f) -{ - sigdata_t *sigdata; + sigdata = it_load_sigdata(f); - DUH_SIGTYPE_DESC *descptr = &_dumb_sigtype_it; + if (!sigdata) + return NULL; - sigdata = it_load_sigdata(f); - - if (!sigdata) - return NULL; - - { - const char *tag[2][2]; - tag[0][0] = "TITLE"; + { + const char *tag[2][2]; + tag[0][0] = "TITLE"; tag[0][1] = (const char *)(((DUMB_IT_SIGDATA *)sigdata)->name); - tag[1][0] = "FORMAT"; - tag[1][1] = "IT"; - return make_duh(-1, 2, (const char *const (*)[2])tag, 1, &descptr, &sigdata); - } + tag[1][0] = "FORMAT"; + tag[1][1] = "IT"; + return make_duh(-1, 2, (const char *const(*)[2])tag, 1, &descptr, + &sigdata); + } } diff --git a/Frameworks/Dumb/dumb/src/it/itread2.c b/Frameworks/Dumb/dumb/src/it/itread2.c index 202b8bb96..17e5e8707 100644 --- a/Frameworks/Dumb/dumb/src/it/itread2.c +++ b/Frameworks/Dumb/dumb/src/it/itread2.c @@ -19,11 +19,8 @@ #include "dumb.h" - - -DUH *dumb_read_it(DUMBFILE *f) -{ - DUH *duh = dumb_read_it_quick(f); - dumb_it_do_initial_runthrough(duh); - return duh; +DUH *dumb_read_it(DUMBFILE *f) { + DUH *duh = dumb_read_it_quick(f); + dumb_it_do_initial_runthrough(duh); + return duh; } diff --git a/Frameworks/Dumb/dumb/src/it/itrender.c b/Frameworks/Dumb/dumb/src/it/itrender.c index d5bbf7928..de872dcf6 100644 --- a/Frameworks/Dumb/dumb/src/it/itrender.c +++ b/Frameworks/Dumb/dumb/src/it/itrender.c @@ -28,7 +28,8 @@ #include "internal/resampler.h" -// Keep this disabled, as it's actually slower than the original C/integer version +// Keep this disabled, as it's actually slower than the original C/integer +// version // //#ifdef __APPLE__ //#include @@ -40,517 +41,644 @@ // #define BIT_ARRAY_BULLSHIT -static IT_PLAYING *new_playing() -{ - IT_PLAYING * r = (IT_PLAYING*) malloc(sizeof(*r)); - if (r) - { - r->resampler.fir_resampler_ratio = 0.0; - r->resampler.fir_resampler[0] = resampler_create(); - if ( !r->resampler.fir_resampler[0] ) { - free( r ); - return NULL; - } - r->resampler.fir_resampler[1] = resampler_create(); - if ( !r->resampler.fir_resampler[1] ) { - resampler_delete( r->resampler.fir_resampler[0] ); - free( r ); - return NULL; - } - } - return r; +static IT_PLAYING *new_playing() { + IT_PLAYING *r = (IT_PLAYING *)malloc(sizeof(*r)); + if (r) { + r->resampler.fir_resampler_ratio = 0.0; + r->resampler.fir_resampler[0] = resampler_create(); + if (!r->resampler.fir_resampler[0]) { + free(r); + return NULL; + } + r->resampler.fir_resampler[1] = resampler_create(); + if (!r->resampler.fir_resampler[1]) { + resampler_delete(r->resampler.fir_resampler[0]); + free(r); + return NULL; + } + } + return r; } -static void free_playing(IT_PLAYING * r) -{ - resampler_delete( r->resampler.fir_resampler[1] ); - resampler_delete( r->resampler.fir_resampler[0] ); - free( r ); +static void free_playing(IT_PLAYING *r) { + resampler_delete(r->resampler.fir_resampler[1]); + resampler_delete(r->resampler.fir_resampler[0]); + free(r); } -static IT_PLAYING *dup_playing(IT_PLAYING *src, IT_CHANNEL *dstchannel, IT_CHANNEL *srcchannel) -{ - IT_PLAYING *dst; +static IT_PLAYING *dup_playing(IT_PLAYING *src, IT_CHANNEL *dstchannel, + IT_CHANNEL *srcchannel) { + IT_PLAYING *dst; - if (!src) return NULL; + if (!src) + return NULL; - dst = malloc(sizeof(*dst)); - if (!dst) return NULL; + dst = malloc(sizeof(*dst)); + if (!dst) + return NULL; - dst->flags = src->flags; - dst->resampling_quality = src->resampling_quality; + dst->flags = src->flags; + dst->resampling_quality = src->resampling_quality; - ASSERT(src->channel); - dst->channel = &dstchannel[src->channel - srcchannel]; - dst->sample = src->sample; - dst->instrument = src->instrument; - dst->env_instrument = src->env_instrument; + ASSERT(src->channel); + dst->channel = &dstchannel[src->channel - srcchannel]; + dst->sample = src->sample; + dst->instrument = src->instrument; + dst->env_instrument = src->env_instrument; - dst->sampnum = src->sampnum; - dst->instnum = src->instnum; + dst->sampnum = src->sampnum; + dst->instnum = src->instnum; - dst->declick_stage = src->declick_stage; + dst->declick_stage = src->declick_stage; - dst->float_volume[0] = src->float_volume[0]; - dst->float_volume[1] = src->float_volume[1]; + dst->float_volume[0] = src->float_volume[0]; + dst->float_volume[1] = src->float_volume[1]; - dst->ramp_volume[0] = src->ramp_volume[0]; - dst->ramp_volume[1] = src->ramp_volume[1]; + dst->ramp_volume[0] = src->ramp_volume[0]; + dst->ramp_volume[1] = src->ramp_volume[1]; - dst->ramp_delta[0] = src->ramp_delta[0]; - dst->ramp_delta[1] = src->ramp_delta[1]; + dst->ramp_delta[0] = src->ramp_delta[0]; + dst->ramp_delta[1] = src->ramp_delta[1]; - dst->channel_volume = src->channel_volume; + dst->channel_volume = src->channel_volume; - dst->volume = src->volume; - dst->pan = src->pan; + dst->volume = src->volume; + dst->pan = src->pan; - dst->volume_offset = src->volume_offset; - dst->panning_offset = src->panning_offset; + dst->volume_offset = src->volume_offset; + dst->panning_offset = src->panning_offset; - dst->note = src->note; + dst->note = src->note; - dst->enabled_envelopes = src->enabled_envelopes; + dst->enabled_envelopes = src->enabled_envelopes; - dst->filter_cutoff = src->filter_cutoff; - dst->filter_resonance = src->filter_resonance; + dst->filter_cutoff = src->filter_cutoff; + dst->filter_resonance = src->filter_resonance; - dst->true_filter_cutoff = src->true_filter_cutoff; - dst->true_filter_resonance = src->true_filter_resonance; + dst->true_filter_cutoff = src->true_filter_cutoff; + dst->true_filter_resonance = src->true_filter_resonance; - dst->vibrato_speed = src->vibrato_speed; - dst->vibrato_depth = src->vibrato_depth; - dst->vibrato_n = src->vibrato_n; - dst->vibrato_time = src->vibrato_time; - dst->vibrato_waveform = src->vibrato_waveform; + dst->vibrato_speed = src->vibrato_speed; + dst->vibrato_depth = src->vibrato_depth; + dst->vibrato_n = src->vibrato_n; + dst->vibrato_time = src->vibrato_time; + dst->vibrato_waveform = src->vibrato_waveform; - dst->tremolo_speed = src->tremolo_speed; - dst->tremolo_depth = src->tremolo_depth; - dst->tremolo_time = src->tremolo_time; - dst->tremolo_waveform = src->tremolo_waveform; + dst->tremolo_speed = src->tremolo_speed; + dst->tremolo_depth = src->tremolo_depth; + dst->tremolo_time = src->tremolo_time; + dst->tremolo_waveform = src->tremolo_waveform; - dst->panbrello_speed = src->panbrello_speed; - dst->panbrello_depth = src->panbrello_depth; - dst->panbrello_time = src->panbrello_time; - dst->panbrello_waveform = src->panbrello_waveform; - dst->panbrello_random = src->panbrello_random; + dst->panbrello_speed = src->panbrello_speed; + dst->panbrello_depth = src->panbrello_depth; + dst->panbrello_time = src->panbrello_time; + dst->panbrello_waveform = src->panbrello_waveform; + dst->panbrello_random = src->panbrello_random; - dst->sample_vibrato_time = src->sample_vibrato_time; - dst->sample_vibrato_waveform = src->sample_vibrato_waveform; - dst->sample_vibrato_depth = src->sample_vibrato_depth; + dst->sample_vibrato_time = src->sample_vibrato_time; + dst->sample_vibrato_waveform = src->sample_vibrato_waveform; + dst->sample_vibrato_depth = src->sample_vibrato_depth; - dst->slide = src->slide; - dst->delta = src->delta; - dst->finetune = src->finetune; + dst->slide = src->slide; + dst->delta = src->delta; + dst->finetune = src->finetune; - dst->volume_envelope = src->volume_envelope; - dst->pan_envelope = src->pan_envelope; - dst->pitch_envelope = src->pitch_envelope; + dst->volume_envelope = src->volume_envelope; + dst->pan_envelope = src->pan_envelope; + dst->pitch_envelope = src->pitch_envelope; - dst->fadeoutcount = src->fadeoutcount; + dst->fadeoutcount = src->fadeoutcount; - dst->filter_state[0] = src->filter_state[0]; - dst->filter_state[1] = src->filter_state[1]; + dst->filter_state[0] = src->filter_state[0]; + dst->filter_state[1] = src->filter_state[1]; - dst->resampler = src->resampler; - dst->resampler.pickup_data = dst; - dst->resampler.fir_resampler_ratio = src->resampler.fir_resampler_ratio; - dst->resampler.fir_resampler[0] = resampler_dup( src->resampler.fir_resampler[0] ); - if ( !dst->resampler.fir_resampler[0] ) { - free( dst ); - return NULL; - } - dst->resampler.fir_resampler[1] = resampler_dup( src->resampler.fir_resampler[1] ); - if ( !dst->resampler.fir_resampler[1] ) { - resampler_delete( dst->resampler.fir_resampler[0] ); - free( dst ); - return NULL; - } - dst->time_lost = src->time_lost; + dst->resampler = src->resampler; + dst->resampler.pickup_data = dst; + dst->resampler.fir_resampler_ratio = src->resampler.fir_resampler_ratio; + dst->resampler.fir_resampler[0] = + resampler_dup(src->resampler.fir_resampler[0]); + if (!dst->resampler.fir_resampler[0]) { + free(dst); + return NULL; + } + dst->resampler.fir_resampler[1] = + resampler_dup(src->resampler.fir_resampler[1]); + if (!dst->resampler.fir_resampler[1]) { + resampler_delete(dst->resampler.fir_resampler[0]); + free(dst); + return NULL; + } + dst->time_lost = src->time_lost; - //dst->output = src->output; + // dst->output = src->output; - return dst; + return dst; } +static void dup_channel(IT_CHANNEL *dst, IT_CHANNEL *src) { + dst->flags = src->flags; + dst->volume = src->volume; + dst->volslide = src->volslide; + dst->xm_volslide = src->xm_volslide; + dst->panslide = src->panslide; -static void dup_channel(IT_CHANNEL *dst, IT_CHANNEL *src) -{ - dst->flags = src->flags; + dst->pan = src->pan; + dst->truepan = src->truepan; - dst->volume = src->volume; - dst->volslide = src->volslide; - dst->xm_volslide = src->xm_volslide; - dst->panslide = src->panslide; + dst->channelvolume = src->channelvolume; + dst->channelvolslide = src->channelvolslide; - dst->pan = src->pan; - dst->truepan = src->truepan; + dst->instrument = src->instrument; + dst->note = src->note; - dst->channelvolume = src->channelvolume; - dst->channelvolslide = src->channelvolslide; + dst->SFmacro = src->SFmacro; - dst->instrument = src->instrument; - dst->note = src->note; + dst->filter_cutoff = src->filter_cutoff; + dst->filter_resonance = src->filter_resonance; - dst->SFmacro = src->SFmacro; + dst->key_off_count = src->key_off_count; + dst->note_cut_count = src->note_cut_count; + dst->note_delay_count = src->note_delay_count; + dst->note_delay_entry = src->note_delay_entry; - dst->filter_cutoff = src->filter_cutoff; - dst->filter_resonance = src->filter_resonance; + dst->new_note_action = src->new_note_action; - dst->key_off_count = src->key_off_count; - dst->note_cut_count = src->note_cut_count; - dst->note_delay_count = src->note_delay_count; - dst->note_delay_entry = src->note_delay_entry; + dst->arpeggio_table = src->arpeggio_table; + memcpy(dst->arpeggio_offsets, src->arpeggio_offsets, + sizeof(dst->arpeggio_offsets)); + dst->retrig = src->retrig; + dst->xm_retrig = src->xm_retrig; + dst->retrig_tick = src->retrig_tick; - dst->new_note_action = src->new_note_action; + dst->tremor_time = src->tremor_time; - dst->arpeggio_table = src->arpeggio_table; - memcpy(dst->arpeggio_offsets, src->arpeggio_offsets, sizeof(dst->arpeggio_offsets)); - dst->retrig = src->retrig; - dst->xm_retrig = src->xm_retrig; - dst->retrig_tick = src->retrig_tick; + dst->vibrato_waveform = src->vibrato_waveform; + dst->tremolo_waveform = src->tremolo_waveform; + dst->panbrello_waveform = src->panbrello_waveform; - dst->tremor_time = src->tremor_time; + dst->portamento = src->portamento; + dst->toneporta = src->toneporta; + dst->toneslide = src->toneslide; + dst->toneslide_tick = src->toneslide_tick; + dst->last_toneslide_tick = src->last_toneslide_tick; + dst->ptm_toneslide = src->ptm_toneslide; + dst->ptm_last_toneslide = src->ptm_last_toneslide; + dst->okt_toneslide = src->okt_toneslide; + dst->destnote = src->destnote; - dst->vibrato_waveform = src->vibrato_waveform; - dst->tremolo_waveform = src->tremolo_waveform; - dst->panbrello_waveform = src->panbrello_waveform; + dst->glissando = src->glissando; - dst->portamento = src->portamento; - dst->toneporta = src->toneporta; - dst->toneslide = src->toneslide; - dst->toneslide_tick = src->toneslide_tick; - dst->last_toneslide_tick = src->last_toneslide_tick; - dst->ptm_toneslide = src->ptm_toneslide; - dst->ptm_last_toneslide = src->ptm_last_toneslide; - dst->okt_toneslide = src->okt_toneslide; - dst->destnote = src->destnote; + dst->sample = src->sample; + dst->truenote = src->truenote; - dst->glissando = src->glissando; + dst->midi_state = src->midi_state; - dst->sample = src->sample; - dst->truenote = src->truenote; + dst->lastvolslide = src->lastvolslide; + dst->lastDKL = src->lastDKL; + dst->lastEF = src->lastEF; + dst->lastG = src->lastG; + dst->lastHspeed = src->lastHspeed; + dst->lastHdepth = src->lastHdepth; + dst->lastRspeed = src->lastRspeed; + dst->lastRdepth = src->lastRdepth; + dst->lastYspeed = src->lastYspeed; + dst->lastYdepth = src->lastYdepth; + dst->lastI = src->lastI; + dst->lastJ = src->lastJ; + dst->lastN = src->lastN; + dst->lastO = src->lastO; + dst->high_offset = src->high_offset; + dst->lastP = src->lastP; + dst->lastQ = src->lastQ; + dst->lastS = src->lastS; + dst->pat_loop_row = src->pat_loop_row; + dst->pat_loop_count = src->pat_loop_count; + dst->pat_loop_end_row = src->pat_loop_end_row; + dst->lastW = src->lastW; - dst->midi_state = src->midi_state; + dst->xm_lastE1 = src->xm_lastE1; + dst->xm_lastE2 = src->xm_lastE2; + dst->xm_lastEA = src->xm_lastEA; + dst->xm_lastEB = src->xm_lastEB; + dst->xm_lastX1 = src->xm_lastX1; + dst->xm_lastX2 = src->xm_lastX2; - dst->lastvolslide = src->lastvolslide; - dst->lastDKL = src->lastDKL; - dst->lastEF = src->lastEF; - dst->lastG = src->lastG; - dst->lastHspeed = src->lastHspeed; - dst->lastHdepth = src->lastHdepth; - dst->lastRspeed = src->lastRspeed; - dst->lastRdepth = src->lastRdepth; - dst->lastYspeed = src->lastYspeed; - dst->lastYdepth = src->lastYdepth; - dst->lastI = src->lastI; - dst->lastJ = src->lastJ; - dst->lastN = src->lastN; - dst->lastO = src->lastO; - dst->high_offset = src->high_offset; - dst->lastP = src->lastP; - dst->lastQ = src->lastQ; - dst->lastS = src->lastS; - dst->pat_loop_row = src->pat_loop_row; - dst->pat_loop_count = src->pat_loop_count; - dst->pat_loop_end_row = src->pat_loop_end_row; - dst->lastW = src->lastW; + dst->inv_loop_delay = src->inv_loop_delay; + dst->inv_loop_speed = src->inv_loop_speed; + dst->inv_loop_offset = src->inv_loop_offset; - dst->xm_lastE1 = src->xm_lastE1; - dst->xm_lastE2 = src->xm_lastE2; - dst->xm_lastEA = src->xm_lastEA; - dst->xm_lastEB = src->xm_lastEB; - dst->xm_lastX1 = src->xm_lastX1; - dst->xm_lastX2 = src->xm_lastX2; - - dst->inv_loop_delay = src->inv_loop_delay; - dst->inv_loop_speed = src->inv_loop_speed; - dst->inv_loop_offset = src->inv_loop_offset; - - dst->playing = dup_playing(src->playing, dst, src); + dst->playing = dup_playing(src->playing, dst, src); #ifdef BIT_ARRAY_BULLSHIT - dst->played_patjump = bit_array_dup(src->played_patjump); - dst->played_patjump_order = src->played_patjump_order; + dst->played_patjump = bit_array_dup(src->played_patjump); + dst->played_patjump_order = src->played_patjump_order; #endif - //dst->output = src->output; + // dst->output = src->output; } - - /* Allocate the new callbacks first, then pass them to this function! * It will free them on failure. */ -static DUMB_IT_SIGRENDERER *dup_sigrenderer(DUMB_IT_SIGRENDERER *src, int n_channels, IT_CALLBACKS *callbacks) -{ - DUMB_IT_SIGRENDERER *dst; - int i; +static DUMB_IT_SIGRENDERER *dup_sigrenderer(DUMB_IT_SIGRENDERER *src, + int n_channels, + IT_CALLBACKS *callbacks) { + DUMB_IT_SIGRENDERER *dst; + int i; - if (!src) { - if (callbacks) free(callbacks); - return NULL; - } + if (!src) { + if (callbacks) + free(callbacks); + return NULL; + } - dst = malloc(sizeof(*dst)); - if (!dst) { - if (callbacks) free(callbacks); - return NULL; - } + dst = malloc(sizeof(*dst)); + if (!dst) { + if (callbacks) + free(callbacks); + return NULL; + } - dst->sigdata = src->sigdata; + dst->sigdata = src->sigdata; - dst->n_channels = n_channels; + dst->n_channels = n_channels; - dst->resampling_quality = src->resampling_quality; + dst->resampling_quality = src->resampling_quality; - dst->globalvolume = src->globalvolume; - dst->globalvolslide = src->globalvolslide; + dst->globalvolume = src->globalvolume; + dst->globalvolslide = src->globalvolslide; - dst->tempo = src->tempo; - dst->temposlide = src->temposlide; + dst->tempo = src->tempo; + dst->temposlide = src->temposlide; - for (i = 0; i < DUMB_IT_N_CHANNELS; i++) - dup_channel(&dst->channel[i], &src->channel[i]); + for (i = 0; i < DUMB_IT_N_CHANNELS; i++) + dup_channel(&dst->channel[i], &src->channel[i]); - for (i = 0; i < DUMB_IT_N_NNA_CHANNELS; i++) - dst->playing[i] = dup_playing(src->playing[i], dst->channel, src->channel); + for (i = 0; i < DUMB_IT_N_NNA_CHANNELS; i++) + dst->playing[i] = + dup_playing(src->playing[i], dst->channel, src->channel); - dst->tick = src->tick; - dst->speed = src->speed; - dst->rowcount = src->rowcount; + dst->tick = src->tick; + dst->speed = src->speed; + dst->rowcount = src->rowcount; - dst->order = src->order; - dst->row = src->row; - dst->processorder = src->processorder; - dst->processrow = src->processrow; - dst->breakrow = src->breakrow; + dst->order = src->order; + dst->row = src->row; + dst->processorder = src->processorder; + dst->processrow = src->processrow; + dst->breakrow = src->breakrow; - dst->restart_position = src->restart_position; + dst->restart_position = src->restart_position; - dst->n_rows = src->n_rows; + dst->n_rows = src->n_rows; - dst->entry_start = src->entry_start; - dst->entry = src->entry; - dst->entry_end = src->entry_end; + dst->entry_start = src->entry_start; + dst->entry = src->entry; + dst->entry_end = src->entry_end; - dst->time_left = src->time_left; - dst->sub_time_left = src->sub_time_left; + dst->time_left = src->time_left; + dst->sub_time_left = src->sub_time_left; - dst->ramp_style = src->ramp_style; + dst->ramp_style = src->ramp_style; - dst->click_remover = NULL; + dst->click_remover = NULL; - dst->callbacks = callbacks; + dst->callbacks = callbacks; #ifdef BIT_ARRAY_BULLSHIT - dst->played = bit_array_dup(src->played); + dst->played = bit_array_dup(src->played); - dst->looped = src->looped; - dst->time_played = src->time_played; - dst->row_timekeeper = timekeeping_array_dup(src->row_timekeeper); + dst->looped = src->looped; + dst->time_played = src->time_played; + dst->row_timekeeper = timekeeping_array_dup(src->row_timekeeper); #endif - dst->gvz_time = src->gvz_time; - dst->gvz_sub_time = src->gvz_sub_time; + dst->gvz_time = src->gvz_time; + dst->gvz_sub_time = src->gvz_sub_time; - //dst->max_output = src->max_output; + // dst->max_output = src->max_output; - return dst; + return dst; } - - static const IT_MIDI default_midi = { - /* unsigned char SFmacro[16][16]; */ - { - {0xF0, 0xF0, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00}, - {0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00}, - {0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00}, - {0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00}, - {0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00}, - {0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00}, - {0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00}, - {0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00}, - {0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00}, - {0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00}, - {0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00}, - {0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00}, - {0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00}, - {0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00}, - {0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00}, - {0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00} - }, - /* unsigned char SFmacrolen[16]; */ - {4, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0}, - /* unsigned short SFmacroz[16]; */ - /* Bitfield; bit 0 set = z in first position */ - { - 0x0008, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, - 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000 - }, - /* unsigned char Zmacro[128][16]; */ - { - {0xF0, 0xF0, 0x01, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00}, - {0xF0, 0xF0, 0x01, 0x08, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00}, - {0xF0, 0xF0, 0x01, 0x10, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00}, - {0xF0, 0xF0, 0x01, 0x18, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00}, - {0xF0, 0xF0, 0x01, 0x20, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00}, - {0xF0, 0xF0, 0x01, 0x28, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00}, - {0xF0, 0xF0, 0x01, 0x30, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00}, - {0xF0, 0xF0, 0x01, 0x38, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00}, - {0xF0, 0xF0, 0x01, 0x40, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00}, - {0xF0, 0xF0, 0x01, 0x48, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00}, - {0xF0, 0xF0, 0x01, 0x50, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00}, - {0xF0, 0xF0, 0x01, 0x58, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00}, - {0xF0, 0xF0, 0x01, 0x60, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00}, - {0xF0, 0xF0, 0x01, 0x68, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00}, - {0xF0, 0xF0, 0x01, 0x70, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00}, - {0xF0, 0xF0, 0x01, 0x78, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00}, + /* unsigned char SFmacro[16][16]; */ + {{0xF0, 0xF0, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, + 0x00, 0x00, 0x00, 0x00}, + {0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, + 0x00, 0x00, 0x00, 0x00}, + {0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, + 0x00, 0x00, 0x00, 0x00}, + {0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, + 0x00, 0x00, 0x00, 0x00}, + {0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, + 0x00, 0x00, 0x00, 0x00}, + {0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, + 0x00, 0x00, 0x00, 0x00}, + {0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, + 0x00, 0x00, 0x00, 0x00}, + {0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, + 0x00, 0x00, 0x00, 0x00}, + {0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, + 0x00, 0x00, 0x00, 0x00}, + {0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, + 0x00, 0x00, 0x00, 0x00}, + {0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, + 0x00, 0x00, 0x00, 0x00}, + {0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, + 0x00, 0x00, 0x00, 0x00}, + {0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, + 0x00, 0x00, 0x00, 0x00}, + {0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, + 0x00, 0x00, 0x00, 0x00}, + {0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, + 0x00, 0x00, 0x00, 0x00}, + {0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, + 0x00, 0x00, 0x00, 0x00}}, + /* unsigned char SFmacrolen[16]; */ + {4, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0}, + /* unsigned short SFmacroz[16]; */ + /* Bitfield; bit 0 set = z in first position */ + {0x0008, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, + 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000, 0x0000}, + /* unsigned char Zmacro[128][16]; */ + {{0xF0, 0xF0, 0x01, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, + 0x00, 0x00, 0x00, 0x00}, + {0xF0, 0xF0, 0x01, 0x08, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, + 0x00, 0x00, 0x00, 0x00}, + {0xF0, 0xF0, 0x01, 0x10, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, + 0x00, 0x00, 0x00, 0x00}, + {0xF0, 0xF0, 0x01, 0x18, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, + 0x00, 0x00, 0x00, 0x00}, + {0xF0, 0xF0, 0x01, 0x20, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, + 0x00, 0x00, 0x00, 0x00}, + {0xF0, 0xF0, 0x01, 0x28, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, + 0x00, 0x00, 0x00, 0x00}, + {0xF0, 0xF0, 0x01, 0x30, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, + 0x00, 0x00, 0x00, 0x00}, + {0xF0, 0xF0, 0x01, 0x38, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, + 0x00, 0x00, 0x00, 0x00}, + {0xF0, 0xF0, 0x01, 0x40, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, + 0x00, 0x00, 0x00, 0x00}, + {0xF0, 0xF0, 0x01, 0x48, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, + 0x00, 0x00, 0x00, 0x00}, + {0xF0, 0xF0, 0x01, 0x50, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, + 0x00, 0x00, 0x00, 0x00}, + {0xF0, 0xF0, 0x01, 0x58, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, + 0x00, 0x00, 0x00, 0x00}, + {0xF0, 0xF0, 0x01, 0x60, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, + 0x00, 0x00, 0x00, 0x00}, + {0xF0, 0xF0, 0x01, 0x68, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, + 0x00, 0x00, 0x00, 0x00}, + {0xF0, 0xF0, 0x01, 0x70, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, + 0x00, 0x00, 0x00, 0x00}, + {0xF0, 0xF0, 0x01, 0x78, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, + 0x00, 0x00, 0x00, 0x00}, - {0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00}, - {0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00}, - {0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00}, - {0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00}, - {0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00}, - {0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00}, - {0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00}, - {0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00}, - {0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00}, - {0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00}, - {0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00}, - {0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00}, - {0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00}, - {0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00}, - {0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00}, - {0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00}, + {0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, + 0x00, 0x00, 0x00, 0x00}, + {0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, + 0x00, 0x00, 0x00, 0x00}, + {0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, + 0x00, 0x00, 0x00, 0x00}, + {0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, + 0x00, 0x00, 0x00, 0x00}, + {0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, + 0x00, 0x00, 0x00, 0x00}, + {0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, + 0x00, 0x00, 0x00, 0x00}, + {0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, + 0x00, 0x00, 0x00, 0x00}, + {0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, + 0x00, 0x00, 0x00, 0x00}, + {0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, + 0x00, 0x00, 0x00, 0x00}, + {0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, + 0x00, 0x00, 0x00, 0x00}, + {0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, + 0x00, 0x00, 0x00, 0x00}, + {0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, + 0x00, 0x00, 0x00, 0x00}, + {0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, + 0x00, 0x00, 0x00, 0x00}, + {0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, + 0x00, 0x00, 0x00, 0x00}, + {0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, + 0x00, 0x00, 0x00, 0x00}, + {0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, + 0x00, 0x00, 0x00, 0x00}, - {0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00}, - {0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00}, - {0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00}, - {0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00}, - {0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00}, - {0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00}, - {0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00}, - {0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00}, - {0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00}, - {0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00}, - {0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00}, - {0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00}, - {0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00}, - {0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00}, - {0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00}, - {0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00}, + {0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, + 0x00, 0x00, 0x00, 0x00}, + {0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, + 0x00, 0x00, 0x00, 0x00}, + {0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, + 0x00, 0x00, 0x00, 0x00}, + {0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, + 0x00, 0x00, 0x00, 0x00}, + {0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, + 0x00, 0x00, 0x00, 0x00}, + {0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, + 0x00, 0x00, 0x00, 0x00}, + {0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, + 0x00, 0x00, 0x00, 0x00}, + {0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, + 0x00, 0x00, 0x00, 0x00}, + {0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, + 0x00, 0x00, 0x00, 0x00}, + {0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, + 0x00, 0x00, 0x00, 0x00}, + {0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, + 0x00, 0x00, 0x00, 0x00}, + {0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, + 0x00, 0x00, 0x00, 0x00}, + {0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, + 0x00, 0x00, 0x00, 0x00}, + {0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, + 0x00, 0x00, 0x00, 0x00}, + {0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, + 0x00, 0x00, 0x00, 0x00}, + {0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, + 0x00, 0x00, 0x00, 0x00}, - {0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00}, - {0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00}, - {0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00}, - {0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00}, - {0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00}, - {0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00}, - {0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00}, - {0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00}, - {0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00}, - {0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00}, - {0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00}, - {0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00}, - {0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00}, - {0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00}, - {0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00}, - {0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00}, + {0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, + 0x00, 0x00, 0x00, 0x00}, + {0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, + 0x00, 0x00, 0x00, 0x00}, + {0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, + 0x00, 0x00, 0x00, 0x00}, + {0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, + 0x00, 0x00, 0x00, 0x00}, + {0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, + 0x00, 0x00, 0x00, 0x00}, + {0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, + 0x00, 0x00, 0x00, 0x00}, + {0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, + 0x00, 0x00, 0x00, 0x00}, + {0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, + 0x00, 0x00, 0x00, 0x00}, + {0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, + 0x00, 0x00, 0x00, 0x00}, + {0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, + 0x00, 0x00, 0x00, 0x00}, + {0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, + 0x00, 0x00, 0x00, 0x00}, + {0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, + 0x00, 0x00, 0x00, 0x00}, + {0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, + 0x00, 0x00, 0x00, 0x00}, + {0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, + 0x00, 0x00, 0x00, 0x00}, + {0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, + 0x00, 0x00, 0x00, 0x00}, + {0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, + 0x00, 0x00, 0x00, 0x00}, - {0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00}, - {0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00}, - {0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00}, - {0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00}, - {0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00}, - {0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00}, - {0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00}, - {0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00}, - {0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00}, - {0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00}, - {0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00}, - {0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00}, - {0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00}, - {0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00}, - {0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00}, - {0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00}, + {0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, + 0x00, 0x00, 0x00, 0x00}, + {0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, + 0x00, 0x00, 0x00, 0x00}, + {0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, + 0x00, 0x00, 0x00, 0x00}, + {0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, + 0x00, 0x00, 0x00, 0x00}, + {0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, + 0x00, 0x00, 0x00, 0x00}, + {0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, + 0x00, 0x00, 0x00, 0x00}, + {0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, + 0x00, 0x00, 0x00, 0x00}, + {0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, + 0x00, 0x00, 0x00, 0x00}, + {0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, + 0x00, 0x00, 0x00, 0x00}, + {0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, + 0x00, 0x00, 0x00, 0x00}, + {0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, + 0x00, 0x00, 0x00, 0x00}, + {0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, + 0x00, 0x00, 0x00, 0x00}, + {0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, + 0x00, 0x00, 0x00, 0x00}, + {0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, + 0x00, 0x00, 0x00, 0x00}, + {0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, + 0x00, 0x00, 0x00, 0x00}, + {0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, + 0x00, 0x00, 0x00, 0x00}, - {0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00}, - {0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00}, - {0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00}, - {0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00}, - {0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00}, - {0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00}, - {0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00}, - {0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00}, - {0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00}, - {0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00}, - {0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00}, - {0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00}, - {0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00}, - {0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00}, - {0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00}, - {0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00}, + {0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, + 0x00, 0x00, 0x00, 0x00}, + {0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, + 0x00, 0x00, 0x00, 0x00}, + {0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, + 0x00, 0x00, 0x00, 0x00}, + {0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, + 0x00, 0x00, 0x00, 0x00}, + {0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, + 0x00, 0x00, 0x00, 0x00}, + {0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, + 0x00, 0x00, 0x00, 0x00}, + {0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, + 0x00, 0x00, 0x00, 0x00}, + {0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, + 0x00, 0x00, 0x00, 0x00}, + {0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, + 0x00, 0x00, 0x00, 0x00}, + {0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, + 0x00, 0x00, 0x00, 0x00}, + {0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, + 0x00, 0x00, 0x00, 0x00}, + {0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, + 0x00, 0x00, 0x00, 0x00}, + {0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, + 0x00, 0x00, 0x00, 0x00}, + {0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, + 0x00, 0x00, 0x00, 0x00}, + {0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, + 0x00, 0x00, 0x00, 0x00}, + {0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, + 0x00, 0x00, 0x00, 0x00}, - {0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00}, - {0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00}, - {0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00}, - {0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00}, - {0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00}, - {0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00}, - {0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00}, - {0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00}, - {0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00}, - {0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00}, - {0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00}, - {0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00}, - {0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00}, - {0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00}, - {0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00}, - {0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00}, + {0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, + 0x00, 0x00, 0x00, 0x00}, + {0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, + 0x00, 0x00, 0x00, 0x00}, + {0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, + 0x00, 0x00, 0x00, 0x00}, + {0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, + 0x00, 0x00, 0x00, 0x00}, + {0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, + 0x00, 0x00, 0x00, 0x00}, + {0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, + 0x00, 0x00, 0x00, 0x00}, + {0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, + 0x00, 0x00, 0x00, 0x00}, + {0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, + 0x00, 0x00, 0x00, 0x00}, + {0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, + 0x00, 0x00, 0x00, 0x00}, + {0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, + 0x00, 0x00, 0x00, 0x00}, + {0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, + 0x00, 0x00, 0x00, 0x00}, + {0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, + 0x00, 0x00, 0x00, 0x00}, + {0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, + 0x00, 0x00, 0x00, 0x00}, + {0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, + 0x00, 0x00, 0x00, 0x00}, + {0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, + 0x00, 0x00, 0x00, 0x00}, + {0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, + 0x00, 0x00, 0x00, 0x00}, - {0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00}, - {0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00}, - {0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00}, - {0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00}, - {0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00}, - {0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00}, - {0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00}, - {0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00}, - {0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00}, - {0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00}, - {0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00}, - {0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00}, - {0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00}, - {0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00}, - {0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00}, - {0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00} - }, - /* unsigned char Zmacrolen[128]; */ - { - 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, - 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, - 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, - 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, - 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, - 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, - 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, - 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0 - } -}; + {0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, + 0x00, 0x00, 0x00, 0x00}, + {0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, + 0x00, 0x00, 0x00, 0x00}, + {0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, + 0x00, 0x00, 0x00, 0x00}, + {0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, + 0x00, 0x00, 0x00, 0x00}, + {0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, + 0x00, 0x00, 0x00, 0x00}, + {0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, + 0x00, 0x00, 0x00, 0x00}, + {0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, + 0x00, 0x00, 0x00, 0x00}, + {0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, + 0x00, 0x00, 0x00, 0x00}, + {0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, + 0x00, 0x00, 0x00, 0x00}, + {0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, + 0x00, 0x00, 0x00, 0x00}, + {0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, + 0x00, 0x00, 0x00, 0x00}, + {0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, + 0x00, 0x00, 0x00, 0x00}, + {0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, + 0x00, 0x00, 0x00, 0x00}, + {0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, + 0x00, 0x00, 0x00, 0x00}, + {0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, + 0x00, 0x00, 0x00, 0x00}, + {0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, + 0x00, 0x00, 0x00, 0x00}}, + /* unsigned char Zmacrolen[128]; */ + {4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 4, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0}}; - - -static void it_reset_filter_state(IT_FILTER_STATE *state) -{ - state->currsample = 0; - state->prevsample = 0; +static void it_reset_filter_state(IT_FILTER_STATE *state) { + state->currsample = 0; + state->prevsample = 0; } - - #define LOG10 2.30258509299 /* IMPORTANT: This function expects one extra sample in 'src' so it can apply @@ -559,279 +687,313 @@ static void it_reset_filter_state(IT_FILTER_STATE *state) * click removal right. */ -static void it_filter_int(DUMB_CLICK_REMOVER *cr, IT_FILTER_STATE *state, sample_t *dst, long pos, sample_t *src, long size, int step, int sampfreq, int cutoff, int resonance) -{ - sample_t currsample = state->currsample; - sample_t prevsample = state->prevsample; +static void it_filter_int(DUMB_CLICK_REMOVER *cr, IT_FILTER_STATE *state, + sample_t *dst, long pos, sample_t *src, long size, + int step, int sampfreq, int cutoff, int resonance) { + sample_t currsample = state->currsample; + sample_t prevsample = state->prevsample; - float a, b, c; + float a, b, c; - long datasize; + long datasize; - { - float inv_angle = (float)(sampfreq * pow(0.5, 0.25 + cutoff*(1.0/(24< 2.0f) d = 2.0f; - d = (loss - d) * inv_angle; - e = inv_angle * inv_angle; - a = 1.0f / (1.0f + d + e); - c = -e * a; - b = 1.0f - a - c; + d = (1.0f - loss) / inv_angle; + if (d > 2.0f) + d = 2.0f; + d = (loss - d) * inv_angle; + e = inv_angle * inv_angle; + a = 1.0f / (1.0f + d + e); + c = -e * a; + b = 1.0f - a - c; #else - a = 1.0f / (inv_angle*inv_angle + inv_angle*loss + loss); - c = -(inv_angle*inv_angle) * a; - b = 1.0f - a - c; + a = 1.0f / (inv_angle * inv_angle + inv_angle * loss + loss); + c = -(inv_angle * inv_angle) * a; + b = 1.0f - a - c; #endif - } + } - dst += pos * step; - datasize = size * step; + dst += pos * step; + datasize = size * step; #define INT_FILTERS #ifdef INT_FILTERS #define MULSCA(a, b) ((int)((LONG_LONG)((a) << 4) * (b) >> 32)) #define SCALEB 12 - { - int ai = (int)(a * (1 << (16+SCALEB))); - int bi = (int)(b * (1 << (16+SCALEB))); - int ci = (int)(c * (1 << (16+SCALEB))); - int i; + { + int ai = (int)(a * (1 << (16 + SCALEB))); + int bi = (int)(b * (1 << (16 + SCALEB))); + int ci = (int)(c * (1 << (16 + SCALEB))); + int i; - if (cr) { - sample_t startstep = MULSCA(src[0], ai) + MULSCA(currsample, bi) + MULSCA(prevsample, ci); - dumb_record_click(cr, pos, startstep); - } + if (cr) { + sample_t startstep = MULSCA(src[0], ai) + MULSCA(currsample, bi) + + MULSCA(prevsample, ci); + dumb_record_click(cr, pos, startstep); + } - for (i = 0; i < datasize; i += step) { - { - sample_t newsample = MULSCA(src[i], ai) + MULSCA(currsample, bi) + MULSCA(prevsample, ci); - prevsample = currsample; - currsample = newsample; - } - dst[i] += currsample; - } + for (i = 0; i < datasize; i += step) { + { + sample_t newsample = MULSCA(src[i], ai) + + MULSCA(currsample, bi) + + MULSCA(prevsample, ci); + prevsample = currsample; + currsample = newsample; + } + dst[i] += currsample; + } - if (cr) { - sample_t endstep = MULSCA(src[datasize], ai) + MULSCA(currsample, bi) + MULSCA(prevsample, ci); - dumb_record_click(cr, pos + size, -endstep); - } - } + if (cr) { + sample_t endstep = MULSCA(src[datasize], ai) + + MULSCA(currsample, bi) + MULSCA(prevsample, ci); + dumb_record_click(cr, pos + size, -endstep); + } + } #else #error This version is broken - it does not use step, and state should contain floats for it - if (cr) { - float startstep = src[0]*a + currsample*b + prevsample*c; - dumb_record_click(cr, pos, (sample_t)startstep); - } + if (cr) { + float startstep = src[0] * a + currsample * b + prevsample * c; + dumb_record_click(cr, pos, (sample_t)startstep); + } - { - int i = size % 3; - while (i > 0) { - { - float newsample = *src++*a + currsample*b + prevsample*c; - prevsample = currsample; - currsample = newsample; - } - *dst++ += (sample_t)currsample; - i--; - } - i = size / 3; - while (i > 0) { - float newsample; - /* Gotta love unrolled loops! */ - *dst++ += (sample_t)(newsample = *src++*a + currsample*b + prevsample*c); - *dst++ += (sample_t)(prevsample = *src++*a + newsample*b + currsample*c); - *dst++ += (sample_t)(currsample = *src++*a + prevsample*b + newsample*c); - i--; - } - } + { + int i = size % 3; + while (i > 0) { + { + float newsample = *src++ * a + currsample * b + prevsample * c; + prevsample = currsample; + currsample = newsample; + } + *dst++ += (sample_t)currsample; + i--; + } + i = size / 3; + while (i > 0) { + float newsample; + /* Gotta love unrolled loops! */ + *dst++ += (sample_t)(newsample = *src++ * a + currsample * b + + prevsample * c); + *dst++ += (sample_t)(prevsample = *src++ * a + newsample * b + + currsample * c); + *dst++ += (sample_t)(currsample = *src++ * a + prevsample * b + + newsample * c); + i--; + } + } - if (cr) { - float endstep = src[datasize]*a + currsample*b + prevsample*c; - dumb_record_click(cr, pos + size, -(sample_t)endstep); - } + if (cr) { + float endstep = src[datasize] * a + currsample * b + prevsample * c; + dumb_record_click(cr, pos + size, -(sample_t)endstep); + } #endif - state->currsample = currsample; - state->prevsample = prevsample; + state->currsample = currsample; + state->prevsample = prevsample; } -#if defined(_USE_SSE) && (defined(_M_IX86) || defined(__i386__) || defined(_M_X64) || defined(__amd64__)) +#if defined(_USE_SSE) && (defined(_M_IX86) || defined(__i386__) || \ + defined(_M_X64) || defined(__amd64__)) #include -static void it_filter_sse(DUMB_CLICK_REMOVER *cr, IT_FILTER_STATE *state, sample_t *dst, long pos, sample_t *src, long size, int step, int sampfreq, int cutoff, int resonance) -{ - __m128 data, impulse; - __m128 temp1, temp2; +static void it_filter_sse(DUMB_CLICK_REMOVER *cr, IT_FILTER_STATE *state, + sample_t *dst, long pos, sample_t *src, long size, + int step, int sampfreq, int cutoff, int resonance) { + __m128 data, impulse; + __m128 temp1, temp2; - sample_t currsample = state->currsample; - sample_t prevsample = state->prevsample; + sample_t currsample = state->currsample; + sample_t prevsample = state->prevsample; - float imp[4]; + float imp[4]; - //profiler( filter_sse ); On ClawHammer Athlon64 3200+, ~12000 cycles, ~500 for that x87 setup code (as opposed to ~25500 for the original integer code) + // profiler( filter_sse ); On ClawHammer Athlon64 3200+, ~12000 cycles, ~500 + // for that x87 setup code (as opposed to ~25500 for the original integer + // code) - long datasize; + long datasize; - { - float inv_angle = (float)(sampfreq * pow(0.5, 0.25 + cutoff*(1.0/(24< 2.0f) d = 2.0f; - d = (loss - d) * inv_angle; - e = inv_angle * inv_angle; - imp[0] = 1.0f / (1.0f + d + e); - imp[2] = -e * imp[0]; - imp[1] = 1.0f - imp[0] - imp[2]; -#else - imp[0] = 1.0f / (inv_angle*inv_angle + inv_angle*loss + loss); - imp[2] = -(inv_angle*inv_angle) * imp[0]; - imp[1] = 1.0f - imp[0] - imp[2]; -#endif - imp[3] = 0.0f; - } - - dst += pos * step; - datasize = size * step; - - { - int ai, bi, ci, i; - - if (cr) { - sample_t startstep; - ai = (int)(imp[0] * (1 << (16+SCALEB))); - bi = (int)(imp[1] * (1 << (16+SCALEB))); - ci = (int)(imp[2] * (1 << (16+SCALEB))); - startstep = MULSCA(src[0], ai) + MULSCA(currsample, bi) + MULSCA(prevsample, ci); - dumb_record_click(cr, pos, startstep); - } - - temp1 = _mm_setzero_ps(); - data = _mm_cvtsi32_ss( temp1, currsample ); - temp2 = _mm_cvtsi32_ss( temp1, prevsample ); - impulse = _mm_loadu_ps( (const float *) &imp ); - data = _mm_shuffle_ps( data, temp2, _MM_SHUFFLE(1, 0, 0, 1) ); - - for (i = 0; i < datasize; i += step) { - temp1 = _mm_cvtsi32_ss( data, src [i] ); - temp1 = _mm_mul_ps( temp1, impulse ); - temp2 = _mm_movehl_ps( temp2, temp1 ); - temp1 = _mm_add_ps( temp1, temp2 ); - temp2 = temp1; - temp2 = _mm_shuffle_ps( temp2, temp1, _MM_SHUFFLE(0, 0, 0, 1) ); - temp1 = _mm_add_ps( temp1, temp2 ); - temp1 = _mm_shuffle_ps( temp1, data, _MM_SHUFFLE(2, 1, 0, 0) ); - data = temp1; - dst [i] += _mm_cvtss_si32( temp1 ); - } - - currsample = _mm_cvtss_si32( temp1 ); - temp1 = _mm_shuffle_ps( temp1, data, _MM_SHUFFLE(0, 0, 0, 2) ); - prevsample = _mm_cvtss_si32( temp1 ); - - if (cr) { - sample_t endstep = MULSCA(src[datasize], ai) + MULSCA(currsample, bi) + MULSCA(prevsample, ci); - dumb_record_click(cr, pos + size, -endstep); - } - } - - state->currsample = currsample; - state->prevsample = prevsample; -} -#endif - -#ifdef FILTER_NEON -static void it_filter_neon(DUMB_CLICK_REMOVER *cr, IT_FILTER_STATE *state, sample_t *dst, long pos, sample_t *src, long size, int step, int sampfreq, int cutoff, int resonance) -{ - float32x4_t data, impulse; - float32x4_t temp1; - float32x2_t temp2; - float32_t temp3; - - sample_t currsample = state->currsample; - sample_t prevsample = state->prevsample; - - float imp[4]; - - //profiler( filter_sse ); On ClawHammer Athlon64 3200+, ~12000 cycles, ~500 for that x87 setup code (as opposed to ~25500 for the original integer code) - - long datasize; - - { - float inv_angle = (float)(sampfreq * pow(0.5, 0.25 + cutoff*(1.0/(24< 2.0f) d = 2.0f; + if (d > 2.0f) + d = 2.0f; d = (loss - d) * inv_angle; e = inv_angle * inv_angle; imp[0] = 1.0f / (1.0f + d + e); imp[2] = -e * imp[0]; imp[1] = 1.0f - imp[0] - imp[2]; #else - imp[0] = 1.0f / (inv_angle*inv_angle + inv_angle*loss + loss); - imp[2] = -(inv_angle*inv_angle) * imp[0]; + imp[0] = 1.0f / (inv_angle * inv_angle + inv_angle * loss + loss); + imp[2] = -(inv_angle * inv_angle) * imp[0]; imp[1] = 1.0f - imp[0] - imp[2]; #endif imp[3] = 0.0f; } - + dst += pos * step; datasize = size * step; - + { int ai, bi, ci, i; - + if (cr) { sample_t startstep; - ai = (int)(imp[0] * (1 << (16+SCALEB))); - bi = (int)(imp[1] * (1 << (16+SCALEB))); - ci = (int)(imp[2] * (1 << (16+SCALEB))); - startstep = MULSCA(src[0], ai) + MULSCA(currsample, bi) + MULSCA(prevsample, ci); + ai = (int)(imp[0] * (1 << (16 + SCALEB))); + bi = (int)(imp[1] * (1 << (16 + SCALEB))); + ci = (int)(imp[2] * (1 << (16 + SCALEB))); + startstep = MULSCA(src[0], ai) + MULSCA(currsample, bi) + + MULSCA(prevsample, ci); dumb_record_click(cr, pos, startstep); } - - data = vdupq_n_f32(0.0f); - data = vsetq_lane_f32( currsample, data, 1 ); - data = vsetq_lane_f32( prevsample, data, 2 ); - impulse = vld1q_f32( (const float32_t *) &imp ); - + + temp1 = _mm_setzero_ps(); + data = _mm_cvtsi32_ss(temp1, currsample); + temp2 = _mm_cvtsi32_ss(temp1, prevsample); + impulse = _mm_loadu_ps((const float *)&imp); + data = _mm_shuffle_ps(data, temp2, _MM_SHUFFLE(1, 0, 0, 1)); + for (i = 0; i < datasize; i += step) { - data = vsetq_lane_f32( src [i], data, 0 ); + temp1 = _mm_cvtsi32_ss(data, src[i]); + temp1 = _mm_mul_ps(temp1, impulse); + temp2 = _mm_movehl_ps(temp2, temp1); + temp1 = _mm_add_ps(temp1, temp2); + temp2 = temp1; + temp2 = _mm_shuffle_ps(temp2, temp1, _MM_SHUFFLE(0, 0, 0, 1)); + temp1 = _mm_add_ps(temp1, temp2); + temp1 = _mm_shuffle_ps(temp1, data, _MM_SHUFFLE(2, 1, 0, 0)); + data = temp1; + dst[i] += _mm_cvtss_si32(temp1); + } + + currsample = _mm_cvtss_si32(temp1); + temp1 = _mm_shuffle_ps(temp1, data, _MM_SHUFFLE(0, 0, 0, 2)); + prevsample = _mm_cvtss_si32(temp1); + + if (cr) { + sample_t endstep = MULSCA(src[datasize], ai) + + MULSCA(currsample, bi) + MULSCA(prevsample, ci); + dumb_record_click(cr, pos + size, -endstep); + } + } + + state->currsample = currsample; + state->prevsample = prevsample; +} +#endif + +#ifdef FILTER_NEON +static void it_filter_neon(DUMB_CLICK_REMOVER *cr, IT_FILTER_STATE *state, + sample_t *dst, long pos, sample_t *src, long size, + int step, int sampfreq, int cutoff, int resonance) { + float32x4_t data, impulse; + float32x4_t temp1; + float32x2_t temp2; + float32_t temp3; + + sample_t currsample = state->currsample; + sample_t prevsample = state->prevsample; + + float imp[4]; + + // profiler( filter_sse ); On ClawHammer Athlon64 3200+, ~12000 cycles, ~500 + // for that x87 setup code (as opposed to ~25500 for the original integer + // code) + + long datasize; + + { + float inv_angle = + (float)(sampfreq * + pow(0.5, + 0.25 + cutoff * (1.0 / (24 << IT_ENVELOPE_SHIFT))) * + (1.0 / (2 * 3.14159265358979323846 * 110.0))); + float loss = (float)exp(resonance * (-LOG10 * 1.2 / 128.0)); + float d, e; +#if 0 + loss *= 2; // This is the mistake most players seem to make! +#endif + +#if 1 + d = (1.0f - loss) / inv_angle; + if (d > 2.0f) + d = 2.0f; + d = (loss - d) * inv_angle; + e = inv_angle * inv_angle; + imp[0] = 1.0f / (1.0f + d + e); + imp[2] = -e * imp[0]; + imp[1] = 1.0f - imp[0] - imp[2]; +#else + imp[0] = 1.0f / (inv_angle * inv_angle + inv_angle * loss + loss); + imp[2] = -(inv_angle * inv_angle) * imp[0]; + imp[1] = 1.0f - imp[0] - imp[2]; +#endif + imp[3] = 0.0f; + } + + dst += pos * step; + datasize = size * step; + + { + int ai, bi, ci, i; + + if (cr) { + sample_t startstep; + ai = (int)(imp[0] * (1 << (16 + SCALEB))); + bi = (int)(imp[1] * (1 << (16 + SCALEB))); + ci = (int)(imp[2] * (1 << (16 + SCALEB))); + startstep = MULSCA(src[0], ai) + MULSCA(currsample, bi) + + MULSCA(prevsample, ci); + dumb_record_click(cr, pos, startstep); + } + + data = vdupq_n_f32(0.0f); + data = vsetq_lane_f32(currsample, data, 1); + data = vsetq_lane_f32(prevsample, data, 2); + impulse = vld1q_f32((const float32_t *)&imp); + + for (i = 0; i < datasize; i += step) { + data = vsetq_lane_f32(src[i], data, 0); temp1 = vmulq_f32(data, impulse); temp2 = vadd_f32(vget_high_f32(temp1), vget_low_f32(temp1)); temp3 = vget_lane_f32(vpadd_f32(temp2, temp2), 0); data = vextq_f32(data, data, 3); data = vsetq_lane_f32(temp3, data, 1); - dst [i] += temp3; + dst[i] += temp3; } - + currsample = temp3; prevsample = vgetq_lane_f32(data, 2); - + if (cr) { - sample_t endstep = MULSCA(src[datasize], ai) + MULSCA(currsample, bi) + MULSCA(prevsample, ci); + sample_t endstep = MULSCA(src[datasize], ai) + + MULSCA(currsample, bi) + MULSCA(prevsample, ci); dumb_record_click(cr, pos + size, -endstep); } } - + state->currsample = currsample; state->prevsample = prevsample; } @@ -845,50 +1007,38 @@ static void it_filter_neon(DUMB_CLICK_REMOVER *cr, IT_FILTER_STATE *state, sampl #ifdef _MSC_VER #include #elif defined(__clang__) || defined(__GNUC__) -static inline void -__cpuid(int *data, int selector) -{ +static inline void __cpuid(int *data, int selector) { #if defined(__PIC__) && defined(__i386__) asm("xchgl %%ebx, %%esi; cpuid; xchgl %%ebx, %%esi" - : "=a" (data[0]), - "=S" (data[1]), - "=c" (data[2]), - "=d" (data[3]) - : "0" (selector)); + : "=a"(data[0]), "=S"(data[1]), "=c"(data[2]), "=d"(data[3]) + : "0"(selector)); #elif defined(__PIC__) && defined(__amd64__) asm("xchg{q} {%%}rbx, %q1; cpuid; xchg{q} {%%}rbx, %q1" - : "=a" (data[0]), - "=&r" (data[1]), - "=c" (data[2]), - "=d" (data[3]) - : "0" (selector)); + : "=a"(data[0]), "=&r"(data[1]), "=c"(data[2]), "=d"(data[3]) + : "0"(selector)); #else asm("cpuid" - : "=a" (data[0]), - "=b" (data[1]), - "=c" (data[2]), - "=d" (data[3]) + : "=a"(data[0]), "=b"(data[1]), "=c"(data[2]), "=d"(data[3]) : "a"(selector)); #endif } #else -#define __cpuid(a,b) memset((a), 0, sizeof(int) * 4) +#define __cpuid(a, b) memset((a), 0, sizeof(int) * 4) #endif static int query_cpu_feature_sse() { - int buffer[4]; - __cpuid(buffer,1); - if ((buffer[3]&(1<<25)) == 0) return 0; - return 1; + int buffer[4]; + __cpuid(buffer, 1); + if ((buffer[3] & (1 << 25)) == 0) + return 0; + return 1; } static int _dumb_it_use_sse = 0; -void _dumb_init_sse() -{ +void _dumb_init_sse() { static int initialized = 0; - if (!initialized) - { + if (!initialized) { _dumb_it_use_sse = query_cpu_feature_sse(); initialized = 1; } @@ -898,53 +1048,56 @@ void _dumb_init_sse() static const int _dumb_it_use_sse = 1; -void _dumb_init_sse() { } +void _dumb_init_sse() {} #else static const int _dumb_it_use_sse = 0; -void _dumb_init_sse() { } +void _dumb_init_sse() {} #endif #endif -static void it_filter(DUMB_CLICK_REMOVER *cr, IT_FILTER_STATE *state, sample_t *dst, long pos, sample_t *src, long size, int step, int sampfreq, int cutoff, int resonance) -{ -#if defined(_USE_SSE) && (defined(_M_IX86) || defined(__i386__) || defined(_M_X64) || defined(__amd64__)) +static void it_filter(DUMB_CLICK_REMOVER *cr, IT_FILTER_STATE *state, + sample_t *dst, long pos, sample_t *src, long size, + int step, int sampfreq, int cutoff, int resonance) { +#if defined(_USE_SSE) && (defined(_M_IX86) || defined(__i386__) || \ + defined(_M_X64) || defined(__amd64__)) _dumb_init_sse(); - if ( _dumb_it_use_sse ) it_filter_sse( cr, state, dst, pos, src, size, step, sampfreq, cutoff, resonance ); - else + if (_dumb_it_use_sse) + it_filter_sse(cr, state, dst, pos, src, size, step, sampfreq, cutoff, + resonance); + else #endif #ifdef FILTER_NEON - it_filter_neon( cr, state, dst, pos, src, size, step, sampfreq, cutoff, resonance ); + it_filter_neon(cr, state, dst, pos, src, size, step, sampfreq, cutoff, + resonance); #else - it_filter_int( cr, state, dst, pos, src, size, step, sampfreq, cutoff, resonance ); + it_filter_int(cr, state, dst, pos, src, size, step, sampfreq, cutoff, + resonance); #endif } - - static const signed char it_sine[256] = { - 0, 2, 3, 5, 6, 8, 9, 11, 12, 14, 16, 17, 19, 20, 22, 23, - 24, 26, 27, 29, 30, 32, 33, 34, 36, 37, 38, 39, 41, 42, 43, 44, - 45, 46, 47, 48, 49, 50, 51, 52, 53, 54, 55, 56, 56, 57, 58, 59, - 59, 60, 60, 61, 61, 62, 62, 62, 63, 63, 63, 64, 64, 64, 64, 64, - 64, 64, 64, 64, 64, 64, 63, 63, 63, 62, 62, 62, 61, 61, 60, 60, - 59, 59, 58, 57, 56, 56, 55, 54, 53, 52, 51, 50, 49, 48, 47, 46, - 45, 44, 43, 42, 41, 39, 38, 37, 36, 34, 33, 32, 30, 29, 27, 26, - 24, 23, 22, 20, 19, 17, 16, 14, 12, 11, 9, 8, 6, 5, 3, 2, - 0, -2, -3, -5, -6, -8, -9,-11,-12,-14,-16,-17,-19,-20,-22,-23, - -24,-26,-27,-29,-30,-32,-33,-34,-36,-37,-38,-39,-41,-42,-43,-44, - -45,-46,-47,-48,-49,-50,-51,-52,-53,-54,-55,-56,-56,-57,-58,-59, - -59,-60,-60,-61,-61,-62,-62,-62,-63,-63,-63,-64,-64,-64,-64,-64, - -64,-64,-64,-64,-64,-64,-63,-63,-63,-62,-62,-62,-61,-61,-60,-60, - -59,-59,-58,-57,-56,-56,-55,-54,-53,-52,-51,-50,-49,-48,-47,-46, - -45,-44,-43,-42,-41,-39,-38,-37,-36,-34,-33,-32,-30,-29,-27,-26, - -24,-23,-22,-20,-19,-17,-16,-14,-12,-11, -9, -8, -6, -5, -3, -2 -}; - - + 0, 2, 3, 5, 6, 8, 9, 11, 12, 14, 16, 17, 19, 20, 22, + 23, 24, 26, 27, 29, 30, 32, 33, 34, 36, 37, 38, 39, 41, 42, + 43, 44, 45, 46, 47, 48, 49, 50, 51, 52, 53, 54, 55, 56, 56, + 57, 58, 59, 59, 60, 60, 61, 61, 62, 62, 62, 63, 63, 63, 64, + 64, 64, 64, 64, 64, 64, 64, 64, 64, 64, 63, 63, 63, 62, 62, + 62, 61, 61, 60, 60, 59, 59, 58, 57, 56, 56, 55, 54, 53, 52, + 51, 50, 49, 48, 47, 46, 45, 44, 43, 42, 41, 39, 38, 37, 36, + 34, 33, 32, 30, 29, 27, 26, 24, 23, 22, 20, 19, 17, 16, 14, + 12, 11, 9, 8, 6, 5, 3, 2, 0, -2, -3, -5, -6, -8, -9, + -11, -12, -14, -16, -17, -19, -20, -22, -23, -24, -26, -27, -29, -30, -32, + -33, -34, -36, -37, -38, -39, -41, -42, -43, -44, -45, -46, -47, -48, -49, + -50, -51, -52, -53, -54, -55, -56, -56, -57, -58, -59, -59, -60, -60, -61, + -61, -62, -62, -62, -63, -63, -63, -64, -64, -64, -64, -64, -64, -64, -64, + -64, -64, -64, -63, -63, -63, -62, -62, -62, -61, -61, -60, -60, -59, -59, + -58, -57, -56, -56, -55, -54, -53, -52, -51, -50, -49, -48, -47, -46, -45, + -44, -43, -42, -41, -39, -38, -37, -36, -34, -33, -32, -30, -29, -27, -26, + -24, -23, -22, -20, -19, -17, -16, -14, -12, -11, -9, -8, -6, -5, -3, + -2}; #if 1 /** WARNING: use these! */ @@ -957,990 +1110,1056 @@ static const signed char it_sine[256] = { */ /** ENTHEH: IT also has the 'don't retrig' thingy :) */ static const signed char it_sawtooth[256] = { - 64, 63, 63, 62, 62, 61, 61, 60, 60, 59, 59, 58, 58, 57, 57, 56, - 56, 55, 55, 54, 54, 53, 53, 52, 52, 51, 51, 50, 50, 49, 49, 48, - 48, 47, 47, 46, 46, 45, 45, 44, 44, 43, 43, 42, 42, 41, 41, 40, - 40, 39, 39, 38, 38, 37, 37, 36, 36, 35, 35, 34, 34, 33, 33, 32, - 32, 31, 31, 30, 30, 29, 29, 28, 28, 27, 27, 26, 26, 25, 25, 24, - 24, 23, 23, 22, 22, 21, 21, 20, 20, 19, 19, 18, 18, 17, 17, 16, - 16, 15, 15, 14, 14, 13, 13, 12, 12, 11, 11, 10, 10, 9, 9, 8, - 8, 7, 7, 6, 6, 5, 5, 4, 4, 3, 3, 2, 2, 1, 1, 0, - 0, -1, -1, -2, -2, -3, -3, -4, -4, -5, -5, -6, -6, -7, -7, -8, - -8, -9, -9,-10,-10,-11,-11,-12,-12,-13,-13,-14,-14,-15,-15,-16, - -16,-17,-17,-18,-18,-19,-19,-20,-20,-21,-21,-22,-22,-23,-23,-24, - -24,-25,-25,-26,-26,-27,-27,-28,-28,-29,-29,-30,-30,-31,-31,-32, - -32,-33,-33,-34,-34,-35,-35,-36,-36,-37,-37,-38,-38,-39,-39,-40, - -40,-41,-41,-42,-42,-43,-43,-44,-44,-45,-45,-46,-46,-47,-47,-48, - -48,-49,-49,-50,-50,-51,-51,-52,-52,-53,-53,-54,-54,-55,-55,-56, - -56,-57,-57,-58,-58,-59,-59,-60,-60,-61,-61,-62,-62,-63,-63,-64 -}; + 64, 63, 63, 62, 62, 61, 61, 60, 60, 59, 59, 58, 58, 57, 57, + 56, 56, 55, 55, 54, 54, 53, 53, 52, 52, 51, 51, 50, 50, 49, + 49, 48, 48, 47, 47, 46, 46, 45, 45, 44, 44, 43, 43, 42, 42, + 41, 41, 40, 40, 39, 39, 38, 38, 37, 37, 36, 36, 35, 35, 34, + 34, 33, 33, 32, 32, 31, 31, 30, 30, 29, 29, 28, 28, 27, 27, + 26, 26, 25, 25, 24, 24, 23, 23, 22, 22, 21, 21, 20, 20, 19, + 19, 18, 18, 17, 17, 16, 16, 15, 15, 14, 14, 13, 13, 12, 12, + 11, 11, 10, 10, 9, 9, 8, 8, 7, 7, 6, 6, 5, 5, 4, + 4, 3, 3, 2, 2, 1, 1, 0, 0, -1, -1, -2, -2, -3, -3, + -4, -4, -5, -5, -6, -6, -7, -7, -8, -8, -9, -9, -10, -10, -11, + -11, -12, -12, -13, -13, -14, -14, -15, -15, -16, -16, -17, -17, -18, -18, + -19, -19, -20, -20, -21, -21, -22, -22, -23, -23, -24, -24, -25, -25, -26, + -26, -27, -27, -28, -28, -29, -29, -30, -30, -31, -31, -32, -32, -33, -33, + -34, -34, -35, -35, -36, -36, -37, -37, -38, -38, -39, -39, -40, -40, -41, + -41, -42, -42, -43, -43, -44, -44, -45, -45, -46, -46, -47, -47, -48, -48, + -49, -49, -50, -50, -51, -51, -52, -52, -53, -53, -54, -54, -55, -55, -56, + -56, -57, -57, -58, -58, -59, -59, -60, -60, -61, -61, -62, -62, -63, -63, + -64}; static const signed char it_squarewave[256] = { - 64, 64, 64, 64, 64, 64, 64, 64, 64, 64, 64, 64, 64, 64, 64, 64, - 64, 64, 64, 64, 64, 64, 64, 64, 64, 64, 64, 64, 64, 64, 64, 64, - 64, 64, 64, 64, 64, 64, 64, 64, 64, 64, 64, 64, 64, 64, 64, 64, - 64, 64, 64, 64, 64, 64, 64, 64, 64, 64, 64, 64, 64, 64, 64, 64, - 64, 64, 64, 64, 64, 64, 64, 64, 64, 64, 64, 64, 64, 64, 64, 64, - 64, 64, 64, 64, 64, 64, 64, 64, 64, 64, 64, 64, 64, 64, 64, 64, - 64, 64, 64, 64, 64, 64, 64, 64, 64, 64, 64, 64, 64, 64, 64, 64, - 64, 64, 64, 64, 64, 64, 64, 64, 64, 64, 64, 64, 64, 64, 64, 64, - 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, - 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, - 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, - 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, - 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, - 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, - 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, - 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0 -}; + 64, 64, 64, 64, 64, 64, 64, 64, 64, 64, 64, 64, 64, 64, 64, 64, 64, 64, 64, + 64, 64, 64, 64, 64, 64, 64, 64, 64, 64, 64, 64, 64, 64, 64, 64, 64, 64, 64, + 64, 64, 64, 64, 64, 64, 64, 64, 64, 64, 64, 64, 64, 64, 64, 64, 64, 64, 64, + 64, 64, 64, 64, 64, 64, 64, 64, 64, 64, 64, 64, 64, 64, 64, 64, 64, 64, 64, + 64, 64, 64, 64, 64, 64, 64, 64, 64, 64, 64, 64, 64, 64, 64, 64, 64, 64, 64, + 64, 64, 64, 64, 64, 64, 64, 64, 64, 64, 64, 64, 64, 64, 64, 64, 64, 64, 64, + 64, 64, 64, 64, 64, 64, 64, 64, 64, 64, 64, 64, 64, 64, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, + 0, 0, 0, 0, 0, 0, 0, 0, 0}; static const signed char it_xm_ramp[256] = { - 0, -1, -1, -2, -2, -3, -3, -4, -4, -5, -5, -6, -6, -7, -7, -8, - -8, -9, -9,-10,-10,-11,-11,-12,-12,-13,-13,-14,-14,-15,-15,-16, - -16,-17,-17,-18,-18,-19,-19,-20,-20,-21,-21,-22,-22,-23,-23,-24, - -24,-25,-25,-26,-26,-27,-27,-28,-28,-29,-29,-30,-30,-31,-31,-32, - -32,-33,-33,-34,-34,-35,-35,-36,-36,-37,-37,-38,-38,-39,-39,-40, - -40,-41,-41,-42,-42,-43,-43,-44,-44,-45,-45,-46,-46,-47,-47,-48, - -48,-49,-49,-50,-50,-51,-51,-52,-52,-53,-53,-54,-54,-55,-55,-56, - -56,-57,-57,-58,-58,-59,-59,-60,-60,-61,-61,-62,-62,-63,-63,-64, - 64, 63, 63, 62, 62, 61, 61, 60, 60, 59, 59, 58, 58, 57, 57, 56, - 56, 55, 55, 54, 54, 53, 53, 52, 52, 51, 51, 50, 50, 49, 49, 48, - 48, 47, 47, 46, 46, 45, 45, 44, 44, 43, 43, 42, 42, 41, 41, 40, - 40, 39, 39, 38, 38, 37, 37, 36, 36, 35, 35, 34, 34, 33, 33, 32, - 32, 31, 31, 30, 30, 29, 29, 28, 28, 27, 27, 26, 26, 25, 25, 24, - 24, 23, 23, 22, 22, 21, 21, 20, 20, 19, 19, 18, 18, 17, 17, 16, - 16, 15, 15, 14, 14, 13, 13, 12, 12, 11, 11, 10, 10, 9, 9, 8, - 8, 7, 7, 6, 6, 5, 5, 4, 4, 3, 3, 2, 2, 1, 1, 0 -}; + 0, -1, -1, -2, -2, -3, -3, -4, -4, -5, -5, -6, -6, -7, -7, + -8, -8, -9, -9, -10, -10, -11, -11, -12, -12, -13, -13, -14, -14, -15, + -15, -16, -16, -17, -17, -18, -18, -19, -19, -20, -20, -21, -21, -22, -22, + -23, -23, -24, -24, -25, -25, -26, -26, -27, -27, -28, -28, -29, -29, -30, + -30, -31, -31, -32, -32, -33, -33, -34, -34, -35, -35, -36, -36, -37, -37, + -38, -38, -39, -39, -40, -40, -41, -41, -42, -42, -43, -43, -44, -44, -45, + -45, -46, -46, -47, -47, -48, -48, -49, -49, -50, -50, -51, -51, -52, -52, + -53, -53, -54, -54, -55, -55, -56, -56, -57, -57, -58, -58, -59, -59, -60, + -60, -61, -61, -62, -62, -63, -63, -64, 64, 63, 63, 62, 62, 61, 61, + 60, 60, 59, 59, 58, 58, 57, 57, 56, 56, 55, 55, 54, 54, 53, + 53, 52, 52, 51, 51, 50, 50, 49, 49, 48, 48, 47, 47, 46, 46, + 45, 45, 44, 44, 43, 43, 42, 42, 41, 41, 40, 40, 39, 39, 38, + 38, 37, 37, 36, 36, 35, 35, 34, 34, 33, 33, 32, 32, 31, 31, + 30, 30, 29, 29, 28, 28, 27, 27, 26, 26, 25, 25, 24, 24, 23, + 23, 22, 22, 21, 21, 20, 20, 19, 19, 18, 18, 17, 17, 16, 16, + 15, 15, 14, 14, 13, 13, 12, 12, 11, 11, 10, 10, 9, 9, 8, + 8, 7, 7, 6, 6, 5, 5, 4, 4, 3, 3, 2, 2, 1, 1, + 0}; static const signed char it_xm_squarewave[256] = { - 64, 64, 64, 64, 64, 64, 64, 64, 64, 64, 64, 64, 64, 64, 64, 64, - 64, 64, 64, 64, 64, 64, 64, 64, 64, 64, 64, 64, 64, 64, 64, 64, - 64, 64, 64, 64, 64, 64, 64, 64, 64, 64, 64, 64, 64, 64, 64, 64, - 64, 64, 64, 64, 64, 64, 64, 64, 64, 64, 64, 64, 64, 64, 64, 64, - 64, 64, 64, 64, 64, 64, 64, 64, 64, 64, 64, 64, 64, 64, 64, 64, - 64, 64, 64, 64, 64, 64, 64, 64, 64, 64, 64, 64, 64, 64, 64, 64, - 64, 64, 64, 64, 64, 64, 64, 64, 64, 64, 64, 64, 64, 64, 64, 64, - 64, 64, 64, 64, 64, 64, 64, 64, 64, 64, 64, 64, 64, 64, 64, 64, - -64,-64,-64,-64,-64,-64,-64,-64,-64,-64,-64,-64,-64,-64,-64,-64, - -64,-64,-64,-64,-64,-64,-64,-64,-64,-64,-64,-64,-64,-64,-64,-64, - -64,-64,-64,-64,-64,-64,-64,-64,-64,-64,-64,-64,-64,-64,-64,-64, - -64,-64,-64,-64,-64,-64,-64,-64,-64,-64,-64,-64,-64,-64,-64,-64, - -64,-64,-64,-64,-64,-64,-64,-64,-64,-64,-64,-64,-64,-64,-64,-64, - -64,-64,-64,-64,-64,-64,-64,-64,-64,-64,-64,-64,-64,-64,-64,-64, - -64,-64,-64,-64,-64,-64,-64,-64,-64,-64,-64,-64,-64,-64,-64,-64, - -64,-64,-64,-64,-64,-64,-64,-64,-64,-64,-64,-64,-64,-64,-64,-64 -}; + 64, 64, 64, 64, 64, 64, 64, 64, 64, 64, 64, 64, 64, 64, 64, + 64, 64, 64, 64, 64, 64, 64, 64, 64, 64, 64, 64, 64, 64, 64, + 64, 64, 64, 64, 64, 64, 64, 64, 64, 64, 64, 64, 64, 64, 64, + 64, 64, 64, 64, 64, 64, 64, 64, 64, 64, 64, 64, 64, 64, 64, + 64, 64, 64, 64, 64, 64, 64, 64, 64, 64, 64, 64, 64, 64, 64, + 64, 64, 64, 64, 64, 64, 64, 64, 64, 64, 64, 64, 64, 64, 64, + 64, 64, 64, 64, 64, 64, 64, 64, 64, 64, 64, 64, 64, 64, 64, + 64, 64, 64, 64, 64, 64, 64, 64, 64, 64, 64, 64, 64, 64, 64, + 64, 64, 64, 64, 64, 64, 64, 64, -64, -64, -64, -64, -64, -64, -64, + -64, -64, -64, -64, -64, -64, -64, -64, -64, -64, -64, -64, -64, -64, -64, + -64, -64, -64, -64, -64, -64, -64, -64, -64, -64, -64, -64, -64, -64, -64, + -64, -64, -64, -64, -64, -64, -64, -64, -64, -64, -64, -64, -64, -64, -64, + -64, -64, -64, -64, -64, -64, -64, -64, -64, -64, -64, -64, -64, -64, -64, + -64, -64, -64, -64, -64, -64, -64, -64, -64, -64, -64, -64, -64, -64, -64, + -64, -64, -64, -64, -64, -64, -64, -64, -64, -64, -64, -64, -64, -64, -64, + -64, -64, -64, -64, -64, -64, -64, -64, -64, -64, -64, -64, -64, -64, -64, + -64, -64, -64, -64, -64, -64, -64, -64, -64, -64, -64, -64, -64, -64, -64, + -64}; #endif +static void reset_tick_counts(DUMB_IT_SIGRENDERER *sigrenderer) { + int i; - -static void reset_tick_counts(DUMB_IT_SIGRENDERER *sigrenderer) -{ - int i; - - for (i = 0; i < DUMB_IT_N_CHANNELS; i++) { - IT_CHANNEL *channel = &sigrenderer->channel[i]; - channel->key_off_count = 0; - channel->note_cut_count = 0; - channel->note_delay_count = 0; - } + for (i = 0; i < DUMB_IT_N_CHANNELS; i++) { + IT_CHANNEL *channel = &sigrenderer->channel[i]; + channel->key_off_count = 0; + channel->note_cut_count = 0; + channel->note_delay_count = 0; + } } +static const unsigned char arpeggio_mod[32] = {0, 1, 2, 0, 1, 2, 0, 1, 2, 0, 1, + 2, 0, 1, 2, 0, 1, 2, 0, 1, 2, 0, + 1, 2, 0, 1, 2, 0, 1, 2, 0, 1}; +static const unsigned char arpeggio_xm[32] = {0, 1, 2, 0, 1, 2, 0, 1, 2, 0, 1, + 2, 0, 1, 2, 0, 0, 2, 2, 2, 2, 2, + 2, 2, 2, 2, 2, 2, 2, 2, 2, 2}; +static const unsigned char arpeggio_okt_3[32] = { + 1, 0, 2, 1, 0, 2, 1, 0, 2, 1, 0, 2, 1, 0, 2, 1, + 0, 2, 1, 0, 2, 1, 0, 2, 1, 0, 2, 1, 0, 2, 1, 0}; +static const unsigned char arpeggio_okt_4[32] = { + 0, 2, 0, 1, 0, 2, 0, 1, 0, 2, 0, 1, 0, 2, 0, 1, + 0, 2, 0, 1, 0, 2, 0, 1, 0, 2, 0, 1, 0, 2, 0, 1}; +static const unsigned char arpeggio_okt_5[32] = { + 2, 2, 0, 2, 2, 0, 2, 2, 0, 2, 2, 0, 2, 2, 0, 2, + 2, 0, 2, 2, 0, 2, 2, 0, 2, 2, 0, 2, 2, 0, 2, 2}; - -static const unsigned char arpeggio_mod[32] = {0, 1, 2, 0, 1, 2, 0, 1, 2, 0, 1, 2, 0, 1, 2, 0, 1, 2, 0, 1, 2, 0, 1, 2, 0, 1, 2, 0, 1, 2, 0, 1}; -static const unsigned char arpeggio_xm[32] = {0, 1, 2, 0, 1, 2, 0, 1, 2, 0, 1, 2, 0, 1, 2, 0, 0, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2}; -static const unsigned char arpeggio_okt_3[32] = {1, 0, 2, 1, 0, 2, 1, 0, 2, 1, 0, 2, 1, 0, 2, 1, 0, 2, 1, 0, 2, 1, 0, 2, 1, 0, 2, 1, 0, 2, 1, 0}; -static const unsigned char arpeggio_okt_4[32] = {0, 2, 0, 1, 0, 2, 0, 1, 0, 2, 0, 1, 0, 2, 0, 1, 0, 2, 0, 1, 0, 2, 0, 1, 0, 2, 0, 1, 0, 2, 0, 1}; -static const unsigned char arpeggio_okt_5[32] = {2, 2, 0, 2, 2, 0, 2, 2, 0, 2, 2, 0, 2, 2, 0, 2, 2, 0, 2, 2, 0, 2, 2, 0, 2, 2, 0, 2, 2, 0, 2, 2}; - - - -static void reset_channel_effects(IT_CHANNEL *channel) -{ - channel->volslide = 0; - channel->xm_volslide = 0; - channel->panslide = 0; - channel->channelvolslide = 0; - channel->arpeggio_table = (const unsigned char *) &arpeggio_mod; - memset(channel->arpeggio_offsets, 0, sizeof(channel->arpeggio_offsets)); - channel->retrig = 0; - if (channel->xm_retrig) { - channel->xm_retrig = 0; - channel->retrig_tick = 0; - } - channel->tremor_time &= 127; - channel->portamento = 0; - channel->toneporta = 0; - if (channel->ptm_toneslide) { - channel->ptm_last_toneslide = channel->ptm_toneslide; - channel->last_toneslide_tick = channel->toneslide_tick; - } else - channel->ptm_last_toneslide = 0; - channel->ptm_toneslide = 0; - channel->toneslide_tick = 0; - channel->okt_toneslide = 0; - if (channel->playing) { - channel->playing->vibrato_n = 0; - channel->playing->tremolo_speed = 0; - channel->playing->tremolo_depth = 0; - channel->playing->panbrello_speed = 0; - } +static void reset_channel_effects(IT_CHANNEL *channel) { + channel->volslide = 0; + channel->xm_volslide = 0; + channel->panslide = 0; + channel->channelvolslide = 0; + channel->arpeggio_table = (const unsigned char *)&arpeggio_mod; + memset(channel->arpeggio_offsets, 0, sizeof(channel->arpeggio_offsets)); + channel->retrig = 0; + if (channel->xm_retrig) { + channel->xm_retrig = 0; + channel->retrig_tick = 0; + } + channel->tremor_time &= 127; + channel->portamento = 0; + channel->toneporta = 0; + if (channel->ptm_toneslide) { + channel->ptm_last_toneslide = channel->ptm_toneslide; + channel->last_toneslide_tick = channel->toneslide_tick; + } else + channel->ptm_last_toneslide = 0; + channel->ptm_toneslide = 0; + channel->toneslide_tick = 0; + channel->okt_toneslide = 0; + if (channel->playing) { + channel->playing->vibrato_n = 0; + channel->playing->tremolo_speed = 0; + channel->playing->tremolo_depth = 0; + channel->playing->panbrello_speed = 0; + } } -static void reset_effects(DUMB_IT_SIGRENDERER *sigrenderer) -{ - int i; +static void reset_effects(DUMB_IT_SIGRENDERER *sigrenderer) { + int i; - sigrenderer->globalvolslide = 0; - sigrenderer->temposlide = 0; + sigrenderer->globalvolslide = 0; + sigrenderer->temposlide = 0; - for (i = 0; i < DUMB_IT_N_CHANNELS; i++) { - reset_channel_effects(&sigrenderer->channel[i]); - } + for (i = 0; i < DUMB_IT_N_CHANNELS; i++) { + reset_channel_effects(&sigrenderer->channel[i]); + } } - - -static void update_tremor(IT_CHANNEL *channel) -{ - if ((channel->tremor_time & 128) && channel->playing) { - if (channel->tremor_time == 128) - channel->tremor_time = (channel->lastI >> 4) | 192; - else if (channel->tremor_time == 192) - channel->tremor_time = (channel->lastI & 15) | 128; - else - channel->tremor_time--; - } +static void update_tremor(IT_CHANNEL *channel) { + if ((channel->tremor_time & 128) && channel->playing) { + if (channel->tremor_time == 128) + channel->tremor_time = (channel->lastI >> 4) | 192; + else if (channel->tremor_time == 192) + channel->tremor_time = (channel->lastI & 15) | 128; + else + channel->tremor_time--; + } } - - -static void it_pickup_loop(DUMB_RESAMPLER *resampler, void *data) -{ - resampler->pos -= resampler->end - resampler->start; - ((IT_PLAYING *)data)->time_lost += resampler->end - resampler->start; +static void it_pickup_loop(DUMB_RESAMPLER *resampler, void *data) { + resampler->pos -= resampler->end - resampler->start; + ((IT_PLAYING *)data)->time_lost += resampler->end - resampler->start; } - - -static void it_pickup_pingpong_loop(DUMB_RESAMPLER *resampler, void *data) -{ - if (resampler->dir < 0) { - resampler->pos = (resampler->start << 1) - 1 - resampler->pos; - resampler->subpos ^= 65535; - resampler->dir = 1; - ((IT_PLAYING *)data)->time_lost += (resampler->end - resampler->start) << 1; - } else { - resampler->pos = (resampler->end << 1) - 1 - resampler->pos; - resampler->subpos ^= 65535; - resampler->dir = -1; - } +static void it_pickup_pingpong_loop(DUMB_RESAMPLER *resampler, void *data) { + if (resampler->dir < 0) { + resampler->pos = (resampler->start << 1) - 1 - resampler->pos; + resampler->subpos ^= 65535; + resampler->dir = 1; + ((IT_PLAYING *)data)->time_lost += (resampler->end - resampler->start) + << 1; + } else { + resampler->pos = (resampler->end << 1) - 1 - resampler->pos; + resampler->subpos ^= 65535; + resampler->dir = -1; + } } +static void it_pickup_stop_at_end(DUMB_RESAMPLER *resampler, void *data) { + (void)data; - -static void it_pickup_stop_at_end(DUMB_RESAMPLER *resampler, void *data) -{ - (void)data; - - if (resampler->dir < 0) { - resampler->pos = (resampler->start << 1) - 1 - resampler->pos; - resampler->subpos ^= 65535; - /* By rights, time_lost would be updated here. However, there is no - * need at this point; it will not be used. - * - * ((IT_PLAYING *)data)->time_lost += (resampler->src_end - resampler->src_start) << 1; - */ - resampler->dir = 1; - } else - resampler->dir = 0; + if (resampler->dir < 0) { + resampler->pos = (resampler->start << 1) - 1 - resampler->pos; + resampler->subpos ^= 65535; + /* By rights, time_lost would be updated here. However, there is no + * need at this point; it will not be used. + * + * ((IT_PLAYING *)data)->time_lost += (resampler->src_end - + * resampler->src_start) << 1; + */ + resampler->dir = 1; + } else + resampler->dir = 0; } +static void it_pickup_stop_after_reverse(DUMB_RESAMPLER *resampler, + void *data) { + (void)data; - -static void it_pickup_stop_after_reverse(DUMB_RESAMPLER *resampler, void *data) -{ - (void)data; - - resampler->dir = 0; + resampler->dir = 0; } - - -static void it_playing_update_resamplers(IT_PLAYING *playing) -{ - if ((playing->sample->flags & IT_SAMPLE_SUS_LOOP) && !(playing->flags & IT_PLAYING_SUSTAINOFF)) { - playing->resampler.start = playing->sample->sus_loop_start; - playing->resampler.end = playing->sample->sus_loop_end; - if (playing->resampler.start == playing->resampler.end) - playing->resampler.pickup = &it_pickup_stop_at_end; - else if (playing->sample->flags & IT_SAMPLE_PINGPONG_SUS_LOOP) - playing->resampler.pickup = &it_pickup_pingpong_loop; - else - playing->resampler.pickup = &it_pickup_loop; - } else if (playing->sample->flags & IT_SAMPLE_LOOP) { - playing->resampler.start = playing->sample->loop_start; - playing->resampler.end = playing->sample->loop_end; - if (playing->resampler.start == playing->resampler.end) - playing->resampler.pickup = &it_pickup_stop_at_end; - else if (playing->sample->flags & IT_SAMPLE_PINGPONG_LOOP) - playing->resampler.pickup = &it_pickup_pingpong_loop; - else - playing->resampler.pickup = &it_pickup_loop; - } else if (playing->flags & IT_PLAYING_REVERSE) { - playing->resampler.start = 0; - playing->resampler.end = playing->sample->length; - playing->resampler.dir = -1; - playing->resampler.pickup = &it_pickup_stop_after_reverse; - } else { - if (playing->sample->flags & IT_SAMPLE_SUS_LOOP) - playing->resampler.start = playing->sample->sus_loop_start; - else - playing->resampler.start = 0; - playing->resampler.end = playing->sample->length; - playing->resampler.pickup = &it_pickup_stop_at_end; - } - ASSERT(playing->resampler.pickup_data == playing); +static void it_playing_update_resamplers(IT_PLAYING *playing) { + if ((playing->sample->flags & IT_SAMPLE_SUS_LOOP) && + !(playing->flags & IT_PLAYING_SUSTAINOFF)) { + playing->resampler.start = playing->sample->sus_loop_start; + playing->resampler.end = playing->sample->sus_loop_end; + if (playing->resampler.start == playing->resampler.end) + playing->resampler.pickup = &it_pickup_stop_at_end; + else if (playing->sample->flags & IT_SAMPLE_PINGPONG_SUS_LOOP) + playing->resampler.pickup = &it_pickup_pingpong_loop; + else + playing->resampler.pickup = &it_pickup_loop; + } else if (playing->sample->flags & IT_SAMPLE_LOOP) { + playing->resampler.start = playing->sample->loop_start; + playing->resampler.end = playing->sample->loop_end; + if (playing->resampler.start == playing->resampler.end) + playing->resampler.pickup = &it_pickup_stop_at_end; + else if (playing->sample->flags & IT_SAMPLE_PINGPONG_LOOP) + playing->resampler.pickup = &it_pickup_pingpong_loop; + else + playing->resampler.pickup = &it_pickup_loop; + } else if (playing->flags & IT_PLAYING_REVERSE) { + playing->resampler.start = 0; + playing->resampler.end = playing->sample->length; + playing->resampler.dir = -1; + playing->resampler.pickup = &it_pickup_stop_after_reverse; + } else { + if (playing->sample->flags & IT_SAMPLE_SUS_LOOP) + playing->resampler.start = playing->sample->sus_loop_start; + else + playing->resampler.start = 0; + playing->resampler.end = playing->sample->length; + playing->resampler.pickup = &it_pickup_stop_at_end; + } + ASSERT(playing->resampler.pickup_data == playing); } - - /* This should be called whenever the sample or sample position changes. */ -static void it_playing_reset_resamplers(IT_PLAYING *playing, long pos) -{ - int bits = playing->sample->flags & IT_SAMPLE_16BIT ? 16 : 8; - int quality = playing->resampling_quality; - int channels = playing->sample->flags & IT_SAMPLE_STEREO ? 2 : 1; - if (playing->sample->max_resampling_quality >= 0 && quality > playing->sample->max_resampling_quality) - quality = playing->sample->max_resampling_quality; - dumb_reset_resampler_n(bits, &playing->resampler, playing->sample->data, channels, pos, 0, 0, quality); - playing->resampler.pickup_data = playing; - playing->time_lost = 0; - playing->flags &= ~IT_PLAYING_DEAD; - it_playing_update_resamplers(playing); +static void it_playing_reset_resamplers(IT_PLAYING *playing, long pos) { + int bits = playing->sample->flags & IT_SAMPLE_16BIT ? 16 : 8; + int quality = playing->resampling_quality; + int channels = playing->sample->flags & IT_SAMPLE_STEREO ? 2 : 1; + if (playing->sample->max_resampling_quality >= 0 && + quality > playing->sample->max_resampling_quality) + quality = playing->sample->max_resampling_quality; + dumb_reset_resampler_n(bits, &playing->resampler, playing->sample->data, + channels, pos, 0, 0, quality); + playing->resampler.pickup_data = playing; + playing->time_lost = 0; + playing->flags &= ~IT_PLAYING_DEAD; + it_playing_update_resamplers(playing); } -static void it_retrigger_note(DUMB_IT_SIGRENDERER *sigrenderer, IT_CHANNEL *channel); +static void it_retrigger_note(DUMB_IT_SIGRENDERER *sigrenderer, + IT_CHANNEL *channel); /* Should we only be retriggering short samples on XM? */ -static void update_retrig(DUMB_IT_SIGRENDERER *sigrenderer, IT_CHANNEL *channel) -{ - if (channel->xm_retrig) { - channel->retrig_tick--; - if (channel->retrig_tick <= 0) { - if (channel->playing) { - it_playing_reset_resamplers(channel->playing, 0); - channel->playing->declick_stage = 0; - } else if (sigrenderer->sigdata->flags & IT_WAS_AN_XM) it_retrigger_note(sigrenderer, channel); - channel->retrig_tick = channel->xm_retrig; - } - } else if (channel->retrig & 0x0F) { - channel->retrig_tick--; - if (channel->retrig_tick <= 0) { - if (channel->retrig < 0x10) { - } else if (channel->retrig < 0x20) { - channel->volume--; - if (channel->volume > 64) channel->volume = 0; - } else if (channel->retrig < 0x30) { - channel->volume -= 2; - if (channel->volume > 64) channel->volume = 0; - } else if (channel->retrig < 0x40) { - channel->volume -= 4; - if (channel->volume > 64) channel->volume = 0; - } else if (channel->retrig < 0x50) { - channel->volume -= 8; - if (channel->volume > 64) channel->volume = 0; - } else if (channel->retrig < 0x60) { - channel->volume -= 16; - if (channel->volume > 64) channel->volume = 0; - } else if (channel->retrig < 0x70) { - channel->volume <<= 1; - channel->volume /= 3; - } else if (channel->retrig < 0x80) { - channel->volume >>= 1; - } else if (channel->retrig < 0x90) { - } else if (channel->retrig < 0xA0) { - channel->volume++; - if (channel->volume > 64) channel->volume = 64; - } else if (channel->retrig < 0xB0) { - channel->volume += 2; - if (channel->volume > 64) channel->volume = 64; - } else if (channel->retrig < 0xC0) { - channel->volume += 4; - if (channel->volume > 64) channel->volume = 64; - } else if (channel->retrig < 0xD0) { - channel->volume += 8; - if (channel->volume > 64) channel->volume = 64; - } else if (channel->retrig < 0xE0) { - channel->volume += 16; - if (channel->volume > 64) channel->volume = 64; - } else if (channel->retrig < 0xF0) { - channel->volume *= 3; - channel->volume >>= 1; - if (channel->volume > 64) channel->volume = 64; - } else { - channel->volume <<= 1; - if (channel->volume > 64) channel->volume = 64; - } - if (channel->playing) { - it_playing_reset_resamplers(channel->playing, 0); - channel->playing->declick_stage = 0; - } else if (sigrenderer->sigdata->flags & IT_WAS_AN_XM) it_retrigger_note(sigrenderer, channel); - channel->retrig_tick = channel->retrig & 0x0F; - } - } +static void update_retrig(DUMB_IT_SIGRENDERER *sigrenderer, + IT_CHANNEL *channel) { + if (channel->xm_retrig) { + channel->retrig_tick--; + if (channel->retrig_tick <= 0) { + if (channel->playing) { + it_playing_reset_resamplers(channel->playing, 0); + channel->playing->declick_stage = 0; + } else if (sigrenderer->sigdata->flags & IT_WAS_AN_XM) + it_retrigger_note(sigrenderer, channel); + channel->retrig_tick = channel->xm_retrig; + } + } else if (channel->retrig & 0x0F) { + channel->retrig_tick--; + if (channel->retrig_tick <= 0) { + if (channel->retrig < 0x10) { + } else if (channel->retrig < 0x20) { + channel->volume--; + if (channel->volume > 64) + channel->volume = 0; + } else if (channel->retrig < 0x30) { + channel->volume -= 2; + if (channel->volume > 64) + channel->volume = 0; + } else if (channel->retrig < 0x40) { + channel->volume -= 4; + if (channel->volume > 64) + channel->volume = 0; + } else if (channel->retrig < 0x50) { + channel->volume -= 8; + if (channel->volume > 64) + channel->volume = 0; + } else if (channel->retrig < 0x60) { + channel->volume -= 16; + if (channel->volume > 64) + channel->volume = 0; + } else if (channel->retrig < 0x70) { + channel->volume <<= 1; + channel->volume /= 3; + } else if (channel->retrig < 0x80) { + channel->volume >>= 1; + } else if (channel->retrig < 0x90) { + } else if (channel->retrig < 0xA0) { + channel->volume++; + if (channel->volume > 64) + channel->volume = 64; + } else if (channel->retrig < 0xB0) { + channel->volume += 2; + if (channel->volume > 64) + channel->volume = 64; + } else if (channel->retrig < 0xC0) { + channel->volume += 4; + if (channel->volume > 64) + channel->volume = 64; + } else if (channel->retrig < 0xD0) { + channel->volume += 8; + if (channel->volume > 64) + channel->volume = 64; + } else if (channel->retrig < 0xE0) { + channel->volume += 16; + if (channel->volume > 64) + channel->volume = 64; + } else if (channel->retrig < 0xF0) { + channel->volume *= 3; + channel->volume >>= 1; + if (channel->volume > 64) + channel->volume = 64; + } else { + channel->volume <<= 1; + if (channel->volume > 64) + channel->volume = 64; + } + if (channel->playing) { + it_playing_reset_resamplers(channel->playing, 0); + channel->playing->declick_stage = 0; + } else if (sigrenderer->sigdata->flags & IT_WAS_AN_XM) + it_retrigger_note(sigrenderer, channel); + channel->retrig_tick = channel->retrig & 0x0F; + } + } } - -static void update_smooth_effects_playing(IT_PLAYING *playing) -{ - playing->vibrato_time += playing->vibrato_n * - (playing->vibrato_speed << 2); - playing->tremolo_time += playing->tremolo_speed << 2; - playing->panbrello_time += playing->panbrello_speed; - if (playing->panbrello_waveform == 3) - playing->panbrello_random = (rand() % 129) - 64; +static void update_smooth_effects_playing(IT_PLAYING *playing) { + playing->vibrato_time += playing->vibrato_n * (playing->vibrato_speed << 2); + playing->tremolo_time += playing->tremolo_speed << 2; + playing->panbrello_time += playing->panbrello_speed; + if (playing->panbrello_waveform == 3) + playing->panbrello_random = (rand() % 129) - 64; } -static void update_smooth_effects(DUMB_IT_SIGRENDERER *sigrenderer) -{ - int i; - - for (i = 0; i < DUMB_IT_N_CHANNELS; i++) { - IT_CHANNEL *channel = &sigrenderer->channel[i]; - IT_PLAYING *playing = channel->playing; - - if (playing) { - update_smooth_effects_playing(playing); - } - } - - for (i = 0; i < DUMB_IT_N_NNA_CHANNELS; i++) { - IT_PLAYING *playing = sigrenderer->playing[i]; - - if (playing) { - update_smooth_effects_playing(playing); - } - } -} - - -static const unsigned char pt_tab_invloop[16] = -{ - 0x00, 0x05, 0x06, 0x07, 0x08, 0x0A, 0x0B, 0x0D, - 0x0F, 0x13, 0x16, 0x1A, 0x20, 0x2B, 0x40, 0x80 -}; - -static void update_invert_loop(IT_CHANNEL *channel, IT_SAMPLE *sample) -{ - channel->inv_loop_delay += pt_tab_invloop[channel->inv_loop_speed]; - if (channel->inv_loop_delay >= 0x80) - { - channel->inv_loop_delay = 0; - - if (sample && ((sample->flags & (IT_SAMPLE_EXISTS | IT_SAMPLE_LOOP)) == (IT_SAMPLE_EXISTS | IT_SAMPLE_LOOP)) && !(sample->flags & (IT_SAMPLE_STEREO | IT_SAMPLE_16BIT))) - { - if (sample->loop_end - sample->loop_start >= 4) - { - channel->inv_loop_offset++; - if (channel->inv_loop_offset >= (sample->loop_end - sample->loop_start)) channel->inv_loop_offset = 0; - - ((char *)sample->data)[sample->loop_start + channel->inv_loop_offset] ^= 0xFF; - } - } - } -} - - -static void update_playing_effects(IT_PLAYING *playing) -{ - IT_CHANNEL *channel = playing->channel; - - if (channel->channelvolslide) { - playing->channel_volume = channel->channelvolume; - } - - if (channel->okt_toneslide) { - if (channel->okt_toneslide--) { - playing->note += channel->toneslide; - if (playing->note >= 120) { - if (channel->toneslide < 0) playing->note = 0; - else playing->note = 119; - } - } - } else if (channel->ptm_toneslide) { - if (--channel->toneslide_tick == 0) { - channel->toneslide_tick = channel->ptm_toneslide; - if (playing) { - playing->note += channel->toneslide; - if (playing->note >= 120) { - if (channel->toneslide < 0) playing->note = 0; - else playing->note = 119; - } - if (channel->playing == playing) { - channel->note = channel->truenote = playing->note; - } - if (channel->toneslide_retrig) { - it_playing_reset_resamplers(playing, 0); - playing->declick_stage = 0; - } - } - } - } -} - - -static void update_effects(DUMB_IT_SIGRENDERER *sigrenderer) -{ +static void update_smooth_effects(DUMB_IT_SIGRENDERER *sigrenderer) { int i; - if (sigrenderer->globalvolslide) { - sigrenderer->globalvolume += sigrenderer->globalvolslide; - if (sigrenderer->globalvolume > 128) { - if (sigrenderer->globalvolslide >= 0) - sigrenderer->globalvolume = 128; - else - sigrenderer->globalvolume = 0; - } - } + for (i = 0; i < DUMB_IT_N_CHANNELS; i++) { + IT_CHANNEL *channel = &sigrenderer->channel[i]; + IT_PLAYING *playing = channel->playing; - if (sigrenderer->temposlide) { - sigrenderer->tempo += sigrenderer->temposlide; - if (sigrenderer->tempo < 32) { - if (sigrenderer->temposlide >= 0) - sigrenderer->tempo = 255; - else - sigrenderer->tempo = 32; - } - } + if (playing) { + update_smooth_effects_playing(playing); + } + } - for (i = 0; i < DUMB_IT_N_CHANNELS; i++) { - IT_CHANNEL *channel = &sigrenderer->channel[i]; - IT_PLAYING *playing = channel->playing; + for (i = 0; i < DUMB_IT_N_NNA_CHANNELS; i++) { + IT_PLAYING *playing = sigrenderer->playing[i]; - if (channel->xm_volslide) { - channel->volume += channel->xm_volslide; - if (channel->volume > 64) { - if (channel->xm_volslide >= 0) - channel->volume = 64; - else - channel->volume = 0; - } - } - - if (channel->volslide) { - int clip = (sigrenderer->sigdata->flags & IT_WAS_AN_S3M) ? 63 : 64; - channel->volume += channel->volslide; - if (channel->volume > clip) { - if (channel->volslide >= 0) - channel->volume = clip; - else - channel->volume = 0; - } - } - - if (channel->panslide) { - if (sigrenderer->sigdata->flags & IT_WAS_AN_XM) { - if (IT_IS_SURROUND(channel->pan)) - { - channel->pan = 32; - channel->truepan = 32 + 128 * 64; - } - if (channel->panslide == -128) - channel->truepan = 32; - else - channel->truepan = MID(32, channel->truepan + channel->panslide*64, 32+255*64); - } else { - if (IT_IS_SURROUND(channel->pan)) - { - channel->pan = 32; - } - channel->pan += channel->panslide; - if (channel->pan > 64) { - if (channel->panslide >= 0) - channel->pan = 64; - else - channel->pan = 0; - } - channel->truepan = channel->pan << IT_ENVELOPE_SHIFT; - } - } - - if (channel->channelvolslide) { - channel->channelvolume += channel->channelvolslide; - if (channel->channelvolume > 64) { - if (channel->channelvolslide >= 0) - channel->channelvolume = 64; - else - channel->channelvolume = 0; - } - } - - update_tremor(channel); - - update_retrig(sigrenderer, channel); - - if (channel->inv_loop_speed) update_invert_loop(channel, playing ? playing->sample : NULL); - - if (playing) { - playing->slide += channel->portamento; - - if (sigrenderer->sigdata->flags & IT_LINEAR_SLIDES) { - if (channel->toneporta && channel->destnote < 120) { - int currpitch = ((playing->note - 60) << 8) + playing->slide; - int destpitch = (channel->destnote - 60) << 8; - if (currpitch > destpitch) { - currpitch -= channel->toneporta; - if (currpitch < destpitch) { - currpitch = destpitch; - channel->destnote = IT_NOTE_OFF; - } - } else if (currpitch < destpitch) { - currpitch += channel->toneporta; - if (currpitch > destpitch) { - currpitch = destpitch; - channel->destnote = IT_NOTE_OFF; - } - } - playing->slide = currpitch - ((playing->note - 60) << 8); - } - } else { - if (channel->toneporta && channel->destnote < 120) { - float amiga_multiplier = playing->sample->C5_speed * (1.0f / AMIGA_DIVISOR); - - float deltanote = (float)pow(DUMB_SEMITONE_BASE, 60 - playing->note); - /* deltanote is 1.0 for C-5, 0.5 for C-6, etc. */ - - float deltaslid = deltanote - playing->slide * amiga_multiplier; - - float destdelta = (float)pow(DUMB_SEMITONE_BASE, 60 - channel->destnote); - if (deltaslid < destdelta) { - playing->slide -= channel->toneporta; - deltaslid = deltanote - playing->slide * amiga_multiplier; - if (deltaslid > destdelta) { - playing->note = channel->destnote; - playing->slide = 0; - channel->destnote = IT_NOTE_OFF; - } - } else { - playing->slide += channel->toneporta; - deltaslid = deltanote - playing->slide * amiga_multiplier; - if (deltaslid < destdelta) { - playing->note = channel->destnote; - playing->slide = 0; - channel->destnote = IT_NOTE_OFF; - } - } - } - } - - update_playing_effects(playing); - } - } - - for (i = 0; i < DUMB_IT_N_NNA_CHANNELS; i++) { - IT_PLAYING *playing = sigrenderer->playing[i]; - if (playing) update_playing_effects(playing); - } - - update_smooth_effects(sigrenderer); + if (playing) { + update_smooth_effects_playing(playing); + } + } } +static const unsigned char pt_tab_invloop[16] = { + 0x00, 0x05, 0x06, 0x07, 0x08, 0x0A, 0x0B, 0x0D, + 0x0F, 0x13, 0x16, 0x1A, 0x20, 0x2B, 0x40, 0x80}; + +static void update_invert_loop(IT_CHANNEL *channel, IT_SAMPLE *sample) { + channel->inv_loop_delay += pt_tab_invloop[channel->inv_loop_speed]; + if (channel->inv_loop_delay >= 0x80) { + channel->inv_loop_delay = 0; + + if (sample && + ((sample->flags & (IT_SAMPLE_EXISTS | IT_SAMPLE_LOOP)) == + (IT_SAMPLE_EXISTS | IT_SAMPLE_LOOP)) && + !(sample->flags & (IT_SAMPLE_STEREO | IT_SAMPLE_16BIT))) { + if (sample->loop_end - sample->loop_start >= 4) { + channel->inv_loop_offset++; + if (channel->inv_loop_offset >= + (sample->loop_end - sample->loop_start)) + channel->inv_loop_offset = 0; + + ((char *)sample + ->data)[sample->loop_start + channel->inv_loop_offset] ^= + 0xFF; + } + } + } +} + +static void update_playing_effects(IT_PLAYING *playing) { + IT_CHANNEL *channel = playing->channel; + + if (channel->channelvolslide) { + playing->channel_volume = channel->channelvolume; + } + + if (channel->okt_toneslide) { + if (channel->okt_toneslide--) { + playing->note += channel->toneslide; + if (playing->note >= 120) { + if (channel->toneslide < 0) + playing->note = 0; + else + playing->note = 119; + } + } + } else if (channel->ptm_toneslide) { + if (--channel->toneslide_tick == 0) { + channel->toneslide_tick = channel->ptm_toneslide; + if (playing) { + playing->note += channel->toneslide; + if (playing->note >= 120) { + if (channel->toneslide < 0) + playing->note = 0; + else + playing->note = 119; + } + if (channel->playing == playing) { + channel->note = channel->truenote = playing->note; + } + if (channel->toneslide_retrig) { + it_playing_reset_resamplers(playing, 0); + playing->declick_stage = 0; + } + } + } + } +} + +static void update_effects(DUMB_IT_SIGRENDERER *sigrenderer) { + int i; + + if (sigrenderer->globalvolslide) { + sigrenderer->globalvolume += sigrenderer->globalvolslide; + if (sigrenderer->globalvolume > 128) { + if (sigrenderer->globalvolslide >= 0) + sigrenderer->globalvolume = 128; + else + sigrenderer->globalvolume = 0; + } + } + + if (sigrenderer->temposlide) { + sigrenderer->tempo += sigrenderer->temposlide; + if (sigrenderer->tempo < 32) { + if (sigrenderer->temposlide >= 0) + sigrenderer->tempo = 255; + else + sigrenderer->tempo = 32; + } + } + + for (i = 0; i < DUMB_IT_N_CHANNELS; i++) { + IT_CHANNEL *channel = &sigrenderer->channel[i]; + IT_PLAYING *playing = channel->playing; + + if (channel->xm_volslide) { + channel->volume += channel->xm_volslide; + if (channel->volume > 64) { + if (channel->xm_volslide >= 0) + channel->volume = 64; + else + channel->volume = 0; + } + } + + if (channel->volslide) { + int clip = (sigrenderer->sigdata->flags & IT_WAS_AN_S3M) ? 63 : 64; + channel->volume += channel->volslide; + if (channel->volume > clip) { + if (channel->volslide >= 0) + channel->volume = clip; + else + channel->volume = 0; + } + } + + if (channel->panslide) { + if (sigrenderer->sigdata->flags & IT_WAS_AN_XM) { + if (IT_IS_SURROUND(channel->pan)) { + channel->pan = 32; + channel->truepan = 32 + 128 * 64; + } + if (channel->panslide == -128) + channel->truepan = 32; + else + channel->truepan = + MID(32, channel->truepan + channel->panslide * 64, + 32 + 255 * 64); + } else { + if (IT_IS_SURROUND(channel->pan)) { + channel->pan = 32; + } + channel->pan += channel->panslide; + if (channel->pan > 64) { + if (channel->panslide >= 0) + channel->pan = 64; + else + channel->pan = 0; + } + channel->truepan = channel->pan << IT_ENVELOPE_SHIFT; + } + } + + if (channel->channelvolslide) { + channel->channelvolume += channel->channelvolslide; + if (channel->channelvolume > 64) { + if (channel->channelvolslide >= 0) + channel->channelvolume = 64; + else + channel->channelvolume = 0; + } + } + + update_tremor(channel); + + update_retrig(sigrenderer, channel); + + if (channel->inv_loop_speed) + update_invert_loop(channel, playing ? playing->sample : NULL); + + if (playing) { + playing->slide += channel->portamento; + + if (sigrenderer->sigdata->flags & IT_LINEAR_SLIDES) { + if (channel->toneporta && channel->destnote < 120) { + int currpitch = + ((playing->note - 60) << 8) + playing->slide; + int destpitch = (channel->destnote - 60) << 8; + if (currpitch > destpitch) { + currpitch -= channel->toneporta; + if (currpitch < destpitch) { + currpitch = destpitch; + channel->destnote = IT_NOTE_OFF; + } + } else if (currpitch < destpitch) { + currpitch += channel->toneporta; + if (currpitch > destpitch) { + currpitch = destpitch; + channel->destnote = IT_NOTE_OFF; + } + } + playing->slide = currpitch - ((playing->note - 60) << 8); + } + } else { + if (channel->toneporta && channel->destnote < 120) { + float amiga_multiplier = + playing->sample->C5_speed * (1.0f / AMIGA_DIVISOR); + + float deltanote = + (float)pow(DUMB_SEMITONE_BASE, 60 - playing->note); + /* deltanote is 1.0 for C-5, 0.5 for C-6, etc. */ + + float deltaslid = + deltanote - playing->slide * amiga_multiplier; + + float destdelta = + (float)pow(DUMB_SEMITONE_BASE, 60 - channel->destnote); + if (deltaslid < destdelta) { + playing->slide -= channel->toneporta; + deltaslid = + deltanote - playing->slide * amiga_multiplier; + if (deltaslid > destdelta) { + playing->note = channel->destnote; + playing->slide = 0; + channel->destnote = IT_NOTE_OFF; + } + } else { + playing->slide += channel->toneporta; + deltaslid = + deltanote - playing->slide * amiga_multiplier; + if (deltaslid < destdelta) { + playing->note = channel->destnote; + playing->slide = 0; + channel->destnote = IT_NOTE_OFF; + } + } + } + } + + update_playing_effects(playing); + } + } + + for (i = 0; i < DUMB_IT_N_NNA_CHANNELS; i++) { + IT_PLAYING *playing = sigrenderer->playing[i]; + if (playing) + update_playing_effects(playing); + } + + update_smooth_effects(sigrenderer); +} static void it_note_off(IT_PLAYING *playing); -// This function should be renamed; it doesn't do the 'Update Pattern Variables' operation ittech.txt describes +// This function should be renamed; it doesn't do the 'Update Pattern Variables' +// operation ittech.txt describes /* Returns 1 if a pattern loop is happening. */ -static int update_pattern_variables(DUMB_IT_SIGRENDERER *sigrenderer, IT_ENTRY *entry) -{ - IT_CHANNEL *channel = &sigrenderer->channel[(int)entry->channel]; +static int update_pattern_variables(DUMB_IT_SIGRENDERER *sigrenderer, + IT_ENTRY *entry) { + IT_CHANNEL *channel = &sigrenderer->channel[(int)entry->channel]; - if (entry->mask & IT_ENTRY_EFFECT) { - switch (entry->effect) { - case IT_JUMP_TO_ORDER: - /* XXX jump and break in same row */ - if ( ( ( sigrenderer->processrow | 0xC00 ) == 0xFFFE ) && - ! ( sigrenderer->processrow & 0x800 ) ) { - sigrenderer->processrow = 0xFFFE & ~0xC00; - } else { - sigrenderer->breakrow = 0; - sigrenderer->processrow = 0xFFFE & ~0x400; - } - sigrenderer->processorder = entry->effectvalue - 1; - break; + if (entry->mask & IT_ENTRY_EFFECT) { + switch (entry->effect) { + case IT_JUMP_TO_ORDER: + /* XXX jump and break in same row */ + if (((sigrenderer->processrow | 0xC00) == 0xFFFE) && + !(sigrenderer->processrow & 0x800)) { + sigrenderer->processrow = 0xFFFE & ~0xC00; + } else { + sigrenderer->breakrow = 0; + sigrenderer->processrow = 0xFFFE & ~0x400; + } + sigrenderer->processorder = entry->effectvalue - 1; + break; - case IT_S: - { - unsigned char effectvalue = entry->effectvalue; - if (sigrenderer->sigdata->flags & IT_WAS_AN_S3M) { - if (effectvalue == 0) - effectvalue = channel->lastDKL; - channel->lastDKL = effectvalue; - } else { - if (effectvalue == 0) - effectvalue = channel->lastS; - } - channel->lastS = effectvalue; - switch (effectvalue >> 4) { - case IT_S_PATTERN_LOOP: - { - unsigned char v = effectvalue & 15; - if (v == 0) { + case IT_S: { + unsigned char effectvalue = entry->effectvalue; + if (sigrenderer->sigdata->flags & IT_WAS_AN_S3M) { + if (effectvalue == 0) + effectvalue = channel->lastDKL; + channel->lastDKL = effectvalue; + } else { + if (effectvalue == 0) + effectvalue = channel->lastS; + } + channel->lastS = effectvalue; + switch (effectvalue >> 4) { + case IT_S_PATTERN_LOOP: { + unsigned char v = effectvalue & 15; + if (v == 0) { #ifdef BIT_ARRAY_BULLSHIT - if (!channel->played_patjump) - channel->played_patjump = bit_array_create(256); - else { - if ( channel->played_patjump_order != 0xFFFE && channel->played_patjump_order != sigrenderer->order ) - bit_array_merge(sigrenderer->played, channel->played_patjump, channel->played_patjump_order * 256); - //if (channel->played_patjump_order != sigrenderer->order) - bit_array_reset(channel->played_patjump); - } - channel->played_patjump_order = sigrenderer->order; + if (!channel->played_patjump) + channel->played_patjump = bit_array_create(256); + else { + if (channel->played_patjump_order != 0xFFFE && + channel->played_patjump_order != sigrenderer->order) + bit_array_merge( + sigrenderer->played, channel->played_patjump, + channel->played_patjump_order * 256); + // if (channel->played_patjump_order != + // sigrenderer->order) + bit_array_reset(channel->played_patjump); + } + channel->played_patjump_order = sigrenderer->order; #endif - channel->pat_loop_row = sigrenderer->processrow; - } else { - if (channel->pat_loop_count == 0) { + channel->pat_loop_row = sigrenderer->processrow; + } else { + if (channel->pat_loop_count == 0) { #ifdef BIT_ARRAY_BULLSHIT - /* wft, uninitialized and no start marker yet... */ - if (channel->played_patjump_order == 0xFFFE) { - int n; - bit_array_destroy(channel->played_patjump); - channel->played_patjump = bit_array_create(256); - for (n = channel->pat_loop_row; n <= sigrenderer->row; n++) - bit_array_clear(sigrenderer->played, sigrenderer->order * 256 + n); - channel->played_patjump_order = sigrenderer->order; - } else if (channel->played_patjump_order == sigrenderer->order) { - bit_array_set(channel->played_patjump, sigrenderer->row); - bit_array_mask(sigrenderer->played, channel->played_patjump, channel->played_patjump_order * 256); - //bit_array_reset(channel->played_patjump); - } + /* wft, uninitialized and no start marker yet... */ + if (channel->played_patjump_order == 0xFFFE) { + int n; + bit_array_destroy(channel->played_patjump); + channel->played_patjump = bit_array_create(256); + for (n = channel->pat_loop_row; + n <= sigrenderer->row; n++) + bit_array_clear(sigrenderer->played, + sigrenderer->order * 256 + n); + channel->played_patjump_order = sigrenderer->order; + } else if (channel->played_patjump_order == + sigrenderer->order) { + bit_array_set(channel->played_patjump, + sigrenderer->row); + bit_array_mask(sigrenderer->played, + channel->played_patjump, + channel->played_patjump_order * 256); + // bit_array_reset(channel->played_patjump); + } #endif - channel->pat_loop_count = v; - sigrenderer->breakrow = channel->pat_loop_row; - if ((sigrenderer->sigdata->flags & (IT_WAS_AN_XM|IT_WAS_A_MOD)) == IT_WAS_AN_XM) { - /* For XM files, if a loop occurs by itself, keep breakrow set for when the pattern ends - fun bug in FT2! */ - if ((sigrenderer->processrow|0xC00) < 0xFFFE) { - /* Infinite pattern loops are possible, so we check whether the pattern loop we're hitting now is earlier than the last one we hit. */ - if (sigrenderer->processrow < channel->pat_loop_end_row) - sigrenderer->processorder = 0xFFFE; /* suspect infinite loop, so trigger loop callback */ - else - sigrenderer->processorder = 0xFFFF; /* don't trigger loop callback */ - channel->pat_loop_end_row = sigrenderer->processrow; - sigrenderer->processrow = 0xFFFF; /* special case: don't reset breakrow or pat_loop_end_row */ - } - } else { - /* IT files do this regardless of other flow control effects seen here. */ - sigrenderer->processorder = 0xFFFF; /* special case: don't trigger loop callback */ - sigrenderer->processrow = 0xFFFE; - } - return 1; - } else if (--channel->pat_loop_count) { + channel->pat_loop_count = v; + sigrenderer->breakrow = channel->pat_loop_row; + if ((sigrenderer->sigdata->flags & + (IT_WAS_AN_XM | IT_WAS_A_MOD)) == IT_WAS_AN_XM) { + /* For XM files, if a loop occurs by itself, keep + * breakrow set for when the pattern ends - fun bug + * in FT2! */ + if ((sigrenderer->processrow | 0xC00) < 0xFFFE) { + /* Infinite pattern loops are possible, so we + * check whether the pattern loop we're hitting + * now is earlier than the last one we hit. */ + if (sigrenderer->processrow < + channel->pat_loop_end_row) + sigrenderer->processorder = + 0xFFFE; /* suspect infinite loop, so + trigger loop callback */ + else + sigrenderer->processorder = + 0xFFFF; /* don't trigger loop callback + */ + channel->pat_loop_end_row = + sigrenderer->processrow; + sigrenderer->processrow = + 0xFFFF; /* special case: don't reset + breakrow or pat_loop_end_row */ + } + } else { + /* IT files do this regardless of other flow control + * effects seen here. */ + sigrenderer->processorder = + 0xFFFF; /* special case: don't trigger loop + callback */ + sigrenderer->processrow = 0xFFFE; + } + return 1; + } else if (--channel->pat_loop_count) { #ifdef BIT_ARRAY_BULLSHIT - if (channel->played_patjump_order == sigrenderer->order) { - bit_array_set(channel->played_patjump, sigrenderer->row); - bit_array_mask(sigrenderer->played, channel->played_patjump, channel->played_patjump_order * 256); - //bit_array_reset(channel->played_patjump); - } + if (channel->played_patjump_order == + sigrenderer->order) { + bit_array_set(channel->played_patjump, + sigrenderer->row); + bit_array_mask(sigrenderer->played, + channel->played_patjump, + channel->played_patjump_order * 256); + // bit_array_reset(channel->played_patjump); + } #endif - sigrenderer->breakrow = channel->pat_loop_row; - if ((sigrenderer->sigdata->flags & (IT_WAS_AN_XM|IT_WAS_A_MOD)) == IT_WAS_AN_XM) { - /* For XM files, if a loop occurs by itself, keep breakrow set for when the pattern ends - fun bug in FT2! */ - if ((sigrenderer->processrow|0xC00) < 0xFFFE) { - /* Infinite pattern loops are possible, so we check whether the pattern loop we're hitting now is earlier than the last one we hit. */ - if (sigrenderer->processrow < channel->pat_loop_end_row) - sigrenderer->processorder = 0xFFFE; /* suspect infinite loop, so trigger loop callback */ - else - sigrenderer->processorder = 0xFFFF; /* don't trigger loop callback */ - channel->pat_loop_end_row = sigrenderer->processrow; - sigrenderer->processrow = 0xFFFF; /* special case: don't reset breakrow or pat_loop_end_row */ - } - } else { - /* IT files do this regardless of other flow control effects seen here. */ - sigrenderer->processorder = 0xFFFF; /* special case: don't trigger loop callback */ - sigrenderer->processrow = 0xFFFE; - } - return 1; - } else if ((sigrenderer->sigdata->flags & (IT_WAS_AN_XM|IT_WAS_A_MOD)) == IT_WAS_AN_XM) { - channel->pat_loop_end_row = 0; - // TODO - /* Findings: - - If a pattern loop completes successfully, and then the pattern terminates, then the next pattern will start on the row corresponding to the E60. - - If a pattern loop doesn't do any loops, and then the pattern terminates, then the next pattern will start on the first row. - - If a break appears to the left of the pattern loop, it jumps into the relevant position in the next pattern, and that's it. - - If a break appears to the right of the pattern loop, it jumps to the start of the next pattern, and that's it. - - If we jump, then effect a loop using an old E60, and then the pattern ends, the next pattern starts on the row corresponding to the E60. - - Theory: breakrow is not cleared when it's a pattern loop effect! - */ - if ((sigrenderer->processrow | 0xC00) < 0xFFFE) // I have no idea if this is correct or not - FT2 is so weird :( - sigrenderer->breakrow = channel->pat_loop_row; /* emulate bug in FT2 */ - } else - channel->pat_loop_row = sigrenderer->processrow + 1; + sigrenderer->breakrow = channel->pat_loop_row; + if ((sigrenderer->sigdata->flags & + (IT_WAS_AN_XM | IT_WAS_A_MOD)) == IT_WAS_AN_XM) { + /* For XM files, if a loop occurs by itself, keep + * breakrow set for when the pattern ends - fun bug + * in FT2! */ + if ((sigrenderer->processrow | 0xC00) < 0xFFFE) { + /* Infinite pattern loops are possible, so we + * check whether the pattern loop we're hitting + * now is earlier than the last one we hit. */ + if (sigrenderer->processrow < + channel->pat_loop_end_row) + sigrenderer->processorder = + 0xFFFE; /* suspect infinite loop, so + trigger loop callback */ + else + sigrenderer->processorder = + 0xFFFF; /* don't trigger loop callback + */ + channel->pat_loop_end_row = + sigrenderer->processrow; + sigrenderer->processrow = + 0xFFFF; /* special case: don't reset + breakrow or pat_loop_end_row */ + } + } else { + /* IT files do this regardless of other flow control + * effects seen here. */ + sigrenderer->processorder = + 0xFFFF; /* special case: don't trigger loop + callback */ + sigrenderer->processrow = 0xFFFE; + } + return 1; + } else if ((sigrenderer->sigdata->flags & + (IT_WAS_AN_XM | IT_WAS_A_MOD)) == + IT_WAS_AN_XM) { + channel->pat_loop_end_row = 0; + // TODO + /* Findings: + - If a pattern loop completes successfully, and then the + pattern terminates, then the next pattern will start on + the row corresponding to the E60. + - If a pattern loop doesn't do any loops, and then the + pattern terminates, then the next pattern will start on + the first row. + - If a break appears to the left of the pattern loop, it + jumps into the relevant position in the next pattern, + and that's it. + - If a break appears to the right of the pattern loop, + it jumps to the start of the next pattern, and that's + it. + - If we jump, then effect a loop using an old E60, and + then the pattern ends, the next pattern starts on the + row corresponding to the E60. + - Theory: breakrow is not cleared when it's a pattern + loop effect! + */ + if ((sigrenderer->processrow | 0xC00) < + 0xFFFE) // I have no idea if this is correct or not + // - FT2 is so weird :( + sigrenderer->breakrow = + channel->pat_loop_row; /* emulate bug in FT2 */ + } else + channel->pat_loop_row = sigrenderer->processrow + 1; #ifdef BIT_ARRAY_BULLSHIT - /*channel->played_patjump_order |= 0x8000;*/ - if (channel->played_patjump_order == sigrenderer->order) { - bit_array_destroy(channel->played_patjump); - channel->played_patjump = 0; - channel->played_patjump_order = 0xFFFE; - } - bit_array_clear(sigrenderer->played, sigrenderer->order * 256 + sigrenderer->row); + /*channel->played_patjump_order |= 0x8000;*/ + if (channel->played_patjump_order == sigrenderer->order) { + bit_array_destroy(channel->played_patjump); + channel->played_patjump = 0; + channel->played_patjump_order = 0xFFFE; + } + bit_array_clear(sigrenderer->played, + sigrenderer->order * 256 + + sigrenderer->row); #endif - } - } - break; - case IT_S_PATTERN_DELAY: - sigrenderer->rowcount = 1 + (effectvalue & 15); - break; - } - } - } - } + } + } break; + case IT_S_PATTERN_DELAY: + sigrenderer->rowcount = 1 + (effectvalue & 15); + break; + } + } + } + } - return 0; + return 0; } - - /* This function guarantees that channel->sample will always be valid if it * is nonzero. In other words, to check if it is valid, simply check if it is * nonzero. */ -static void instrument_to_sample(DUMB_IT_SIGDATA *sigdata, IT_CHANNEL *channel) -{ - if (sigdata->flags & IT_USE_INSTRUMENTS) { - if (channel->instrument >= 1 && channel->instrument <= sigdata->n_instruments) { - if (channel->note < 120) { - channel->sample = sigdata->instrument[channel->instrument-1].map_sample[channel->note]; - channel->truenote = sigdata->instrument[channel->instrument-1].map_note[channel->note]; - } else - channel->sample = 0; - } else - channel->sample = 0; - } else { - channel->sample = channel->instrument; - channel->truenote = channel->note; - } - if (!(channel->sample >= 1 && channel->sample <= sigdata->n_samples && (sigdata->sample[channel->sample-1].flags & IT_SAMPLE_EXISTS) && sigdata->sample[channel->sample-1].C5_speed)) - channel->sample = 0; +static void instrument_to_sample(DUMB_IT_SIGDATA *sigdata, + IT_CHANNEL *channel) { + if (sigdata->flags & IT_USE_INSTRUMENTS) { + if (channel->instrument >= 1 && + channel->instrument <= sigdata->n_instruments) { + if (channel->note < 120) { + channel->sample = sigdata->instrument[channel->instrument - 1] + .map_sample[channel->note]; + channel->truenote = sigdata->instrument[channel->instrument - 1] + .map_note[channel->note]; + } else + channel->sample = 0; + } else + channel->sample = 0; + } else { + channel->sample = channel->instrument; + channel->truenote = channel->note; + } + if (!(channel->sample >= 1 && channel->sample <= sigdata->n_samples && + (sigdata->sample[channel->sample - 1].flags & IT_SAMPLE_EXISTS) && + sigdata->sample[channel->sample - 1].C5_speed)) + channel->sample = 0; } +static void fix_sample_looping(IT_PLAYING *playing) { + if ((playing->sample->flags & (IT_SAMPLE_LOOP | IT_SAMPLE_SUS_LOOP)) == + (IT_SAMPLE_LOOP | IT_SAMPLE_SUS_LOOP)) { + if (playing->resampler.dir < 0) { + playing->resampler.pos = (playing->sample->sus_loop_end << 1) - 1 - + playing->resampler.pos; + playing->resampler.subpos ^= 65535; + playing->resampler.dir = 1; + } - -static void fix_sample_looping(IT_PLAYING *playing) -{ - if ((playing->sample->flags & (IT_SAMPLE_LOOP | IT_SAMPLE_SUS_LOOP)) == - (IT_SAMPLE_LOOP | IT_SAMPLE_SUS_LOOP)) { - if (playing->resampler.dir < 0) { - playing->resampler.pos = (playing->sample->sus_loop_end << 1) - 1 - playing->resampler.pos; - playing->resampler.subpos ^= 65535; - playing->resampler.dir = 1; - } - - playing->resampler.pos += playing->time_lost; - // XXX what - playing->time_lost = 0; - } + playing->resampler.pos += playing->time_lost; + // XXX what + playing->time_lost = 0; + } } +static void it_compatible_gxx_retrigger(DUMB_IT_SIGDATA *sigdata, + IT_CHANNEL *channel) { + int flags = 0; + if (channel->sample) { + if (sigdata->flags & IT_USE_INSTRUMENTS) { + if (!(channel->playing->flags & IT_PLAYING_SUSTAINOFF)) { + if (channel->playing->env_instrument->volume_envelope.flags & + IT_ENVELOPE_CARRY) + flags |= 1; + if (channel->playing->env_instrument->pan_envelope.flags & + IT_ENVELOPE_CARRY) + flags |= 2; + if (channel->playing->env_instrument->pitch_envelope.flags & + IT_ENVELOPE_CARRY) + flags |= 4; + } + } + } + if (!(flags & 1)) { + channel->playing->volume_envelope.next_node = 0; + channel->playing->volume_envelope.tick = 0; + } + if (!(flags & 2)) { + channel->playing->pan_envelope.next_node = 0; + channel->playing->pan_envelope.tick = 0; + } + if (!(flags & 4)) { + channel->playing->pitch_envelope.next_node = 0; + channel->playing->pitch_envelope.tick = 0; + } + channel->playing->fadeoutcount = 1024; + // Should we remove IT_PLAYING_BACKGROUND? Test with sample with sustain + // loop... + channel->playing->flags &= ~(IT_PLAYING_BACKGROUND | IT_PLAYING_SUSTAINOFF | + IT_PLAYING_FADING | IT_PLAYING_DEAD); + it_playing_update_resamplers(channel->playing); - -static void it_compatible_gxx_retrigger(DUMB_IT_SIGDATA *sigdata, IT_CHANNEL *channel) -{ - int flags = 0; - if (channel->sample) { - if (sigdata->flags & IT_USE_INSTRUMENTS) { - if (!(channel->playing->flags & IT_PLAYING_SUSTAINOFF)) { - if (channel->playing->env_instrument->volume_envelope.flags & IT_ENVELOPE_CARRY) - flags |= 1; - if (channel->playing->env_instrument->pan_envelope.flags & IT_ENVELOPE_CARRY) - flags |= 2; - if (channel->playing->env_instrument->pitch_envelope.flags & IT_ENVELOPE_CARRY) - flags |= 4; - } - } - } - if (!(flags & 1)) { - channel->playing->volume_envelope.next_node = 0; - channel->playing->volume_envelope.tick = 0; - } - if (!(flags & 2)) { - channel->playing->pan_envelope.next_node = 0; - channel->playing->pan_envelope.tick = 0; - } - if (!(flags & 4)) { - channel->playing->pitch_envelope.next_node = 0; - channel->playing->pitch_envelope.tick = 0; - } - channel->playing->fadeoutcount = 1024; - // Should we remove IT_PLAYING_BACKGROUND? Test with sample with sustain loop... - channel->playing->flags &= ~(IT_PLAYING_BACKGROUND | IT_PLAYING_SUSTAINOFF | IT_PLAYING_FADING | IT_PLAYING_DEAD); - it_playing_update_resamplers(channel->playing); - - if (!flags && channel->sample) - if (sigdata->flags & IT_USE_INSTRUMENTS) - channel->playing->env_instrument = &sigdata->instrument[channel->instrument-1]; + if (!flags && channel->sample) + if (sigdata->flags & IT_USE_INSTRUMENTS) + channel->playing->env_instrument = + &sigdata->instrument[channel->instrument - 1]; } - - -static void it_note_off(IT_PLAYING *playing) -{ - if (playing) { - playing->enabled_envelopes |= IT_ENV_VOLUME; - playing->flags |= IT_PLAYING_BACKGROUND | IT_PLAYING_SUSTAINOFF; - fix_sample_looping(playing); - it_playing_update_resamplers(playing); - if (playing->instrument) - if ((playing->instrument->volume_envelope.flags & (IT_ENVELOPE_ON | IT_ENVELOPE_LOOP_ON)) != IT_ENVELOPE_ON) - playing->flags |= IT_PLAYING_FADING; - } +static void it_note_off(IT_PLAYING *playing) { + if (playing) { + playing->enabled_envelopes |= IT_ENV_VOLUME; + playing->flags |= IT_PLAYING_BACKGROUND | IT_PLAYING_SUSTAINOFF; + fix_sample_looping(playing); + it_playing_update_resamplers(playing); + if (playing->instrument) + if ((playing->instrument->volume_envelope.flags & + (IT_ENVELOPE_ON | IT_ENVELOPE_LOOP_ON)) != IT_ENVELOPE_ON) + playing->flags |= IT_PLAYING_FADING; + } } - - -static void xm_note_off(DUMB_IT_SIGDATA *sigdata, IT_CHANNEL *channel) -{ - if (channel->playing) { - if (!channel->instrument || channel->instrument > sigdata->n_instruments || - !(sigdata->instrument[channel->instrument-1].volume_envelope.flags & IT_ENVELOPE_ON)) - //if (!(entry->mask & IT_ENTRY_INSTRUMENT)) - // dunno what that was there for ... - channel->volume = 0; - channel->playing->flags |= IT_PLAYING_SUSTAINOFF | IT_PLAYING_FADING; - it_playing_update_resamplers(channel->playing); - } +static void xm_note_off(DUMB_IT_SIGDATA *sigdata, IT_CHANNEL *channel) { + if (channel->playing) { + if (!channel->instrument || + channel->instrument > sigdata->n_instruments || + !(sigdata->instrument[channel->instrument - 1] + .volume_envelope.flags & + IT_ENVELOPE_ON)) + // if (!(entry->mask & IT_ENTRY_INSTRUMENT)) + // dunno what that was there for ... + channel->volume = 0; + channel->playing->flags |= IT_PLAYING_SUSTAINOFF | IT_PLAYING_FADING; + it_playing_update_resamplers(channel->playing); + } } - -static void recalculate_it_envelope_node(IT_PLAYING_ENVELOPE *pe, IT_ENVELOPE *e) -{ - int envpos = pe->tick; - unsigned int pt = e->n_nodes - 1; - unsigned int i; - for (i = 0; i < (unsigned int)(e->n_nodes - 1); ++i) - { - if (envpos <= e->node_t[i]) - { - pt = i; - break; - } - } - pe->next_node = pt; +static void recalculate_it_envelope_node(IT_PLAYING_ENVELOPE *pe, + IT_ENVELOPE *e) { + int envpos = pe->tick; + unsigned int pt = e->n_nodes - 1; + unsigned int i; + for (i = 0; i < (unsigned int)(e->n_nodes - 1); ++i) { + if (envpos <= e->node_t[i]) { + pt = i; + break; + } + } + pe->next_node = pt; } - -static void recalculate_it_envelope_nodes(IT_PLAYING *playing) -{ - recalculate_it_envelope_node(&playing->volume_envelope, &playing->env_instrument->volume_envelope); - recalculate_it_envelope_node(&playing->pan_envelope, &playing->env_instrument->pitch_envelope); - recalculate_it_envelope_node(&playing->pitch_envelope, &playing->env_instrument->pitch_envelope); +static void recalculate_it_envelope_nodes(IT_PLAYING *playing) { + recalculate_it_envelope_node(&playing->volume_envelope, + &playing->env_instrument->volume_envelope); + recalculate_it_envelope_node(&playing->pan_envelope, + &playing->env_instrument->pitch_envelope); + recalculate_it_envelope_node(&playing->pitch_envelope, + &playing->env_instrument->pitch_envelope); } +static void it_retrigger_note(DUMB_IT_SIGRENDERER *sigrenderer, + IT_CHANNEL *channel) { + int vol_env_tick = 0; + int pan_env_tick = 0; + int pitch_env_tick = 0; -static void it_retrigger_note(DUMB_IT_SIGRENDERER *sigrenderer, IT_CHANNEL *channel) -{ - int vol_env_tick = 0; - int pan_env_tick = 0; - int pitch_env_tick = 0; + DUMB_IT_SIGDATA *sigdata = sigrenderer->sigdata; + unsigned char nna = ~0; + int i, envelopes_copied = 0; - DUMB_IT_SIGDATA *sigdata = sigrenderer->sigdata; - unsigned char nna = ~0; - int i, envelopes_copied = 0; + if (channel->playing) { + if (channel->note == IT_NOTE_CUT) + nna = NNA_NOTE_CUT; + else if (channel->note == IT_NOTE_OFF) + nna = NNA_NOTE_OFF; + else if (channel->note > 120) + nna = NNA_NOTE_FADE; + else if (!channel->playing->instrument || + (channel->playing->flags & IT_PLAYING_DEAD)) + nna = NNA_NOTE_CUT; + else if (channel->new_note_action != 0xFF) { + nna = channel->new_note_action; + } else + nna = channel->playing->instrument->new_note_action; - if (channel->playing) { - if (channel->note == IT_NOTE_CUT) - nna = NNA_NOTE_CUT; - else if (channel->note == IT_NOTE_OFF) - nna = NNA_NOTE_OFF; - else if (channel->note > 120) - nna = NNA_NOTE_FADE; - else if (!channel->playing->instrument || (channel->playing->flags & IT_PLAYING_DEAD)) - nna = NNA_NOTE_CUT; - else if (channel->new_note_action != 0xFF) - { - nna = channel->new_note_action; - } - else - nna = channel->playing->instrument->new_note_action; + if (!(channel->playing->flags & IT_PLAYING_SUSTAINOFF)) { + if (nna != NNA_NOTE_CUT) + vol_env_tick = channel->playing->volume_envelope.tick; + pan_env_tick = channel->playing->pan_envelope.tick; + pitch_env_tick = channel->playing->pitch_envelope.tick; + envelopes_copied = 1; + } - if (!(channel->playing->flags & IT_PLAYING_SUSTAINOFF)) - { - if (nna != NNA_NOTE_CUT) - vol_env_tick = channel->playing->volume_envelope.tick; - pan_env_tick = channel->playing->pan_envelope.tick; - pitch_env_tick = channel->playing->pitch_envelope.tick; - envelopes_copied = 1; - } + switch (nna) { + case NNA_NOTE_CUT: + channel->playing->declick_stage = 3; + break; + case NNA_NOTE_OFF: + it_note_off(channel->playing); + break; + case NNA_NOTE_FADE: + channel->playing->flags |= + IT_PLAYING_BACKGROUND | IT_PLAYING_FADING; + break; + } + } - switch (nna) { - case NNA_NOTE_CUT: - channel->playing->declick_stage = 3; - break; - case NNA_NOTE_OFF: - it_note_off(channel->playing); - break; - case NNA_NOTE_FADE: - channel->playing->flags |= IT_PLAYING_BACKGROUND | IT_PLAYING_FADING; - break; - } - } + channel->new_note_action = 0xFF; - channel->new_note_action = 0xFF; + if (channel->sample == 0 || channel->note > 120) + return; - if (channel->sample == 0 || channel->note > 120) - return; + channel->destnote = IT_NOTE_OFF; - channel->destnote = IT_NOTE_OFF; + if (channel->playing) { + for (i = 0; i < DUMB_IT_N_NNA_CHANNELS; i++) { + if (!sigrenderer->playing[i]) { + sigrenderer->playing[i] = channel->playing; + channel->playing = NULL; + break; + } + } - if (channel->playing) { - for (i = 0; i < DUMB_IT_N_NNA_CHANNELS; i++) { - if (!sigrenderer->playing[i]) { - sigrenderer->playing[i] = channel->playing; - channel->playing = NULL; - break; - } - } + if (sigrenderer->sigdata->flags & IT_USE_INSTRUMENTS) { + for (i = 0; i < DUMB_IT_N_NNA_CHANNELS; i++) { + IT_PLAYING *playing = sigrenderer->playing[i]; + if (playing && playing->channel == channel && + playing->instrument->dup_check_type) { + int match = 1; + switch (playing->instrument->dup_check_type) { + case DCT_NOTE: + match = (channel->truenote == playing->note); + case DCT_SAMPLE: + match = match && (channel->sample == playing->sampnum); + case DCT_INSTRUMENT: + match = + match && (channel->instrument == playing->instnum); + break; + } - if (sigrenderer->sigdata->flags & IT_USE_INSTRUMENTS) - { - for (i = 0; i < DUMB_IT_N_NNA_CHANNELS; i++) { - IT_PLAYING * playing = sigrenderer->playing[i]; - if (playing && playing->channel == channel && playing->instrument->dup_check_type) { - int match = 1; - switch (playing->instrument->dup_check_type) - { - case DCT_NOTE: - match = (channel->truenote == playing->note); - case DCT_SAMPLE: - match = match && (channel->sample == playing->sampnum); - case DCT_INSTRUMENT: - match = match && (channel->instrument == playing->instnum); - break; - } - - if (match) - { - switch (playing->instrument->dup_check_action) - { - case DCA_NOTE_CUT: - playing->declick_stage = 3; - if (channel->playing == playing) channel->playing = NULL; - break; - case DCA_NOTE_OFF: - if (!(playing->flags & IT_PLAYING_SUSTAINOFF)) - it_note_off(playing); - break; - case DCA_NOTE_FADE: - playing->flags |= IT_PLAYING_BACKGROUND | IT_PLAYING_FADING; - break; - } - } - } - } - } + if (match) { + switch (playing->instrument->dup_check_action) { + case DCA_NOTE_CUT: + playing->declick_stage = 3; + if (channel->playing == playing) + channel->playing = NULL; + break; + case DCA_NOTE_OFF: + if (!(playing->flags & IT_PLAYING_SUSTAINOFF)) + it_note_off(playing); + break; + case DCA_NOTE_FADE: + playing->flags |= + IT_PLAYING_BACKGROUND | IT_PLAYING_FADING; + break; + } + } + } + } + } /** WARNING - come up with some more heuristics for replacing old notes */ #if 0 @@ -1956,1885 +2175,1955 @@ static void it_retrigger_note(DUMB_IT_SIGRENDERER *sigrenderer, IT_CHANNEL *chan } } #endif - } + } - if (channel->playing) - free_playing(channel->playing); + if (channel->playing) + free_playing(channel->playing); - channel->playing = new_playing(); + channel->playing = new_playing(); - if (!channel->playing) - return; + if (!channel->playing) + return; - if (!envelopes_copied && sigdata->flags & IT_USE_INSTRUMENTS) { - for (i = 0; i < DUMB_IT_N_NNA_CHANNELS; i++) { - IT_PLAYING * playing = sigrenderer->playing[i]; - if (!playing || playing->channel != channel) continue; - if (playing->flags & IT_PLAYING_SUSTAINOFF) continue; - if (nna != NNA_NOTE_CUT) - vol_env_tick = playing->volume_envelope.tick; - pan_env_tick = playing->pan_envelope.tick; - pitch_env_tick = playing->pitch_envelope.tick; - envelopes_copied = 1; - break; - } - } + if (!envelopes_copied && sigdata->flags & IT_USE_INSTRUMENTS) { + for (i = 0; i < DUMB_IT_N_NNA_CHANNELS; i++) { + IT_PLAYING *playing = sigrenderer->playing[i]; + if (!playing || playing->channel != channel) + continue; + if (playing->flags & IT_PLAYING_SUSTAINOFF) + continue; + if (nna != NNA_NOTE_CUT) + vol_env_tick = playing->volume_envelope.tick; + pan_env_tick = playing->pan_envelope.tick; + pitch_env_tick = playing->pitch_envelope.tick; + envelopes_copied = 1; + break; + } + } - channel->playing->flags = 0; - channel->playing->resampling_quality = sigrenderer->resampling_quality; - channel->playing->channel = channel; - channel->playing->sample = &sigdata->sample[channel->sample-1]; - if (sigdata->flags & IT_USE_INSTRUMENTS) - channel->playing->instrument = &sigdata->instrument[channel->instrument-1]; - else - channel->playing->instrument = NULL; - channel->playing->env_instrument = channel->playing->instrument; - channel->playing->sampnum = channel->sample; - channel->playing->instnum = channel->instrument; - channel->playing->declick_stage = 0; - channel->playing->channel_volume = channel->channelvolume; - channel->playing->note = channel->truenote; - channel->playing->enabled_envelopes = 0; - channel->playing->volume_offset = 0; - channel->playing->panning_offset = 0; - //channel->playing->output = channel->output; - if (sigdata->flags & IT_USE_INSTRUMENTS) { - IT_PLAYING * playing = channel->playing; - IT_INSTRUMENT * instrument = playing->instrument; - if (instrument->volume_envelope.flags & IT_ENVELOPE_ON) playing->enabled_envelopes |= IT_ENV_VOLUME; - if (instrument->pan_envelope.flags & IT_ENVELOPE_ON) playing->enabled_envelopes |= IT_ENV_PANNING; - if (instrument->pitch_envelope.flags & IT_ENVELOPE_ON) playing->enabled_envelopes |= IT_ENV_PITCH; - if (instrument->random_volume) playing->volume_offset = (rand() % (instrument->random_volume * 2 + 1)) - instrument->random_volume; - if (instrument->random_pan) playing->panning_offset = (rand() % (instrument->random_pan * 2 + 1)) - instrument->random_pan; - //if (instrument->output) playing->output = instrument->output; - } - channel->playing->filter_cutoff = 127; - channel->playing->filter_resonance = 0; - channel->playing->true_filter_cutoff = 127 << 8; - channel->playing->true_filter_resonance = 0; - channel->playing->vibrato_speed = 0; - channel->playing->vibrato_depth = 0; - channel->playing->vibrato_n = 0; - channel->playing->vibrato_time = 0; - channel->playing->vibrato_waveform = channel->vibrato_waveform; - channel->playing->tremolo_speed = 0; - channel->playing->tremolo_depth = 0; - channel->playing->tremolo_time = 0; - channel->playing->tremolo_waveform = channel->tremolo_waveform; - channel->playing->panbrello_speed = 0; - channel->playing->panbrello_depth = 0; - channel->playing->panbrello_time = 0; - channel->playing->panbrello_waveform = channel->panbrello_waveform; - channel->playing->panbrello_random = 0; - channel->playing->sample_vibrato_time = 0; - channel->playing->sample_vibrato_waveform = channel->playing->sample->vibrato_waveform; - channel->playing->sample_vibrato_depth = 0; - channel->playing->slide = 0; - channel->playing->finetune = channel->playing->sample->finetune; + channel->playing->flags = 0; + channel->playing->resampling_quality = sigrenderer->resampling_quality; + channel->playing->channel = channel; + channel->playing->sample = &sigdata->sample[channel->sample - 1]; + if (sigdata->flags & IT_USE_INSTRUMENTS) + channel->playing->instrument = + &sigdata->instrument[channel->instrument - 1]; + else + channel->playing->instrument = NULL; + channel->playing->env_instrument = channel->playing->instrument; + channel->playing->sampnum = channel->sample; + channel->playing->instnum = channel->instrument; + channel->playing->declick_stage = 0; + channel->playing->channel_volume = channel->channelvolume; + channel->playing->note = channel->truenote; + channel->playing->enabled_envelopes = 0; + channel->playing->volume_offset = 0; + channel->playing->panning_offset = 0; + // channel->playing->output = channel->output; + if (sigdata->flags & IT_USE_INSTRUMENTS) { + IT_PLAYING *playing = channel->playing; + IT_INSTRUMENT *instrument = playing->instrument; + if (instrument->volume_envelope.flags & IT_ENVELOPE_ON) + playing->enabled_envelopes |= IT_ENV_VOLUME; + if (instrument->pan_envelope.flags & IT_ENVELOPE_ON) + playing->enabled_envelopes |= IT_ENV_PANNING; + if (instrument->pitch_envelope.flags & IT_ENVELOPE_ON) + playing->enabled_envelopes |= IT_ENV_PITCH; + if (instrument->random_volume) + playing->volume_offset = + (rand() % (instrument->random_volume * 2 + 1)) - + instrument->random_volume; + if (instrument->random_pan) + playing->panning_offset = + (rand() % (instrument->random_pan * 2 + 1)) - + instrument->random_pan; + // if (instrument->output) playing->output = instrument->output; + } + channel->playing->filter_cutoff = 127; + channel->playing->filter_resonance = 0; + channel->playing->true_filter_cutoff = 127 << 8; + channel->playing->true_filter_resonance = 0; + channel->playing->vibrato_speed = 0; + channel->playing->vibrato_depth = 0; + channel->playing->vibrato_n = 0; + channel->playing->vibrato_time = 0; + channel->playing->vibrato_waveform = channel->vibrato_waveform; + channel->playing->tremolo_speed = 0; + channel->playing->tremolo_depth = 0; + channel->playing->tremolo_time = 0; + channel->playing->tremolo_waveform = channel->tremolo_waveform; + channel->playing->panbrello_speed = 0; + channel->playing->panbrello_depth = 0; + channel->playing->panbrello_time = 0; + channel->playing->panbrello_waveform = channel->panbrello_waveform; + channel->playing->panbrello_random = 0; + channel->playing->sample_vibrato_time = 0; + channel->playing->sample_vibrato_waveform = + channel->playing->sample->vibrato_waveform; + channel->playing->sample_vibrato_depth = 0; + channel->playing->slide = 0; + channel->playing->finetune = channel->playing->sample->finetune; - if (sigdata->flags & IT_USE_INSTRUMENTS) - { - if (envelopes_copied && channel->playing->env_instrument->volume_envelope.flags & IT_ENVELOPE_CARRY) { - channel->playing->volume_envelope.tick = vol_env_tick; - } else { - channel->playing->volume_envelope.tick = 0; - } - if (envelopes_copied && channel->playing->env_instrument->pan_envelope.flags & IT_ENVELOPE_CARRY) { - channel->playing->pan_envelope.tick = pan_env_tick; - } else { - channel->playing->pan_envelope.tick = 0; - } - if (envelopes_copied && channel->playing->env_instrument->pitch_envelope.flags & IT_ENVELOPE_CARRY) { - channel->playing->pitch_envelope.tick = pitch_env_tick; - } else { - channel->playing->pitch_envelope.tick = 0; - } - recalculate_it_envelope_nodes(channel->playing); - } - channel->playing->fadeoutcount = 1024; - it_reset_filter_state(&channel->playing->filter_state[0]); - it_reset_filter_state(&channel->playing->filter_state[1]); - it_playing_reset_resamplers(channel->playing, 0); + if (sigdata->flags & IT_USE_INSTRUMENTS) { + if (envelopes_copied && + channel->playing->env_instrument->volume_envelope.flags & + IT_ENVELOPE_CARRY) { + channel->playing->volume_envelope.tick = vol_env_tick; + } else { + channel->playing->volume_envelope.tick = 0; + } + if (envelopes_copied && + channel->playing->env_instrument->pan_envelope.flags & + IT_ENVELOPE_CARRY) { + channel->playing->pan_envelope.tick = pan_env_tick; + } else { + channel->playing->pan_envelope.tick = 0; + } + if (envelopes_copied && + channel->playing->env_instrument->pitch_envelope.flags & + IT_ENVELOPE_CARRY) { + channel->playing->pitch_envelope.tick = pitch_env_tick; + } else { + channel->playing->pitch_envelope.tick = 0; + } + recalculate_it_envelope_nodes(channel->playing); + } + channel->playing->fadeoutcount = 1024; + it_reset_filter_state(&channel->playing->filter_state[0]); + it_reset_filter_state(&channel->playing->filter_state[1]); + it_playing_reset_resamplers(channel->playing, 0); - /** WARNING - is everything initialised? */ + /** WARNING - is everything initialised? */ } +static void get_default_volpan(DUMB_IT_SIGDATA *sigdata, IT_CHANNEL *channel) { + if (channel->sample == 0) + return; + channel->volume = sigdata->sample[channel->sample - 1].default_volume; -static void get_default_volpan(DUMB_IT_SIGDATA *sigdata, IT_CHANNEL *channel) -{ - if (channel->sample == 0) - return; + if (sigdata->flags & IT_WAS_AN_XM) { + if (!(sigdata->flags & IT_WAS_A_MOD)) + channel->truepan = + 32 + sigdata->sample[channel->sample - 1].default_pan * 64; + return; + } - channel->volume = sigdata->sample[channel->sample-1].default_volume; + { + int pan = sigdata->sample[channel->sample - 1].default_pan; + if (pan >= 128 && pan <= 192) { + channel->pan = pan - 128; + return; + } + } - if (sigdata->flags & IT_WAS_AN_XM) { - if (!(sigdata->flags & IT_WAS_A_MOD)) - channel->truepan = 32 + sigdata->sample[channel->sample-1].default_pan*64; - return; - } - - { - int pan = sigdata->sample[channel->sample-1].default_pan; - if (pan >= 128 && pan <= 192) { - channel->pan = pan - 128; - return; - } - } - - if (sigdata->flags & IT_USE_INSTRUMENTS) { - IT_INSTRUMENT *instrument = &sigdata->instrument[channel->instrument-1]; - if (instrument->default_pan <= 64) - channel->pan = instrument->default_pan; - if (instrument->filter_cutoff >= 128) - channel->filter_cutoff = instrument->filter_cutoff - 128; - if (instrument->filter_resonance >= 128) - channel->filter_resonance = instrument->filter_resonance - 128; - } + if (sigdata->flags & IT_USE_INSTRUMENTS) { + IT_INSTRUMENT *instrument = + &sigdata->instrument[channel->instrument - 1]; + if (instrument->default_pan <= 64) + channel->pan = instrument->default_pan; + if (instrument->filter_cutoff >= 128) + channel->filter_cutoff = instrument->filter_cutoff - 128; + if (instrument->filter_resonance >= 128) + channel->filter_resonance = instrument->filter_resonance - 128; + } } +static void get_true_pan(DUMB_IT_SIGDATA *sigdata, IT_CHANNEL *channel) { + channel->truepan = channel->pan << IT_ENVELOPE_SHIFT; - -static void get_true_pan(DUMB_IT_SIGDATA *sigdata, IT_CHANNEL *channel) -{ - channel->truepan = channel->pan << IT_ENVELOPE_SHIFT; - - if (channel->sample && !IT_IS_SURROUND_SHIFTED(channel->truepan) && (sigdata->flags & IT_USE_INSTRUMENTS)) { - IT_INSTRUMENT *instrument = &sigdata->instrument[channel->instrument-1]; - int truepan = channel->truepan; - truepan += (channel->note - instrument->pp_centre) * instrument->pp_separation << (IT_ENVELOPE_SHIFT - 3); - channel->truepan = (unsigned short)MID(0, truepan, 64 << IT_ENVELOPE_SHIFT); - } + if (channel->sample && !IT_IS_SURROUND_SHIFTED(channel->truepan) && + (sigdata->flags & IT_USE_INSTRUMENTS)) { + IT_INSTRUMENT *instrument = + &sigdata->instrument[channel->instrument - 1]; + int truepan = channel->truepan; + truepan += + (channel->note - instrument->pp_centre) * instrument->pp_separation + << (IT_ENVELOPE_SHIFT - 3); + channel->truepan = + (unsigned short)MID(0, truepan, 64 << IT_ENVELOPE_SHIFT); + } } +static void post_process_it_volpan(DUMB_IT_SIGRENDERER *sigrenderer, + IT_ENTRY *entry) { + IT_CHANNEL *channel = &sigrenderer->channel[(int)entry->channel]; - -static void post_process_it_volpan(DUMB_IT_SIGRENDERER *sigrenderer, IT_ENTRY *entry) -{ - IT_CHANNEL *channel = &sigrenderer->channel[(int)entry->channel]; - - if (entry->mask & IT_ENTRY_VOLPAN) { - if (entry->volpan <= 84) { - /* Volume */ - /* Fine volume slide up */ - /* Fine volume slide down */ - } else if (entry->volpan <= 94) { - /* Volume slide up */ - unsigned char v = entry->volpan - 85; - if (v == 0) - v = channel->lastvolslide; - channel->lastvolslide = v; - /* = effect Dx0 where x == entry->volpan - 85 */ - channel->volslide += v; - } else if (entry->volpan <= 104) { - /* Volume slide down */ - unsigned char v = entry->volpan - 95; - if (v == 0) - v = channel->lastvolslide; - channel->lastvolslide = v; - /* = effect D0x where x == entry->volpan - 95 */ - channel->volslide -= v; - } else if (entry->volpan <= 114) { - /* Portamento down */ - unsigned char v = (entry->volpan - 105) << 2; - if (v == 0) - v = channel->lastEF; - channel->lastEF = v; - channel->portamento -= v << 4; - } else if (entry->volpan <= 124) { - /* Portamento up */ - unsigned char v = (entry->volpan - 115) << 2; - if (v == 0) - v = channel->lastEF; - channel->lastEF = v; - channel->portamento += v << 4; - } else if (entry->volpan <= 202) { - /* Pan */ - /* Tone Portamento */ - } else if (entry->volpan <= 212) { - /* Vibrato */ - /* This is unaffected by IT_OLD_EFFECTS. However, if v == 0, then any doubling of depth that happened before (with Hxy in the effect column) will be preserved. */ - unsigned char v = entry->volpan - 203; - if (v == 0) - v = channel->lastHdepth; - else { - v <<= 2; - channel->lastHdepth = v; - } - if (channel->playing) { - channel->playing->vibrato_speed = channel->lastHspeed; - channel->playing->vibrato_depth = v; - channel->playing->vibrato_n++; - } - } - } + if (entry->mask & IT_ENTRY_VOLPAN) { + if (entry->volpan <= 84) { + /* Volume */ + /* Fine volume slide up */ + /* Fine volume slide down */ + } else if (entry->volpan <= 94) { + /* Volume slide up */ + unsigned char v = entry->volpan - 85; + if (v == 0) + v = channel->lastvolslide; + channel->lastvolslide = v; + /* = effect Dx0 where x == entry->volpan - 85 */ + channel->volslide += v; + } else if (entry->volpan <= 104) { + /* Volume slide down */ + unsigned char v = entry->volpan - 95; + if (v == 0) + v = channel->lastvolslide; + channel->lastvolslide = v; + /* = effect D0x where x == entry->volpan - 95 */ + channel->volslide -= v; + } else if (entry->volpan <= 114) { + /* Portamento down */ + unsigned char v = (entry->volpan - 105) << 2; + if (v == 0) + v = channel->lastEF; + channel->lastEF = v; + channel->portamento -= v << 4; + } else if (entry->volpan <= 124) { + /* Portamento up */ + unsigned char v = (entry->volpan - 115) << 2; + if (v == 0) + v = channel->lastEF; + channel->lastEF = v; + channel->portamento += v << 4; + } else if (entry->volpan <= 202) { + /* Pan */ + /* Tone Portamento */ + } else if (entry->volpan <= 212) { + /* Vibrato */ + /* This is unaffected by IT_OLD_EFFECTS. However, if v == 0, then + * any doubling of depth that happened before (with Hxy in the + * effect column) will be preserved. */ + unsigned char v = entry->volpan - 203; + if (v == 0) + v = channel->lastHdepth; + else { + v <<= 2; + channel->lastHdepth = v; + } + if (channel->playing) { + channel->playing->vibrato_speed = channel->lastHspeed; + channel->playing->vibrato_depth = v; + channel->playing->vibrato_n++; + } + } + } } +static void it_send_midi(DUMB_IT_SIGRENDERER *sigrenderer, IT_CHANNEL *channel, + unsigned char midi_byte) { + if (sigrenderer->callbacks->midi) + if ((*sigrenderer->callbacks->midi)( + sigrenderer->callbacks->midi_data, + (int)(channel - sigrenderer->channel), midi_byte)) + return; - -static void it_send_midi(DUMB_IT_SIGRENDERER *sigrenderer, IT_CHANNEL *channel, unsigned char midi_byte) -{ - if (sigrenderer->callbacks->midi) - if ((*sigrenderer->callbacks->midi)(sigrenderer->callbacks->midi_data, (int)(channel - sigrenderer->channel), midi_byte)) - return; - - switch (channel->midi_state) { - case 4: /* Ready to receive resonance parameter */ - if (midi_byte < 0x80) channel->filter_resonance = midi_byte; - channel->midi_state = 0; - break; - case 3: /* Ready to receive cutoff parameter */ - if (midi_byte < 0x80) channel->filter_cutoff = midi_byte; - channel->midi_state = 0; - break; - case 2: /* Ready for byte specifying which parameter will follow */ - if (midi_byte == 0) /* Cutoff */ - channel->midi_state = 3; - else if (midi_byte == 1) /* Resonance */ - channel->midi_state = 4; - else - channel->midi_state = 0; - break; - default: /* Counting initial F0 bytes */ - switch (midi_byte) { - case 0xF0: - channel->midi_state++; - break; - case 0xFA: - case 0xFC: - case 0xFF: - /* Reset filter parameters for all channels */ - { - int i; - for (i = 0; i < DUMB_IT_N_CHANNELS; i++) { - sigrenderer->channel[i].filter_cutoff = 127; - sigrenderer->channel[i].filter_resonance = 0; - //// should we be resetting channel[i].playing->filter_* here? - } - } - /* Fall through */ - default: - channel->midi_state = 0; - break; - } - } + switch (channel->midi_state) { + case 4: /* Ready to receive resonance parameter */ + if (midi_byte < 0x80) + channel->filter_resonance = midi_byte; + channel->midi_state = 0; + break; + case 3: /* Ready to receive cutoff parameter */ + if (midi_byte < 0x80) + channel->filter_cutoff = midi_byte; + channel->midi_state = 0; + break; + case 2: /* Ready for byte specifying which parameter will follow */ + if (midi_byte == 0) /* Cutoff */ + channel->midi_state = 3; + else if (midi_byte == 1) /* Resonance */ + channel->midi_state = 4; + else + channel->midi_state = 0; + break; + default: /* Counting initial F0 bytes */ + switch (midi_byte) { + case 0xF0: + channel->midi_state++; + break; + case 0xFA: + case 0xFC: + case 0xFF: + /* Reset filter parameters for all channels */ + { + int i; + for (i = 0; i < DUMB_IT_N_CHANNELS; i++) { + sigrenderer->channel[i].filter_cutoff = 127; + sigrenderer->channel[i].filter_resonance = 0; + //// should we be resetting channel[i].playing->filter_* + /// here? + } + } + /* Fall through */ + default: + channel->midi_state = 0; + break; + } + } } +static void xm_envelope_calculate_value(IT_ENVELOPE *envelope, + IT_PLAYING_ENVELOPE *pe) { + if (pe->next_node <= 0) + pe->value = envelope->node_y[0] << IT_ENVELOPE_SHIFT; + else if (pe->next_node >= envelope->n_nodes) + pe->value = envelope->node_y[envelope->n_nodes - 1] + << IT_ENVELOPE_SHIFT; + else { + int ys = envelope->node_y[pe->next_node - 1] << IT_ENVELOPE_SHIFT; + int ts = envelope->node_t[pe->next_node - 1]; + int te = envelope->node_t[pe->next_node]; + if (ts == te) + pe->value = ys; + else { + int ye = envelope->node_y[pe->next_node] << IT_ENVELOPE_SHIFT; + int t = pe->tick; -static void xm_envelope_calculate_value(IT_ENVELOPE *envelope, IT_PLAYING_ENVELOPE *pe) -{ - if (pe->next_node <= 0) - pe->value = envelope->node_y[0] << IT_ENVELOPE_SHIFT; - else if (pe->next_node >= envelope->n_nodes) - pe->value = envelope->node_y[envelope->n_nodes-1] << IT_ENVELOPE_SHIFT; - else { - int ys = envelope->node_y[pe->next_node-1] << IT_ENVELOPE_SHIFT; - int ts = envelope->node_t[pe->next_node-1]; - int te = envelope->node_t[pe->next_node]; - - if (ts == te) - pe->value = ys; - else { - int ye = envelope->node_y[pe->next_node] << IT_ENVELOPE_SHIFT; - int t = pe->tick; - - pe->value = ys + (ye - ys) * (t - ts) / (te - ts); - } - } + pe->value = ys + (ye - ys) * (t - ts) / (te - ts); + } + } } - - extern const char xm_convert_vibrato[]; const char mod_convert_vibrato[] = { - IT_VIBRATO_SINE, - IT_VIBRATO_RAMP_UP, /* this will be inverted by IT_OLD_EFFECTS */ - IT_VIBRATO_XM_SQUARE, - IT_VIBRATO_XM_SQUARE -}; + IT_VIBRATO_SINE, + IT_VIBRATO_RAMP_UP, /* this will be inverted by IT_OLD_EFFECTS */ + IT_VIBRATO_XM_SQUARE, IT_VIBRATO_XM_SQUARE}; /* Returns 1 if a callback caused termination of playback. */ -static int process_effects(DUMB_IT_SIGRENDERER *sigrenderer, IT_ENTRY *entry, int ignore_cxx) -{ - DUMB_IT_SIGDATA *sigdata = sigrenderer->sigdata; - IT_PLAYING *playing; - int i; +static int process_effects(DUMB_IT_SIGRENDERER *sigrenderer, IT_ENTRY *entry, + int ignore_cxx) { + DUMB_IT_SIGDATA *sigdata = sigrenderer->sigdata; + IT_PLAYING *playing; + int i; - IT_CHANNEL *channel = &sigrenderer->channel[(int)entry->channel]; + IT_CHANNEL *channel = &sigrenderer->channel[(int)entry->channel]; - if (entry->mask & IT_ENTRY_EFFECT) { - switch (entry->effect) { -/* -Notes about effects (as compared to other module formats) + if (entry->mask & IT_ENTRY_EFFECT) { + switch (entry->effect) { + /* + Notes about effects (as compared to other module formats) -C This is now in *HEX*. (Used to be in decimal in ST3) -E/F/G/H/U You need to check whether the song uses Amiga/Linear slides. -H/U Vibrato in Impulse Tracker is two times finer than in - any other tracker and is updated EVERY tick. - If "Old Effects" is *ON*, then the vibrato is played in the - normal manner (every non-row tick and normal depth) -E/F/G These commands ALL share the same memory. -Oxx Offsets to samples are to the 'xx00th' SAMPLE. (ie. for - 16 bit samples, the offset is xx00h*2) - Oxx past the sample end will be ignored, unless "Old Effects" - is ON, in which case the Oxx will play from the end of the - sample. -Yxy This uses a table 4 times larger (hence 4 times slower) than - vibrato or tremelo. If the waveform is set to random, then - the 'speed' part of the command is interpreted as a delay. -*/ - case IT_SET_SPEED: - if (entry->effectvalue) - { - /*if (entry->effectvalue == 255) - if (sigrenderer->callbacks->xm_speed_zero && (*sigrenderer->callbacks->xm_speed_zero)(sigrenderer->callbacks->xm_speed_zero_data)) - return 1;*/ - if (sigdata->flags & IT_WAS_AN_STM) { - int n = entry->effectvalue; - if (n >= 32) { - sigrenderer->tick = sigrenderer->speed = n; - } - } else { - sigrenderer->tick = sigrenderer->speed = entry->effectvalue; - } - } - else if ((sigdata->flags & (IT_WAS_AN_XM|IT_WAS_A_MOD)) == IT_WAS_AN_XM) { + C This is now in *HEX*. (Used to be in decimal in ST3) + E/F/G/H/U You need to check whether the song uses Amiga/Linear + slides. H/U Vibrato in Impulse Tracker is two times + finer than in any other tracker and is updated EVERY tick. If "Old + Effects" is *ON*, then the vibrato is played in the normal manner + (every non-row tick and normal depth) E/F/G These commands + ALL share the same memory. Oxx Offsets to samples are to + the 'xx00th' SAMPLE. (ie. for 16 bit samples, the offset is xx00h*2) + Oxx past the sample end will be ignored, unless "Old + Effects" is ON, in which case the Oxx will play from the end of the + sample. + Yxy This uses a table 4 times larger (hence 4 times + slower) than vibrato or tremelo. If the waveform is set to random, + then the 'speed' part of the command is interpreted as a delay. + */ + case IT_SET_SPEED: + if (entry->effectvalue) { + /*if (entry->effectvalue == 255) + if (sigrenderer->callbacks->xm_speed_zero && + (*sigrenderer->callbacks->xm_speed_zero)(sigrenderer->callbacks->xm_speed_zero_data)) + return 1;*/ + if (sigdata->flags & IT_WAS_AN_STM) { + int n = entry->effectvalue; + if (n >= 32) { + sigrenderer->tick = sigrenderer->speed = n; + } + } else { + sigrenderer->tick = sigrenderer->speed = entry->effectvalue; + } + } else if ((sigdata->flags & (IT_WAS_AN_XM | IT_WAS_A_MOD)) == + IT_WAS_AN_XM) { #ifdef BIT_ARRAY_BULLSHIT - bit_array_set(sigrenderer->played, sigrenderer->order * 256 + sigrenderer->row); + bit_array_set(sigrenderer->played, + sigrenderer->order * 256 + sigrenderer->row); #endif - sigrenderer->speed = 0; + sigrenderer->speed = 0; #ifdef BIT_ARRAY_BULLSHIT - sigrenderer->looped = 1; + sigrenderer->looped = 1; #endif - if (sigrenderer->callbacks->xm_speed_zero && (*sigrenderer->callbacks->xm_speed_zero)(sigrenderer->callbacks->xm_speed_zero_data)) - return 1; - } - break; + if (sigrenderer->callbacks->xm_speed_zero && + (*sigrenderer->callbacks->xm_speed_zero)( + sigrenderer->callbacks->xm_speed_zero_data)) + return 1; + } + break; - case IT_BREAK_TO_ROW: - if (ignore_cxx) break; - sigrenderer->breakrow = entry->effectvalue; - /* XXX jump and break on the same row */ - if ( ( ( sigrenderer->processrow | 0xC00 ) == 0xFFFE ) && - ! ( sigrenderer->processrow & 0x400 ) ) { - sigrenderer->processrow = 0xFFFE & ~0xC00; - } else { - sigrenderer->processorder = sigrenderer->order; - sigrenderer->processrow = 0xFFFE & ~0x800; - } - break; + case IT_BREAK_TO_ROW: + if (ignore_cxx) + break; + sigrenderer->breakrow = entry->effectvalue; + /* XXX jump and break on the same row */ + if (((sigrenderer->processrow | 0xC00) == 0xFFFE) && + !(sigrenderer->processrow & 0x400)) { + sigrenderer->processrow = 0xFFFE & ~0xC00; + } else { + sigrenderer->processorder = sigrenderer->order; + sigrenderer->processrow = 0xFFFE & ~0x800; + } + break; - case IT_VOLSLIDE_VIBRATO: - for (i = -1; i < DUMB_IT_N_NNA_CHANNELS; i++) { - if (i < 0) playing = channel->playing; - else { - playing = sigrenderer->playing[i]; - if (!playing || playing->channel != channel) continue; - } - if (playing) { - playing->vibrato_speed = channel->lastHspeed; - playing->vibrato_depth = channel->lastHdepth; - playing->vibrato_n++; - } - } - /* Fall through and process volume slide. */ - case IT_VOLUME_SLIDE: - case IT_VOLSLIDE_TONEPORTA: - /* The tone portamento component is handled elsewhere. */ - { - unsigned char v = entry->effectvalue; - if (!(sigdata->flags & IT_WAS_A_MOD)) { - if (v == 0) - v = channel->lastDKL; - channel->lastDKL = v; - } - if (!(sigdata->flags & IT_WAS_AN_XM)) { - int clip = (sigdata->flags & IT_WAS_AN_S3M) ? 63 : 64; - if ((v & 0x0F) == 0x0F) { - if (!(v & 0xF0)) { - channel->volslide = -15; - channel->volume -= 15; - if (channel->volume > clip) channel->volume = 0; - } else { - channel->volume += v >> 4; - if (channel->volume > clip) channel->volume = clip; - } - } else if ((v & 0xF0) == 0xF0) { - if (!(v & 0x0F)) { - channel->volslide = 15; - channel->volume += 15; - if (channel->volume > clip) channel->volume = clip; - } else { - channel->volume -= v & 15; - if (channel->volume > clip) channel->volume = 0; - } - } else if (!(v & 0x0F)) { - channel->volslide = v >> 4; - } else { - channel->volslide = -(v & 15); - } - } else { - if ((v & 0x0F) == 0) { /* Dx0 */ - channel->volslide = v >> 4; - } else if ((v & 0xF0) == 0) { /* D0x */ - channel->volslide = -v; - } else if ((v & 0x0F) == 0x0F) { /* DxF */ - channel->volume += v >> 4; - if (channel->volume > 64) channel->volume = 64; - } else if ((v & 0xF0) == 0xF0) { /* DFx */ - channel->volume -= v & 15; - if (channel->volume > 64) channel->volume = 0; - } - } - } - break; - case IT_XM_FINE_VOLSLIDE_DOWN: - { - unsigned char v = entry->effectvalue; - if (v == 0) - v = channel->xm_lastEB; - channel->xm_lastEB = v; - channel->volume -= v; - if (channel->volume > 64) channel->volume = 0; - } - break; - case IT_XM_FINE_VOLSLIDE_UP: - { - unsigned char v = entry->effectvalue; - if (v == 0) - v = channel->xm_lastEA; - channel->xm_lastEA = v; - channel->volume += v; - if (channel->volume > 64) channel->volume = 64; - } - break; - case IT_PORTAMENTO_DOWN: - { - unsigned char v = entry->effectvalue; - if (sigdata->flags & (IT_WAS_AN_XM|IT_WAS_A_669)) { - if (!(sigdata->flags & IT_WAS_A_MOD)) { - if (v == 0xF0) - v |= channel->xm_lastE2; - else if (v >= 0xF0) - channel->xm_lastE2 = v & 15; - else if (v == 0xE0) - v |= channel->xm_lastX2; - else - channel->xm_lastX2 = v & 15; - } - } else if (sigdata->flags & IT_WAS_AN_S3M) { - if (v == 0) - v = channel->lastDKL; - channel->lastDKL = v; - } else { - if (v == 0) - v = channel->lastEF; - channel->lastEF = v; - } - for (i = -1; i < DUMB_IT_N_NNA_CHANNELS; i++) { - if (i < 0) playing = channel->playing; - else { - playing = sigrenderer->playing[i]; - if (!playing || playing->channel != channel) continue; - } - if (playing) { - if ((v & 0xF0) == 0xF0) - playing->slide -= (v & 15) << 4; - else if ((v & 0xF0) == 0xE0) - playing->slide -= (v & 15) << 2; - else if (i < 0 && sigdata->flags & IT_WAS_A_669) - channel->portamento -= v << 3; - else if (i < 0) - channel->portamento -= v << 4; - } - } - } - break; - case IT_PORTAMENTO_UP: - { - unsigned char v = entry->effectvalue; - if (sigdata->flags & (IT_WAS_AN_XM|IT_WAS_A_669)) { - if (!(sigdata->flags & IT_WAS_A_MOD)) { - if (v == 0xF0) - v |= channel->xm_lastE1; - else if (v >= 0xF0) - channel->xm_lastE1 = v & 15; - else if (v == 0xE0) - v |= channel->xm_lastX1; - else - channel->xm_lastX1 = v & 15; - } - } else if (sigdata->flags & IT_WAS_AN_S3M) { - if (v == 0) - v = channel->lastDKL; - channel->lastDKL = v; - } else { - if (v == 0) - v = channel->lastEF; - channel->lastEF = v; - } - for (i = -1; i < DUMB_IT_N_NNA_CHANNELS; i++) { - if (i < 0) playing = channel->playing; - else { - playing = sigrenderer->playing[i]; - if (!playing || playing->channel != channel) continue; - } - if (playing) { - if ((v & 0xF0) == 0xF0) - playing->slide += (v & 15) << 4; - else if ((v & 0xF0) == 0xE0) - playing->slide += (v & 15) << 2; - else if (i < 0 && sigdata->flags & IT_WAS_A_669) - channel->portamento += v << 3; - else if (i < 0) - channel->portamento += v << 4; - } - } - } - break; - case IT_XM_PORTAMENTO_DOWN: - { - unsigned char v = entry->effectvalue; - if (!(sigdata->flags & IT_WAS_A_MOD)) { - if (v == 0) - v = channel->lastJ; - channel->lastJ = v; - } - if (channel->playing) - channel->portamento -= v << 4; - } - break; - case IT_XM_PORTAMENTO_UP: - { - unsigned char v = entry->effectvalue; - if (!(sigdata->flags & IT_WAS_A_MOD)) { - if (v == 0) - v = channel->lastEF; - channel->lastEF = v; - } - if (channel->playing) - channel->portamento += v << 4; - } - break; - case IT_XM_KEY_OFF: - channel->key_off_count = entry->effectvalue; - if (!channel->key_off_count) xm_note_off(sigdata, channel); - break; - case IT_VIBRATO: - { - if (entry->effectvalue || !(sigdata->flags & IT_WAS_A_669)) { - unsigned char speed = entry->effectvalue >> 4; - unsigned char depth = entry->effectvalue & 15; - if (speed == 0) - speed = channel->lastHspeed; - channel->lastHspeed = speed; - if (depth == 0) - depth = channel->lastHdepth; - else { - if (sigdata->flags & IT_OLD_EFFECTS && !(sigdata->flags & IT_WAS_A_MOD)) - depth <<= 3; - else - depth <<= 2; - channel->lastHdepth = depth; - } - for (i = -1; i < DUMB_IT_N_NNA_CHANNELS; i++) { - if (i < 0) playing = channel->playing; - else { - playing = sigrenderer->playing[i]; - if (!playing || playing->channel != channel) continue; - } - if (playing) { - playing->vibrato_speed = speed; - playing->vibrato_depth = depth; - playing->vibrato_n++; - } - } - } - } - break; - case IT_TREMOR: - { - unsigned char v = entry->effectvalue; - if (v == 0) { - if (sigdata->flags & IT_WAS_AN_S3M) - v = channel->lastDKL; - else - v = channel->lastI; - } - else if (!(sigdata->flags & IT_OLD_EFFECTS)) { - if (v & 0xF0) v -= 0x10; - if (v & 0x0F) v -= 0x01; - } - if (sigdata->flags & IT_WAS_AN_S3M) - channel->lastDKL = v; - else - channel->lastI = v; - channel->tremor_time |= 128; - } - update_tremor(channel); - break; - case IT_ARPEGGIO: - { - unsigned char v = entry->effectvalue; - /* XM files have no memory for arpeggio (000 = no effect) - * and we use lastJ for portamento down instead. - */ - if (!(sigdata->flags & IT_WAS_AN_XM)) { - if (sigdata->flags & IT_WAS_AN_S3M) { - if (v == 0) - v = channel->lastDKL; - channel->lastDKL = v; - } else { - if (v == 0) - v = channel->lastJ; - channel->lastJ = v; - } - } - channel->arpeggio_offsets[0] = 0; - channel->arpeggio_offsets[1] = (v & 0xF0) >> 4; - channel->arpeggio_offsets[2] = (v & 0x0F); - channel->arpeggio_table = (const unsigned char *)(((sigdata->flags & (IT_WAS_AN_XM|IT_WAS_A_MOD))==IT_WAS_AN_XM) ? &arpeggio_xm : &arpeggio_mod); - } - break; - case IT_SET_CHANNEL_VOLUME: - if (sigdata->flags & IT_WAS_AN_XM) - channel->volume = MIN(entry->effectvalue, 64); - else if (entry->effectvalue <= 64) - channel->channelvolume = entry->effectvalue; + case IT_VOLSLIDE_VIBRATO: + for (i = -1; i < DUMB_IT_N_NNA_CHANNELS; i++) { + if (i < 0) + playing = channel->playing; + else { + playing = sigrenderer->playing[i]; + if (!playing || playing->channel != channel) + continue; + } + if (playing) { + playing->vibrato_speed = channel->lastHspeed; + playing->vibrato_depth = channel->lastHdepth; + playing->vibrato_n++; + } + } + /* Fall through and process volume slide. */ + case IT_VOLUME_SLIDE: + case IT_VOLSLIDE_TONEPORTA: + /* The tone portamento component is handled elsewhere. */ + { + unsigned char v = entry->effectvalue; + if (!(sigdata->flags & IT_WAS_A_MOD)) { + if (v == 0) + v = channel->lastDKL; + channel->lastDKL = v; + } + if (!(sigdata->flags & IT_WAS_AN_XM)) { + int clip = (sigdata->flags & IT_WAS_AN_S3M) ? 63 : 64; + if ((v & 0x0F) == 0x0F) { + if (!(v & 0xF0)) { + channel->volslide = -15; + channel->volume -= 15; + if (channel->volume > clip) + channel->volume = 0; + } else { + channel->volume += v >> 4; + if (channel->volume > clip) + channel->volume = clip; + } + } else if ((v & 0xF0) == 0xF0) { + if (!(v & 0x0F)) { + channel->volslide = 15; + channel->volume += 15; + if (channel->volume > clip) + channel->volume = clip; + } else { + channel->volume -= v & 15; + if (channel->volume > clip) + channel->volume = 0; + } + } else if (!(v & 0x0F)) { + channel->volslide = v >> 4; + } else { + channel->volslide = -(v & 15); + } + } else { + if ((v & 0x0F) == 0) { /* Dx0 */ + channel->volslide = v >> 4; + } else if ((v & 0xF0) == 0) { /* D0x */ + channel->volslide = -v; + } else if ((v & 0x0F) == 0x0F) { /* DxF */ + channel->volume += v >> 4; + if (channel->volume > 64) + channel->volume = 64; + } else if ((v & 0xF0) == 0xF0) { /* DFx */ + channel->volume -= v & 15; + if (channel->volume > 64) + channel->volume = 0; + } + } + } + break; + case IT_XM_FINE_VOLSLIDE_DOWN: { + unsigned char v = entry->effectvalue; + if (v == 0) + v = channel->xm_lastEB; + channel->xm_lastEB = v; + channel->volume -= v; + if (channel->volume > 64) + channel->volume = 0; + } break; + case IT_XM_FINE_VOLSLIDE_UP: { + unsigned char v = entry->effectvalue; + if (v == 0) + v = channel->xm_lastEA; + channel->xm_lastEA = v; + channel->volume += v; + if (channel->volume > 64) + channel->volume = 64; + } break; + case IT_PORTAMENTO_DOWN: { + unsigned char v = entry->effectvalue; + if (sigdata->flags & (IT_WAS_AN_XM | IT_WAS_A_669)) { + if (!(sigdata->flags & IT_WAS_A_MOD)) { + if (v == 0xF0) + v |= channel->xm_lastE2; + else if (v >= 0xF0) + channel->xm_lastE2 = v & 15; + else if (v == 0xE0) + v |= channel->xm_lastX2; + else + channel->xm_lastX2 = v & 15; + } + } else if (sigdata->flags & IT_WAS_AN_S3M) { + if (v == 0) + v = channel->lastDKL; + channel->lastDKL = v; + } else { + if (v == 0) + v = channel->lastEF; + channel->lastEF = v; + } + for (i = -1; i < DUMB_IT_N_NNA_CHANNELS; i++) { + if (i < 0) + playing = channel->playing; + else { + playing = sigrenderer->playing[i]; + if (!playing || playing->channel != channel) + continue; + } + if (playing) { + if ((v & 0xF0) == 0xF0) + playing->slide -= (v & 15) << 4; + else if ((v & 0xF0) == 0xE0) + playing->slide -= (v & 15) << 2; + else if (i < 0 && sigdata->flags & IT_WAS_A_669) + channel->portamento -= v << 3; + else if (i < 0) + channel->portamento -= v << 4; + } + } + } break; + case IT_PORTAMENTO_UP: { + unsigned char v = entry->effectvalue; + if (sigdata->flags & (IT_WAS_AN_XM | IT_WAS_A_669)) { + if (!(sigdata->flags & IT_WAS_A_MOD)) { + if (v == 0xF0) + v |= channel->xm_lastE1; + else if (v >= 0xF0) + channel->xm_lastE1 = v & 15; + else if (v == 0xE0) + v |= channel->xm_lastX1; + else + channel->xm_lastX1 = v & 15; + } + } else if (sigdata->flags & IT_WAS_AN_S3M) { + if (v == 0) + v = channel->lastDKL; + channel->lastDKL = v; + } else { + if (v == 0) + v = channel->lastEF; + channel->lastEF = v; + } + for (i = -1; i < DUMB_IT_N_NNA_CHANNELS; i++) { + if (i < 0) + playing = channel->playing; + else { + playing = sigrenderer->playing[i]; + if (!playing || playing->channel != channel) + continue; + } + if (playing) { + if ((v & 0xF0) == 0xF0) + playing->slide += (v & 15) << 4; + else if ((v & 0xF0) == 0xE0) + playing->slide += (v & 15) << 2; + else if (i < 0 && sigdata->flags & IT_WAS_A_669) + channel->portamento += v << 3; + else if (i < 0) + channel->portamento += v << 4; + } + } + } break; + case IT_XM_PORTAMENTO_DOWN: { + unsigned char v = entry->effectvalue; + if (!(sigdata->flags & IT_WAS_A_MOD)) { + if (v == 0) + v = channel->lastJ; + channel->lastJ = v; + } + if (channel->playing) + channel->portamento -= v << 4; + } break; + case IT_XM_PORTAMENTO_UP: { + unsigned char v = entry->effectvalue; + if (!(sigdata->flags & IT_WAS_A_MOD)) { + if (v == 0) + v = channel->lastEF; + channel->lastEF = v; + } + if (channel->playing) + channel->portamento += v << 4; + } break; + case IT_XM_KEY_OFF: + channel->key_off_count = entry->effectvalue; + if (!channel->key_off_count) + xm_note_off(sigdata, channel); + break; + case IT_VIBRATO: { + if (entry->effectvalue || !(sigdata->flags & IT_WAS_A_669)) { + unsigned char speed = entry->effectvalue >> 4; + unsigned char depth = entry->effectvalue & 15; + if (speed == 0) + speed = channel->lastHspeed; + channel->lastHspeed = speed; + if (depth == 0) + depth = channel->lastHdepth; + else { + if (sigdata->flags & IT_OLD_EFFECTS && + !(sigdata->flags & IT_WAS_A_MOD)) + depth <<= 3; + else + depth <<= 2; + channel->lastHdepth = depth; + } + for (i = -1; i < DUMB_IT_N_NNA_CHANNELS; i++) { + if (i < 0) + playing = channel->playing; + else { + playing = sigrenderer->playing[i]; + if (!playing || playing->channel != channel) + continue; + } + if (playing) { + playing->vibrato_speed = speed; + playing->vibrato_depth = depth; + playing->vibrato_n++; + } + } + } + } break; + case IT_TREMOR: { + unsigned char v = entry->effectvalue; + if (v == 0) { + if (sigdata->flags & IT_WAS_AN_S3M) + v = channel->lastDKL; + else + v = channel->lastI; + } else if (!(sigdata->flags & IT_OLD_EFFECTS)) { + if (v & 0xF0) + v -= 0x10; + if (v & 0x0F) + v -= 0x01; + } + if (sigdata->flags & IT_WAS_AN_S3M) + channel->lastDKL = v; + else + channel->lastI = v; + channel->tremor_time |= 128; + } + update_tremor(channel); + break; + case IT_ARPEGGIO: { + unsigned char v = entry->effectvalue; + /* XM files have no memory for arpeggio (000 = no effect) + * and we use lastJ for portamento down instead. + */ + if (!(sigdata->flags & IT_WAS_AN_XM)) { + if (sigdata->flags & IT_WAS_AN_S3M) { + if (v == 0) + v = channel->lastDKL; + channel->lastDKL = v; + } else { + if (v == 0) + v = channel->lastJ; + channel->lastJ = v; + } + } + channel->arpeggio_offsets[0] = 0; + channel->arpeggio_offsets[1] = (v & 0xF0) >> 4; + channel->arpeggio_offsets[2] = (v & 0x0F); + channel->arpeggio_table = + (const unsigned char *)(((sigdata->flags & + (IT_WAS_AN_XM | IT_WAS_A_MOD)) == + IT_WAS_AN_XM) + ? &arpeggio_xm + : &arpeggio_mod); + } break; + case IT_SET_CHANNEL_VOLUME: + if (sigdata->flags & IT_WAS_AN_XM) + channel->volume = MIN(entry->effectvalue, 64); + else if (entry->effectvalue <= 64) + channel->channelvolume = entry->effectvalue; #ifdef VOLUME_OUT_OF_RANGE_SETS_MAXIMUM - else - channel->channelvolume = 64; + else + channel->channelvolume = 64; #endif - if (channel->playing) - channel->playing->channel_volume = channel->channelvolume; - break; - case IT_CHANNEL_VOLUME_SLIDE: - { - unsigned char v = entry->effectvalue; - if (v == 0) - v = channel->lastN; - channel->lastN = v; - if ((v & 0x0F) == 0) { /* Nx0 */ - channel->channelvolslide = v >> 4; - } else if ((v & 0xF0) == 0) { /* N0x */ - channel->channelvolslide = -v; - } else { - if ((v & 0x0F) == 0x0F) { /* NxF */ - channel->channelvolume += v >> 4; - if (channel->channelvolume > 64) channel->channelvolume = 64; - } else if ((v & 0xF0) == 0xF0) { /* NFx */ - channel->channelvolume -= v & 15; - if (channel->channelvolume > 64) channel->channelvolume = 0; - } else - break; - if (channel->playing) - channel->playing->channel_volume = channel->channelvolume; - } - } - break; - case IT_SET_SAMPLE_OFFSET: - { - unsigned char v = entry->effectvalue; - /*if (sigdata->flags & IT_WAS_A_MOD) { + if (channel->playing) + channel->playing->channel_volume = channel->channelvolume; + break; + case IT_CHANNEL_VOLUME_SLIDE: { + unsigned char v = entry->effectvalue; + if (v == 0) + v = channel->lastN; + channel->lastN = v; + if ((v & 0x0F) == 0) { /* Nx0 */ + channel->channelvolslide = v >> 4; + } else if ((v & 0xF0) == 0) { /* N0x */ + channel->channelvolslide = -v; + } else { + if ((v & 0x0F) == 0x0F) { /* NxF */ + channel->channelvolume += v >> 4; + if (channel->channelvolume > 64) + channel->channelvolume = 64; + } else if ((v & 0xF0) == 0xF0) { /* NFx */ + channel->channelvolume -= v & 15; + if (channel->channelvolume > 64) + channel->channelvolume = 0; + } else + break; + if (channel->playing) + channel->playing->channel_volume = channel->channelvolume; + } + } break; + case IT_SET_SAMPLE_OFFSET: { + unsigned char v = entry->effectvalue; + /*if (sigdata->flags & IT_WAS_A_MOD) { if (v == 0) break; } else*/ { - if (v == 0) - v = channel->lastO; - channel->lastO = v; - } - /* Note: we set the offset even if tone portamento is - * specified. Impulse Tracker does the same. - */ - if (entry->mask & IT_ENTRY_NOTE) { - if (channel->playing) { - int offset = ((int)channel->high_offset << 16) | ((int)v << 8); - IT_PLAYING *playing = channel->playing; - IT_SAMPLE *sample = playing->sample; - int end; - if ((sample->flags & IT_SAMPLE_SUS_LOOP) && !(playing->flags & IT_PLAYING_SUSTAINOFF)) - end = (int)sample->sus_loop_end; - else if (sample->flags & IT_SAMPLE_LOOP) - end = (int)sample->loop_end; - else { - end = (int)sample->length; - if ( sigdata->flags & IT_WAS_PROCESSED && end > 64 ) // XXX bah damn LPC and edge case modules - end -= 64; - } - if ((sigdata->flags & IT_WAS_A_PTM) && (sample->flags & IT_SAMPLE_16BIT)) - offset >>= 1; - if (offset < end) { - it_playing_reset_resamplers(playing, offset); - playing->declick_stage = 0; - } else if (sigdata->flags & IT_OLD_EFFECTS) { - it_playing_reset_resamplers(playing, end); - playing->declick_stage = 0; - } - } - } - } - break; - case IT_PANNING_SLIDE: - /** JULIEN: guess what? the docs are wrong! (how unusual ;) - * Pxy seems to memorize its previous value... and there - * might be other mistakes like that... (sigh!) - */ - /** ENTHEH: umm... but... the docs say that Pxy memorises its - * value... don't they? :o - */ - { - unsigned char v = entry->effectvalue; - int p = channel->truepan; - if (sigdata->flags & IT_WAS_AN_XM) - { - if (IT_IS_SURROUND(channel->pan)) - { - channel->pan = 32; - p = 32 + 128 * 64; - } - p >>= 6; - } - else { - if (IT_IS_SURROUND(channel->pan)) p = 32 << 8; - p = (p + 128) >> 8; - channel->pan = p; - } - if (v == 0) - v = channel->lastP; - channel->lastP = v; - if ((v & 0x0F) == 0) { /* Px0 */ - channel->panslide = -(v >> 4); - } else if ((v & 0xF0) == 0) { /* P0x */ - channel->panslide = v; - } else if ((v & 0x0F) == 0x0F) { /* PxF */ - p -= v >> 4; - } else if ((v & 0xF0) == 0xF0) { /* PFx */ - p += v & 15; - } - if (sigdata->flags & IT_WAS_AN_XM) - channel->truepan = 32 + MID(0, p, 255) * 64; - else { - if (p < 0) p = 0; - else if (p > 64) p = 64; - channel->pan = p; - channel->truepan = p << 8; - } - } - break; - case IT_RETRIGGER_NOTE: - { - unsigned char v = entry->effectvalue; - if (sigdata->flags & IT_WAS_AN_XM) { - if ((v & 0x0F) == 0) v |= channel->lastQ & 0x0F; - if ((v & 0xF0) == 0) v |= channel->lastQ & 0xF0; - channel->lastQ = v; - } else if (sigdata->flags & IT_WAS_AN_S3M) { - if (v == 0) - v = channel->lastDKL; - channel->lastDKL = v; - } else { - if (v == 0) - v = channel->lastQ; - channel->lastQ = v; - } - if ((v & 0x0F) == 0) v |= 0x01; - channel->retrig = v; - if (entry->mask & IT_ENTRY_NOTE) { - channel->retrig_tick = v & 0x0F; - /* Emulate a bug */ - if (sigdata->flags & IT_WAS_AN_XM) - update_retrig(sigrenderer, channel); - } else - update_retrig(sigrenderer, channel); - } - break; - case IT_XM_RETRIGGER_NOTE: - channel->retrig_tick = channel->xm_retrig = entry->effectvalue; - if (entry->effectvalue == 0) - if (channel->playing) { - it_playing_reset_resamplers(channel->playing, 0); - channel->playing->declick_stage = 0; - } - break; - case IT_TREMOLO: - { - unsigned char speed, depth; - if (sigdata->flags & IT_WAS_AN_S3M) { - unsigned char v = entry->effectvalue; - if (v == 0) - v = channel->lastDKL; - channel->lastDKL = v; - speed = v >> 4; - depth = v & 15; - } else { - speed = entry->effectvalue >> 4; - depth = entry->effectvalue & 15; - if (speed == 0) - speed = channel->lastRspeed; - channel->lastRspeed = speed; - if (depth == 0) - depth = channel->lastRdepth; - channel->lastRdepth = depth; - } - for (i = -1; i < DUMB_IT_N_NNA_CHANNELS; i++) { - if (i < 0) playing = channel->playing; - else { - playing = sigrenderer->playing[i]; - if (!playing || playing->channel != channel) continue; - } - if (playing) { - playing->tremolo_speed = speed; - playing->tremolo_depth = depth; - } - } - } - break; - case IT_S: - { - /* channel->lastS was set in update_pattern_variables(). */ - unsigned char effectvalue = channel->lastS; - switch (effectvalue >> 4) { - //case IT_S_SET_FILTER: - /* Waveforms for commands S3x, S4x and S5x: - * 0: Sine wave - * 1: Ramp down - * 2: Square wave - * 3: Random wave - */ - case IT_S_SET_GLISSANDO_CONTROL: - channel->glissando = effectvalue & 15; - break; + if (v == 0) + v = channel->lastO; + channel->lastO = v; + } + /* Note: we set the offset even if tone portamento is + * specified. Impulse Tracker does the same. + */ + if (entry->mask & IT_ENTRY_NOTE) { + if (channel->playing) { + int offset = + ((int)channel->high_offset << 16) | ((int)v << 8); + IT_PLAYING *playing = channel->playing; + IT_SAMPLE *sample = playing->sample; + int end; + if ((sample->flags & IT_SAMPLE_SUS_LOOP) && + !(playing->flags & IT_PLAYING_SUSTAINOFF)) + end = (int)sample->sus_loop_end; + else if (sample->flags & IT_SAMPLE_LOOP) + end = (int)sample->loop_end; + else { + end = (int)sample->length; + if (sigdata->flags & IT_WAS_PROCESSED && + end > 64) // XXX bah damn LPC and edge case modules + end -= 64; + } + if ((sigdata->flags & IT_WAS_A_PTM) && + (sample->flags & IT_SAMPLE_16BIT)) + offset >>= 1; + if (offset < end) { + it_playing_reset_resamplers(playing, offset); + playing->declick_stage = 0; + } else if (sigdata->flags & IT_OLD_EFFECTS) { + it_playing_reset_resamplers(playing, end); + playing->declick_stage = 0; + } + } + } + } break; + case IT_PANNING_SLIDE: + /** JULIEN: guess what? the docs are wrong! (how unusual ;) + * Pxy seems to memorize its previous value... and there + * might be other mistakes like that... (sigh!) + */ + /** ENTHEH: umm... but... the docs say that Pxy memorises its + * value... don't they? :o + */ + { + unsigned char v = entry->effectvalue; + int p = channel->truepan; + if (sigdata->flags & IT_WAS_AN_XM) { + if (IT_IS_SURROUND(channel->pan)) { + channel->pan = 32; + p = 32 + 128 * 64; + } + p >>= 6; + } else { + if (IT_IS_SURROUND(channel->pan)) + p = 32 << 8; + p = (p + 128) >> 8; + channel->pan = p; + } + if (v == 0) + v = channel->lastP; + channel->lastP = v; + if ((v & 0x0F) == 0) { /* Px0 */ + channel->panslide = -(v >> 4); + } else if ((v & 0xF0) == 0) { /* P0x */ + channel->panslide = v; + } else if ((v & 0x0F) == 0x0F) { /* PxF */ + p -= v >> 4; + } else if ((v & 0xF0) == 0xF0) { /* PFx */ + p += v & 15; + } + if (sigdata->flags & IT_WAS_AN_XM) + channel->truepan = 32 + MID(0, p, 255) * 64; + else { + if (p < 0) + p = 0; + else if (p > 64) + p = 64; + channel->pan = p; + channel->truepan = p << 8; + } + } + break; + case IT_RETRIGGER_NOTE: { + unsigned char v = entry->effectvalue; + if (sigdata->flags & IT_WAS_AN_XM) { + if ((v & 0x0F) == 0) + v |= channel->lastQ & 0x0F; + if ((v & 0xF0) == 0) + v |= channel->lastQ & 0xF0; + channel->lastQ = v; + } else if (sigdata->flags & IT_WAS_AN_S3M) { + if (v == 0) + v = channel->lastDKL; + channel->lastDKL = v; + } else { + if (v == 0) + v = channel->lastQ; + channel->lastQ = v; + } + if ((v & 0x0F) == 0) + v |= 0x01; + channel->retrig = v; + if (entry->mask & IT_ENTRY_NOTE) { + channel->retrig_tick = v & 0x0F; + /* Emulate a bug */ + if (sigdata->flags & IT_WAS_AN_XM) + update_retrig(sigrenderer, channel); + } else + update_retrig(sigrenderer, channel); + } break; + case IT_XM_RETRIGGER_NOTE: + channel->retrig_tick = channel->xm_retrig = entry->effectvalue; + if (entry->effectvalue == 0) + if (channel->playing) { + it_playing_reset_resamplers(channel->playing, 0); + channel->playing->declick_stage = 0; + } + break; + case IT_TREMOLO: { + unsigned char speed, depth; + if (sigdata->flags & IT_WAS_AN_S3M) { + unsigned char v = entry->effectvalue; + if (v == 0) + v = channel->lastDKL; + channel->lastDKL = v; + speed = v >> 4; + depth = v & 15; + } else { + speed = entry->effectvalue >> 4; + depth = entry->effectvalue & 15; + if (speed == 0) + speed = channel->lastRspeed; + channel->lastRspeed = speed; + if (depth == 0) + depth = channel->lastRdepth; + channel->lastRdepth = depth; + } + for (i = -1; i < DUMB_IT_N_NNA_CHANNELS; i++) { + if (i < 0) + playing = channel->playing; + else { + playing = sigrenderer->playing[i]; + if (!playing || playing->channel != channel) + continue; + } + if (playing) { + playing->tremolo_speed = speed; + playing->tremolo_depth = depth; + } + } + } break; + case IT_S: { + /* channel->lastS was set in update_pattern_variables(). */ + unsigned char effectvalue = channel->lastS; + switch (effectvalue >> 4) { + // case IT_S_SET_FILTER: + /* Waveforms for commands S3x, S4x and S5x: + * 0: Sine wave + * 1: Ramp down + * 2: Square wave + * 3: Random wave + */ + case IT_S_SET_GLISSANDO_CONTROL: + channel->glissando = effectvalue & 15; + break; - case IT_S_FINETUNE: - if (channel->playing) { - channel->playing->finetune = ((int)(effectvalue & 15) - 8) << 5; - } - break; + case IT_S_FINETUNE: + if (channel->playing) { + channel->playing->finetune = ((int)(effectvalue & 15) - 8) + << 5; + } + break; - case IT_S_SET_VIBRATO_WAVEFORM: - { - int waveform = effectvalue & 3; - if (sigdata->flags & IT_WAS_A_MOD) waveform = mod_convert_vibrato[waveform]; - else if (sigdata->flags & IT_WAS_AN_XM) waveform = xm_convert_vibrato[waveform]; - channel->vibrato_waveform = waveform; - if (channel->playing) { - channel->playing->vibrato_waveform = waveform; - if (!(effectvalue & 4)) - channel->playing->vibrato_time = 0; - } - } - break; - case IT_S_SET_TREMOLO_WAVEFORM: - { - int waveform = effectvalue & 3; - if (sigdata->flags & IT_WAS_A_MOD) waveform = mod_convert_vibrato[waveform]; - else if (sigdata->flags & IT_WAS_AN_XM) waveform = xm_convert_vibrato[waveform]; - channel->tremolo_waveform = waveform; - if (channel->playing) { - channel->playing->tremolo_waveform = waveform; - if (!(effectvalue & 4)) - channel->playing->tremolo_time = 0; - } - } - break; - case IT_S_SET_PANBRELLO_WAVEFORM: - channel->panbrello_waveform = effectvalue & 3; - if (channel->playing) { - channel->playing->panbrello_waveform = effectvalue & 3; - if (!(effectvalue & 4)) - channel->playing->panbrello_time = 0; - } - break; + case IT_S_SET_VIBRATO_WAVEFORM: { + int waveform = effectvalue & 3; + if (sigdata->flags & IT_WAS_A_MOD) + waveform = mod_convert_vibrato[waveform]; + else if (sigdata->flags & IT_WAS_AN_XM) + waveform = xm_convert_vibrato[waveform]; + channel->vibrato_waveform = waveform; + if (channel->playing) { + channel->playing->vibrato_waveform = waveform; + if (!(effectvalue & 4)) + channel->playing->vibrato_time = 0; + } + } break; + case IT_S_SET_TREMOLO_WAVEFORM: { + int waveform = effectvalue & 3; + if (sigdata->flags & IT_WAS_A_MOD) + waveform = mod_convert_vibrato[waveform]; + else if (sigdata->flags & IT_WAS_AN_XM) + waveform = xm_convert_vibrato[waveform]; + channel->tremolo_waveform = waveform; + if (channel->playing) { + channel->playing->tremolo_waveform = waveform; + if (!(effectvalue & 4)) + channel->playing->tremolo_time = 0; + } + } break; + case IT_S_SET_PANBRELLO_WAVEFORM: + channel->panbrello_waveform = effectvalue & 3; + if (channel->playing) { + channel->playing->panbrello_waveform = effectvalue & 3; + if (!(effectvalue & 4)) + channel->playing->panbrello_time = 0; + } + break; - case IT_S_FINE_PATTERN_DELAY: - sigrenderer->tick += effectvalue & 15; - break; + case IT_S_FINE_PATTERN_DELAY: + sigrenderer->tick += effectvalue & 15; + break; #if 1 - case IT_S7: - { - if (sigrenderer->sigdata->flags & IT_USE_INSTRUMENTS) - { - int i; - switch (effectvalue & 15) - { - case 0: /* cut background notes */ - for (i = 0; i < DUMB_IT_N_NNA_CHANNELS; i++) - { - IT_PLAYING * playing = sigrenderer->playing[i]; - if (playing && channel == playing->channel) - { - playing->declick_stage = 3; - if (channel->playing == playing) channel->playing = NULL; - } - } - break; - case 1: /* release background notes */ - for (i = 0; i < DUMB_IT_N_NNA_CHANNELS; i++) - { - IT_PLAYING * playing = sigrenderer->playing[i]; - if (playing && channel == playing->channel && !(playing->flags & IT_PLAYING_SUSTAINOFF)) - { - it_note_off(playing); - } - } - break; - case 2: /* fade background notes */ - for (i = 0; i < DUMB_IT_N_NNA_CHANNELS; i++) - { - IT_PLAYING * playing = sigrenderer->playing[i]; - if (playing && channel == playing->channel) - { - //playing->flags &= IT_PLAYING_SUSTAINOFF; - playing->flags |= IT_PLAYING_FADING; - } - } - break; - case 3: - channel->new_note_action = NNA_NOTE_CUT; - break; - case 4: - channel->new_note_action = NNA_NOTE_CONTINUE; - break; - case 5: - channel->new_note_action = NNA_NOTE_OFF; - break; - case 6: - channel->new_note_action = NNA_NOTE_FADE; - break; + case IT_S7: { + if (sigrenderer->sigdata->flags & IT_USE_INSTRUMENTS) { + int i; + switch (effectvalue & 15) { + case 0: /* cut background notes */ + for (i = 0; i < DUMB_IT_N_NNA_CHANNELS; i++) { + IT_PLAYING *playing = sigrenderer->playing[i]; + if (playing && channel == playing->channel) { + playing->declick_stage = 3; + if (channel->playing == playing) + channel->playing = NULL; + } + } + break; + case 1: /* release background notes */ + for (i = 0; i < DUMB_IT_N_NNA_CHANNELS; i++) { + IT_PLAYING *playing = sigrenderer->playing[i]; + if (playing && channel == playing->channel && + !(playing->flags & IT_PLAYING_SUSTAINOFF)) { + it_note_off(playing); + } + } + break; + case 2: /* fade background notes */ + for (i = 0; i < DUMB_IT_N_NNA_CHANNELS; i++) { + IT_PLAYING *playing = sigrenderer->playing[i]; + if (playing && channel == playing->channel) { + // playing->flags &= IT_PLAYING_SUSTAINOFF; + playing->flags |= IT_PLAYING_FADING; + } + } + break; + case 3: + channel->new_note_action = NNA_NOTE_CUT; + break; + case 4: + channel->new_note_action = NNA_NOTE_CONTINUE; + break; + case 5: + channel->new_note_action = NNA_NOTE_OFF; + break; + case 6: + channel->new_note_action = NNA_NOTE_FADE; + break; - case 7: - if (channel->playing) - channel->playing->enabled_envelopes &= ~IT_ENV_VOLUME; - break; - case 8: - if (channel->playing) - channel->playing->enabled_envelopes |= IT_ENV_VOLUME; - break; + case 7: + if (channel->playing) + channel->playing->enabled_envelopes &= + ~IT_ENV_VOLUME; + break; + case 8: + if (channel->playing) + channel->playing->enabled_envelopes |= + IT_ENV_VOLUME; + break; - case 9: - if (channel->playing) - channel->playing->enabled_envelopes &= ~IT_ENV_PANNING; - break; - case 10: - if (channel->playing) - channel->playing->enabled_envelopes |= IT_ENV_PANNING; - break; + case 9: + if (channel->playing) + channel->playing->enabled_envelopes &= + ~IT_ENV_PANNING; + break; + case 10: + if (channel->playing) + channel->playing->enabled_envelopes |= + IT_ENV_PANNING; + break; - case 11: - if (channel->playing) - channel->playing->enabled_envelopes &= ~IT_ENV_PITCH; - break; - case 12: - if (channel->playing) - channel->playing->enabled_envelopes |= IT_ENV_PITCH; - break; - } - } - } - break; + case 11: + if (channel->playing) + channel->playing->enabled_envelopes &= + ~IT_ENV_PITCH; + break; + case 12: + if (channel->playing) + channel->playing->enabled_envelopes |= IT_ENV_PITCH; + break; + } + } + } break; #endif - case IT_S_SET_PAN: - //ASSERT(!(sigdata->flags & IT_WAS_AN_XM)); - channel->pan = - ((effectvalue & 15) << 2) | - ((effectvalue & 15) >> 2); - channel->truepan = channel->pan << IT_ENVELOPE_SHIFT; + case IT_S_SET_PAN: + // ASSERT(!(sigdata->flags & IT_WAS_AN_XM)); + channel->pan = + ((effectvalue & 15) << 2) | ((effectvalue & 15) >> 2); + channel->truepan = channel->pan << IT_ENVELOPE_SHIFT; - if (channel->playing) - channel->playing->panbrello_depth = 0; - break; - case IT_S_SET_SURROUND_SOUND: - if ((effectvalue & 15) == 15) { - if (channel->playing && channel->playing->sample && - !(channel->playing->sample->flags & (IT_SAMPLE_LOOP | IT_SAMPLE_SUS_LOOP))) { - channel->playing->flags |= IT_PLAYING_REVERSE; - it_playing_reset_resamplers( channel->playing, channel->playing->sample->length - 1 ); - } - } else if ((effectvalue & 15) == 1) { - channel->pan = IT_SURROUND; - channel->truepan = channel->pan << IT_ENVELOPE_SHIFT; - } - if (channel->playing) - channel->playing->panbrello_depth = 0; - break; - case IT_S_SET_HIGH_OFFSET: - channel->high_offset = effectvalue & 15; - break; - //case IT_S_PATTERN_LOOP: - case IT_S_DELAYED_NOTE_CUT: - channel->note_cut_count = effectvalue & 15; - if (!channel->note_cut_count) { - if (sigdata->flags & (IT_WAS_AN_XM | IT_WAS_A_PTM)) - channel->volume = 0; - else - channel->note_cut_count = 1; - } - break; - case IT_S_SET_MIDI_MACRO: - if ((sigdata->flags & (IT_WAS_AN_XM | IT_WAS_A_MOD)) == (IT_WAS_AN_XM | IT_WAS_A_MOD)) { - channel->inv_loop_speed = effectvalue & 15; - update_invert_loop(channel, channel->playing ? channel->playing->sample : NULL); - } else channel->SFmacro = effectvalue & 15; - break; - } - } - break; - case IT_SET_SONG_TEMPO: - { - unsigned char v = entry->effectvalue; - if (v == 0) - v = channel->lastW; - channel->lastW = v; - if (v < 0x10) - sigrenderer->temposlide = -v; - else if (v < 0x20) - sigrenderer->temposlide = v & 15; - else - sigrenderer->tempo = v; - } - break; - case IT_FINE_VIBRATO: - { - unsigned char speed = entry->effectvalue >> 4; - unsigned char depth = entry->effectvalue & 15; - if (speed == 0) - speed = channel->lastHspeed; - channel->lastHspeed = speed; - if (depth == 0) - depth = channel->lastHdepth; - else { - if (sigdata->flags & IT_OLD_EFFECTS) - depth <<= 1; - channel->lastHdepth = depth; - } - for (i = -1; i < DUMB_IT_N_NNA_CHANNELS; i++) { - if (i < 0) playing = channel->playing; - else { - playing = sigrenderer->playing[i]; - if (!playing || playing->channel != channel) continue; - } - if (playing) { - playing->vibrato_speed = speed; - playing->vibrato_depth = depth; - playing->vibrato_n++; - } - } - } - break; - case IT_SET_GLOBAL_VOLUME: - if ((sigdata->flags & IT_WAS_AN_S3M) && (entry->effectvalue > 64)) - break; - if (entry->effectvalue <= 128) - sigrenderer->globalvolume = entry->effectvalue; + if (channel->playing) + channel->playing->panbrello_depth = 0; + break; + case IT_S_SET_SURROUND_SOUND: + if ((effectvalue & 15) == 15) { + if (channel->playing && channel->playing->sample && + !(channel->playing->sample->flags & + (IT_SAMPLE_LOOP | IT_SAMPLE_SUS_LOOP))) { + channel->playing->flags |= IT_PLAYING_REVERSE; + it_playing_reset_resamplers( + channel->playing, + channel->playing->sample->length - 1); + } + } else if ((effectvalue & 15) == 1) { + channel->pan = IT_SURROUND; + channel->truepan = channel->pan << IT_ENVELOPE_SHIFT; + } + if (channel->playing) + channel->playing->panbrello_depth = 0; + break; + case IT_S_SET_HIGH_OFFSET: + channel->high_offset = effectvalue & 15; + break; + // case IT_S_PATTERN_LOOP: + case IT_S_DELAYED_NOTE_CUT: + channel->note_cut_count = effectvalue & 15; + if (!channel->note_cut_count) { + if (sigdata->flags & (IT_WAS_AN_XM | IT_WAS_A_PTM)) + channel->volume = 0; + else + channel->note_cut_count = 1; + } + break; + case IT_S_SET_MIDI_MACRO: + if ((sigdata->flags & (IT_WAS_AN_XM | IT_WAS_A_MOD)) == + (IT_WAS_AN_XM | IT_WAS_A_MOD)) { + channel->inv_loop_speed = effectvalue & 15; + update_invert_loop(channel, channel->playing + ? channel->playing->sample + : NULL); + } else + channel->SFmacro = effectvalue & 15; + break; + } + } break; + case IT_SET_SONG_TEMPO: { + unsigned char v = entry->effectvalue; + if (v == 0) + v = channel->lastW; + channel->lastW = v; + if (v < 0x10) + sigrenderer->temposlide = -v; + else if (v < 0x20) + sigrenderer->temposlide = v & 15; + else + sigrenderer->tempo = v; + } break; + case IT_FINE_VIBRATO: { + unsigned char speed = entry->effectvalue >> 4; + unsigned char depth = entry->effectvalue & 15; + if (speed == 0) + speed = channel->lastHspeed; + channel->lastHspeed = speed; + if (depth == 0) + depth = channel->lastHdepth; + else { + if (sigdata->flags & IT_OLD_EFFECTS) + depth <<= 1; + channel->lastHdepth = depth; + } + for (i = -1; i < DUMB_IT_N_NNA_CHANNELS; i++) { + if (i < 0) + playing = channel->playing; + else { + playing = sigrenderer->playing[i]; + if (!playing || playing->channel != channel) + continue; + } + if (playing) { + playing->vibrato_speed = speed; + playing->vibrato_depth = depth; + playing->vibrato_n++; + } + } + } break; + case IT_SET_GLOBAL_VOLUME: + if ((sigdata->flags & IT_WAS_AN_S3M) && (entry->effectvalue > 64)) + break; + if (entry->effectvalue <= 128) + sigrenderer->globalvolume = entry->effectvalue; #ifdef VOLUME_OUT_OF_RANGE_SETS_MAXIMUM - else - sigrenderer->globalvolume = 128; + else + sigrenderer->globalvolume = 128; #endif - break; - case IT_GLOBAL_VOLUME_SLIDE: - { - unsigned char v = entry->effectvalue; - if (v == 0) - v = channel->lastW; - channel->lastW = v; - if ((v & 0x0F) == 0) { /* Wx0 */ - sigrenderer->globalvolslide = - (sigdata->flags & IT_WAS_AN_XM) ? (v >> 4)*2 : (v >> 4); - } else if ((v & 0xF0) == 0) { /* W0x */ - sigrenderer->globalvolslide = - (sigdata->flags & IT_WAS_AN_XM) ? (-v)*2 : (-v); - } else if ((v & 0x0F) == 0x0F) { /* WxF */ - sigrenderer->globalvolume += v >> 4; - if (sigrenderer->globalvolume > 128) sigrenderer->globalvolume = 128; - } else if ((v & 0xF0) == 0xF0) { /* WFx */ - sigrenderer->globalvolume -= v & 15; - if (sigrenderer->globalvolume > 128) sigrenderer->globalvolume = 0; - } - } - break; - case IT_SET_PANNING: - if (sigdata->flags & IT_WAS_AN_XM) { - channel->truepan = 32 + entry->effectvalue*64; - } else { - if (sigdata->flags & IT_WAS_AN_S3M) - channel->pan = (entry->effectvalue + 1) >> 1; - else - channel->pan = (entry->effectvalue + 2) >> 2; - channel->truepan = channel->pan << IT_ENVELOPE_SHIFT; - } - if (channel->playing) - channel->playing->panbrello_depth = 0; - break; - case IT_PANBRELLO: - { - unsigned char speed = entry->effectvalue >> 4; - unsigned char depth = entry->effectvalue & 15; - if (speed == 0) - speed = channel->lastYspeed; - channel->lastYspeed = speed; - if (depth == 0) - depth = channel->lastYdepth; - channel->lastYdepth = depth; - if (channel->playing) { - channel->playing->panbrello_speed = speed; - channel->playing->panbrello_depth = depth; - } - } - break; - case IT_MIDI_MACRO: - { - const IT_MIDI *midi = sigdata->midi ? sigdata->midi : &default_midi; - if (entry->effectvalue >= 0x80) { - int n = midi->Zmacrolen[entry->effectvalue-0x80]; - int i; - for (i = 0; i < n; i++) - it_send_midi(sigrenderer, channel, midi->Zmacro[entry->effectvalue-0x80][i]); - } else { - int n = midi->SFmacrolen[channel->SFmacro]; - int i, j; - for (i = 0, j = 1; i < n; i++, j <<= 1) - it_send_midi(sigrenderer, channel, - (unsigned char)(midi->SFmacroz[channel->SFmacro] & j ? - entry->effectvalue : midi->SFmacro[channel->SFmacro][i])); - } - } - break; - case IT_XM_SET_ENVELOPE_POSITION: - if (channel->playing && channel->playing->env_instrument) { - IT_ENVELOPE *envelope = &channel->playing->env_instrument->volume_envelope; - if (envelope->flags & IT_ENVELOPE_ON) { - IT_PLAYING_ENVELOPE *pe = &channel->playing->volume_envelope; - pe->tick = entry->effectvalue; - if (pe->tick >= envelope->node_t[envelope->n_nodes-1]) - pe->tick = envelope->node_t[envelope->n_nodes-1]; - pe->next_node = 0; - while (pe->tick > envelope->node_t[pe->next_node]) pe->next_node++; - xm_envelope_calculate_value(envelope, pe); - } - } - break; + break; + case IT_GLOBAL_VOLUME_SLIDE: { + unsigned char v = entry->effectvalue; + if (v == 0) + v = channel->lastW; + channel->lastW = v; + if ((v & 0x0F) == 0) { /* Wx0 */ + sigrenderer->globalvolslide = + (sigdata->flags & IT_WAS_AN_XM) ? (v >> 4) * 2 : (v >> 4); + } else if ((v & 0xF0) == 0) { /* W0x */ + sigrenderer->globalvolslide = + (sigdata->flags & IT_WAS_AN_XM) ? (-v) * 2 : (-v); + } else if ((v & 0x0F) == 0x0F) { /* WxF */ + sigrenderer->globalvolume += v >> 4; + if (sigrenderer->globalvolume > 128) + sigrenderer->globalvolume = 128; + } else if ((v & 0xF0) == 0xF0) { /* WFx */ + sigrenderer->globalvolume -= v & 15; + if (sigrenderer->globalvolume > 128) + sigrenderer->globalvolume = 0; + } + } break; + case IT_SET_PANNING: + if (sigdata->flags & IT_WAS_AN_XM) { + channel->truepan = 32 + entry->effectvalue * 64; + } else { + if (sigdata->flags & IT_WAS_AN_S3M) + channel->pan = (entry->effectvalue + 1) >> 1; + else + channel->pan = (entry->effectvalue + 2) >> 2; + channel->truepan = channel->pan << IT_ENVELOPE_SHIFT; + } + if (channel->playing) + channel->playing->panbrello_depth = 0; + break; + case IT_PANBRELLO: { + unsigned char speed = entry->effectvalue >> 4; + unsigned char depth = entry->effectvalue & 15; + if (speed == 0) + speed = channel->lastYspeed; + channel->lastYspeed = speed; + if (depth == 0) + depth = channel->lastYdepth; + channel->lastYdepth = depth; + if (channel->playing) { + channel->playing->panbrello_speed = speed; + channel->playing->panbrello_depth = depth; + } + } break; + case IT_MIDI_MACRO: { + const IT_MIDI *midi = sigdata->midi ? sigdata->midi : &default_midi; + if (entry->effectvalue >= 0x80) { + int n = midi->Zmacrolen[entry->effectvalue - 0x80]; + int i; + for (i = 0; i < n; i++) + it_send_midi(sigrenderer, channel, + midi->Zmacro[entry->effectvalue - 0x80][i]); + } else { + int n = midi->SFmacrolen[channel->SFmacro]; + int i, j; + for (i = 0, j = 1; i < n; i++, j <<= 1) + it_send_midi( + sigrenderer, channel, + (unsigned char)(midi->SFmacroz[channel->SFmacro] & j + ? entry->effectvalue + : midi->SFmacro[channel->SFmacro] + [i])); + } + } break; + case IT_XM_SET_ENVELOPE_POSITION: + if (channel->playing && channel->playing->env_instrument) { + IT_ENVELOPE *envelope = + &channel->playing->env_instrument->volume_envelope; + if (envelope->flags & IT_ENVELOPE_ON) { + IT_PLAYING_ENVELOPE *pe = + &channel->playing->volume_envelope; + pe->tick = entry->effectvalue; + if (pe->tick >= envelope->node_t[envelope->n_nodes - 1]) + pe->tick = envelope->node_t[envelope->n_nodes - 1]; + pe->next_node = 0; + while (pe->tick > envelope->node_t[pe->next_node]) + pe->next_node++; + xm_envelope_calculate_value(envelope, pe); + } + } + break; - /* uggly plain portamento for now */ - case IT_PTM_NOTE_SLIDE_DOWN: - case IT_PTM_NOTE_SLIDE_DOWN_RETRIG: - { - channel->toneslide_retrig = (entry->effect == IT_PTM_NOTE_SLIDE_DOWN_RETRIG); + /* uggly plain portamento for now */ + case IT_PTM_NOTE_SLIDE_DOWN: + case IT_PTM_NOTE_SLIDE_DOWN_RETRIG: { + channel->toneslide_retrig = + (entry->effect == IT_PTM_NOTE_SLIDE_DOWN_RETRIG); - if (channel->ptm_last_toneslide) { - channel->toneslide_tick = channel->last_toneslide_tick; + if (channel->ptm_last_toneslide) { + channel->toneslide_tick = channel->last_toneslide_tick; - if (--channel->toneslide_tick == 0) { - channel->truenote += channel->toneslide; - if (channel->truenote >= 120) { - if (channel->toneslide < 0) channel->truenote = 0; - else channel->truenote = 119; - } - channel->note += channel->toneslide; - if (channel->note >= 120) { - if (channel->toneslide < 0) channel->note = 0; - else channel->note = 119; - } + if (--channel->toneslide_tick == 0) { + channel->truenote += channel->toneslide; + if (channel->truenote >= 120) { + if (channel->toneslide < 0) + channel->truenote = 0; + else + channel->truenote = 119; + } + channel->note += channel->toneslide; + if (channel->note >= 120) { + if (channel->toneslide < 0) + channel->note = 0; + else + channel->note = 119; + } - if (channel->playing) { - if (channel->sample) channel->playing->note = channel->truenote; - else channel->playing->note = channel->note; - it_playing_reset_resamplers(channel->playing, 0); - channel->playing->declick_stage = 0; - } - } - } + if (channel->playing) { + if (channel->sample) + channel->playing->note = channel->truenote; + else + channel->playing->note = channel->note; + it_playing_reset_resamplers(channel->playing, 0); + channel->playing->declick_stage = 0; + } + } + } - channel->ptm_last_toneslide = 0; + channel->ptm_last_toneslide = 0; - channel->toneslide = -(entry->effectvalue & 15); - channel->ptm_toneslide = (entry->effectvalue & 0xF0) >> 4; - channel->toneslide_tick += channel->ptm_toneslide; - } - break; - case IT_PTM_NOTE_SLIDE_UP: - case IT_PTM_NOTE_SLIDE_UP_RETRIG: - { - channel->toneslide_retrig = (entry->effect == IT_PTM_NOTE_SLIDE_UP_RETRIG); + channel->toneslide = -(entry->effectvalue & 15); + channel->ptm_toneslide = (entry->effectvalue & 0xF0) >> 4; + channel->toneslide_tick += channel->ptm_toneslide; + } break; + case IT_PTM_NOTE_SLIDE_UP: + case IT_PTM_NOTE_SLIDE_UP_RETRIG: { + channel->toneslide_retrig = + (entry->effect == IT_PTM_NOTE_SLIDE_UP_RETRIG); - if (channel->ptm_last_toneslide) { - channel->toneslide_tick = channel->last_toneslide_tick; + if (channel->ptm_last_toneslide) { + channel->toneslide_tick = channel->last_toneslide_tick; - if (--channel->toneslide_tick == 0) { - channel->truenote += channel->toneslide; - if (channel->truenote >= 120) { - if (channel->toneslide < 0) channel->truenote = 0; - else channel->truenote = 119; - } - channel->note += channel->toneslide; - if (channel->note >= 120) { - if (channel->toneslide < 0) channel->note = 0; - else channel->note = 119; - } + if (--channel->toneslide_tick == 0) { + channel->truenote += channel->toneslide; + if (channel->truenote >= 120) { + if (channel->toneslide < 0) + channel->truenote = 0; + else + channel->truenote = 119; + } + channel->note += channel->toneslide; + if (channel->note >= 120) { + if (channel->toneslide < 0) + channel->note = 0; + else + channel->note = 119; + } - if (channel->playing) { - if (channel->sample) channel->playing->note = channel->truenote; - else channel->playing->note = channel->note; - it_playing_reset_resamplers(channel->playing, 0); - channel->playing->declick_stage = 0; - } - } - } + if (channel->playing) { + if (channel->sample) + channel->playing->note = channel->truenote; + else + channel->playing->note = channel->note; + it_playing_reset_resamplers(channel->playing, 0); + channel->playing->declick_stage = 0; + } + } + } - channel->ptm_last_toneslide = 0; + channel->ptm_last_toneslide = 0; - channel->toneslide = -(entry->effectvalue & 15); - channel->ptm_toneslide = (entry->effectvalue & 0xF0) >> 4; - channel->toneslide_tick += channel->ptm_toneslide; - } - break; + channel->toneslide = -(entry->effectvalue & 15); + channel->ptm_toneslide = (entry->effectvalue & 0xF0) >> 4; + channel->toneslide_tick += channel->ptm_toneslide; + } break; - case IT_OKT_NOTE_SLIDE_DOWN: - case IT_OKT_NOTE_SLIDE_DOWN_ROW: - channel->toneslide = -entry->effectvalue; - channel->okt_toneslide = (entry->effect == IT_OKT_NOTE_SLIDE_DOWN) ? 255 : 1; - break; + case IT_OKT_NOTE_SLIDE_DOWN: + case IT_OKT_NOTE_SLIDE_DOWN_ROW: + channel->toneslide = -entry->effectvalue; + channel->okt_toneslide = + (entry->effect == IT_OKT_NOTE_SLIDE_DOWN) ? 255 : 1; + break; - case IT_OKT_NOTE_SLIDE_UP: - case IT_OKT_NOTE_SLIDE_UP_ROW: - channel->toneslide = entry->effectvalue; - channel->okt_toneslide = (entry->effect == IT_OKT_NOTE_SLIDE_UP) ? 255 : 1; - break; + case IT_OKT_NOTE_SLIDE_UP: + case IT_OKT_NOTE_SLIDE_UP_ROW: + channel->toneslide = entry->effectvalue; + channel->okt_toneslide = + (entry->effect == IT_OKT_NOTE_SLIDE_UP) ? 255 : 1; + break; - case IT_OKT_ARPEGGIO_3: - case IT_OKT_ARPEGGIO_4: - case IT_OKT_ARPEGGIO_5: - { - channel->arpeggio_offsets[0] = 0; - channel->arpeggio_offsets[1] = -(entry->effectvalue >> 4); - channel->arpeggio_offsets[2] = entry->effectvalue & 0x0F; + case IT_OKT_ARPEGGIO_3: + case IT_OKT_ARPEGGIO_4: + case IT_OKT_ARPEGGIO_5: { + channel->arpeggio_offsets[0] = 0; + channel->arpeggio_offsets[1] = -(entry->effectvalue >> 4); + channel->arpeggio_offsets[2] = entry->effectvalue & 0x0F; - switch (entry->effect) - { - case IT_OKT_ARPEGGIO_3: - channel->arpeggio_table = (const unsigned char *)&arpeggio_okt_3; - break; + switch (entry->effect) { + case IT_OKT_ARPEGGIO_3: + channel->arpeggio_table = + (const unsigned char *)&arpeggio_okt_3; + break; - case IT_OKT_ARPEGGIO_4: - channel->arpeggio_table = (const unsigned char *)&arpeggio_okt_4; - break; + case IT_OKT_ARPEGGIO_4: + channel->arpeggio_table = + (const unsigned char *)&arpeggio_okt_4; + break; - case IT_OKT_ARPEGGIO_5: - channel->arpeggio_table = (const unsigned char *)&arpeggio_okt_5; - break; - } - } - break; + case IT_OKT_ARPEGGIO_5: + channel->arpeggio_table = + (const unsigned char *)&arpeggio_okt_5; + break; + } + } break; - case IT_OKT_VOLUME_SLIDE_DOWN: - if ( entry->effectvalue <= 16 ) channel->volslide = -entry->effectvalue; - else - { - channel->volume -= entry->effectvalue - 16; - if (channel->volume > 64) channel->volume = 0; - } - break; + case IT_OKT_VOLUME_SLIDE_DOWN: + if (entry->effectvalue <= 16) + channel->volslide = -entry->effectvalue; + else { + channel->volume -= entry->effectvalue - 16; + if (channel->volume > 64) + channel->volume = 0; + } + break; - case IT_OKT_VOLUME_SLIDE_UP: - if ( entry->effectvalue <= 16 ) channel->volslide = entry->effectvalue; - else - { - channel->volume += entry->effectvalue - 16; - if (channel->volume > 64) channel->volume = 64; - } - break; - } - } + case IT_OKT_VOLUME_SLIDE_UP: + if (entry->effectvalue <= 16) + channel->volslide = entry->effectvalue; + else { + channel->volume += entry->effectvalue - 16; + if (channel->volume > 64) + channel->volume = 64; + } + break; + } + } - if (!(sigdata->flags & IT_WAS_AN_XM)) - post_process_it_volpan(sigrenderer, entry); + if (!(sigdata->flags & IT_WAS_AN_XM)) + post_process_it_volpan(sigrenderer, entry); - return 0; + return 0; } +static int process_it_note_data(DUMB_IT_SIGRENDERER *sigrenderer, + IT_ENTRY *entry) { + DUMB_IT_SIGDATA *sigdata = sigrenderer->sigdata; + IT_CHANNEL *channel = &sigrenderer->channel[(int)entry->channel]; + // When tone portamento and instrument are specified: + // If Gxx is off: + // - same sample, do nothing but portamento + // - diff sample, retrigger all but keep current note+slide + do porta + // - if instrument is invalid, nothing; if sample is invalid, cut + // If Gxx is on: + // - same sample or new sample invalid, retrigger envelopes and initialise + // note value for portamento to 'seek' to + // - diff sample/inst, start using new envelopes + // When tone portamento is specified alone, sample won't change. + // TODO: consider what happens with instrument alone after all this... -static int process_it_note_data(DUMB_IT_SIGRENDERER *sigrenderer, IT_ENTRY *entry) -{ - DUMB_IT_SIGDATA *sigdata = sigrenderer->sigdata; - IT_CHANNEL *channel = &sigrenderer->channel[(int)entry->channel]; + if (entry->mask & (IT_ENTRY_NOTE | IT_ENTRY_INSTRUMENT)) { + if (entry->mask & IT_ENTRY_INSTRUMENT) + channel->instrument = entry->instrument; + instrument_to_sample(sigdata, channel); + if (channel->note <= 120) { + if ((sigdata->flags & IT_USE_INSTRUMENTS) && channel->sample == 0) + it_retrigger_note(sigrenderer, channel); + /* Stop the note */ /*return 1;*/ + if (entry->mask & IT_ENTRY_INSTRUMENT) + get_default_volpan(sigdata, channel); + } else + it_retrigger_note(sigrenderer, channel); /* Stop the note */ + } - // When tone portamento and instrument are specified: - // If Gxx is off: - // - same sample, do nothing but portamento - // - diff sample, retrigger all but keep current note+slide + do porta - // - if instrument is invalid, nothing; if sample is invalid, cut - // If Gxx is on: - // - same sample or new sample invalid, retrigger envelopes and initialise note value for portamento to 'seek' to - // - diff sample/inst, start using new envelopes - // When tone portamento is specified alone, sample won't change. - // TODO: consider what happens with instrument alone after all this... + /** WARNING: This is not ideal, since channel->playing might not get + * allocated owing to lack of memory... */ + if (((entry->mask & IT_ENTRY_VOLPAN) && entry->volpan >= 193 && + entry->volpan <= 202) || + ((entry->mask & IT_ENTRY_EFFECT) && + (entry->effect == IT_TONE_PORTAMENTO || + entry->effect == IT_VOLSLIDE_TONEPORTA))) { + if (channel->playing && (entry->mask & IT_ENTRY_INSTRUMENT)) { + if (sigdata->flags & IT_COMPATIBLE_GXX) + it_compatible_gxx_retrigger(sigdata, channel); + else if ((!(sigdata->flags & IT_USE_INSTRUMENTS) || + (channel->instrument >= 1 && + channel->instrument <= sigdata->n_instruments)) && + channel->sample != channel->playing->sampnum) { + unsigned char note = channel->playing->note; + int slide = channel->playing->slide; + it_retrigger_note(sigrenderer, channel); + if (channel->playing) { + channel->playing->note = note; + channel->playing->slide = slide; + // Should we be preserving sample_vibrato_time? depth? + } + } + } - if (entry->mask & (IT_ENTRY_NOTE | IT_ENTRY_INSTRUMENT)) { - if (entry->mask & IT_ENTRY_INSTRUMENT) - channel->instrument = entry->instrument; - instrument_to_sample(sigdata, channel); - if (channel->note <= 120) { - if ((sigdata->flags & IT_USE_INSTRUMENTS) && channel->sample == 0) - it_retrigger_note(sigrenderer, channel); /* Stop the note */ /*return 1;*/ - if (entry->mask & IT_ENTRY_INSTRUMENT) - get_default_volpan(sigdata, channel); - } else - it_retrigger_note(sigrenderer, channel); /* Stop the note */ - } + channel->toneporta = 0; - /** WARNING: This is not ideal, since channel->playing might not get allocated owing to lack of memory... */ - if (((entry->mask & IT_ENTRY_VOLPAN) && entry->volpan >= 193 && entry->volpan <= 202) || - ((entry->mask & IT_ENTRY_EFFECT) && (entry->effect == IT_TONE_PORTAMENTO || entry->effect == IT_VOLSLIDE_TONEPORTA))) - { - if (channel->playing && (entry->mask & IT_ENTRY_INSTRUMENT)) { - if (sigdata->flags & IT_COMPATIBLE_GXX) - it_compatible_gxx_retrigger(sigdata, channel); - else if ((!(sigdata->flags & IT_USE_INSTRUMENTS) || - (channel->instrument >= 1 && channel->instrument <= sigdata->n_instruments)) && - channel->sample != channel->playing->sampnum) - { - unsigned char note = channel->playing->note; - int slide = channel->playing->slide; - it_retrigger_note(sigrenderer, channel); - if (channel->playing) { - channel->playing->note = note; - channel->playing->slide = slide; - // Should we be preserving sample_vibrato_time? depth? - } - } - } + if ((entry->mask & IT_ENTRY_VOLPAN) && entry->volpan >= 193 && + entry->volpan <= 202) { + /* Tone Portamento in the volume column */ + static const unsigned char slidetable[] = {0, 1, 4, 8, 16, + 32, 64, 96, 128, 255}; + unsigned char v = slidetable[entry->volpan - 193]; + if (sigdata->flags & IT_COMPATIBLE_GXX) { + if (v == 0) + v = channel->lastG; + channel->lastG = v; + } else { + if (v == 0) + v = channel->lastEF; + channel->lastEF = v; + } + channel->toneporta += v << 4; + } - channel->toneporta = 0; + if ((entry->mask & IT_ENTRY_EFFECT) && + (entry->effect == IT_TONE_PORTAMENTO || + entry->effect == IT_VOLSLIDE_TONEPORTA)) { + /* Tone Portamento in the effect column */ + unsigned char v; + if (entry->effect == IT_TONE_PORTAMENTO) + v = entry->effectvalue; + else + v = 0; + if (sigdata->flags & IT_COMPATIBLE_GXX) { + if (v == 0) + v = channel->lastG; + channel->lastG = v; + } else { + if (v == 0 && !(sigdata->flags & IT_WAS_A_669)) + v = channel->lastEF; + channel->lastEF = v; + } + channel->toneporta += v << 4; + } - if ((entry->mask & IT_ENTRY_VOLPAN) && entry->volpan >= 193 && entry->volpan <= 202) { - /* Tone Portamento in the volume column */ - static const unsigned char slidetable[] = {0, 1, 4, 8, 16, 32, 64, 96, 128, 255}; - unsigned char v = slidetable[entry->volpan - 193]; - if (sigdata->flags & IT_COMPATIBLE_GXX) { - if (v == 0) - v = channel->lastG; - channel->lastG = v; - } else { - if (v == 0) - v = channel->lastEF; - channel->lastEF = v; - } - channel->toneporta += v << 4; - } + if ((entry->mask & IT_ENTRY_NOTE) || + ((sigdata->flags & IT_COMPATIBLE_GXX) && + (entry->mask & IT_ENTRY_INSTRUMENT))) { + if (channel->note <= 120) { + if (channel->sample) + channel->destnote = channel->truenote; + else + channel->destnote = channel->note; + } + } - if ((entry->mask & IT_ENTRY_EFFECT) && (entry->effect == IT_TONE_PORTAMENTO || entry->effect == IT_VOLSLIDE_TONEPORTA)) { - /* Tone Portamento in the effect column */ - unsigned char v; - if (entry->effect == IT_TONE_PORTAMENTO) - v = entry->effectvalue; - else - v = 0; - if (sigdata->flags & IT_COMPATIBLE_GXX) { - if (v == 0) - v = channel->lastG; - channel->lastG = v; - } else { - if (v == 0 && !(sigdata->flags & IT_WAS_A_669)) - v = channel->lastEF; - channel->lastEF = v; - } - channel->toneporta += v << 4; - } + if (channel->playing) + goto skip_start_note; + } - if ((entry->mask & IT_ENTRY_NOTE) || ((sigdata->flags & IT_COMPATIBLE_GXX) && (entry->mask & IT_ENTRY_INSTRUMENT))) { - if (channel->note <= 120) { - if (channel->sample) - channel->destnote = channel->truenote; - else - channel->destnote = channel->note; - } - } + if ((entry->mask & IT_ENTRY_NOTE) || + ((entry->mask & IT_ENTRY_INSTRUMENT) && + (!channel->playing || + entry->instrument != channel->playing->instnum))) { + if (channel->note <= 120) { + get_true_pan(sigdata, channel); + if ((entry->mask & IT_ENTRY_NOTE) || + !(sigdata->flags & (IT_WAS_AN_S3M | IT_WAS_A_PTM))) + it_retrigger_note(sigrenderer, channel); + } + } - if (channel->playing) goto skip_start_note; - } +skip_start_note: - if ((entry->mask & IT_ENTRY_NOTE) || - ((entry->mask & IT_ENTRY_INSTRUMENT) && (!channel->playing || entry->instrument != channel->playing->instnum))) - { - if (channel->note <= 120) { - get_true_pan(sigdata, channel); - if ((entry->mask & IT_ENTRY_NOTE) || !(sigdata->flags & (IT_WAS_AN_S3M|IT_WAS_A_PTM))) - it_retrigger_note(sigrenderer, channel); - } - } - - skip_start_note: - - if (entry->mask & IT_ENTRY_VOLPAN) { - if (entry->volpan <= 64) { - /* Volume */ - channel->volume = entry->volpan; - } else if (entry->volpan <= 74) { - /* Fine volume slide up */ - unsigned char v = entry->volpan - 65; - if (v == 0) - v = channel->lastvolslide; - channel->lastvolslide = v; - /* = effect DxF where x == entry->volpan - 65 */ - channel->volume += v; - if (channel->volume > 64) channel->volume = 64; - } else if (entry->volpan <= 84) { - /* Fine volume slide down */ - unsigned char v = entry->volpan - 75; - if (v == 0) - v = channel->lastvolslide; - channel->lastvolslide = v; - /* = effect DFx where x == entry->volpan - 75 */ - channel->volume -= v; - if (channel->volume > 64) channel->volume = 0; - } else if (entry->volpan < 128) { - /* Volume slide up */ - /* Volume slide down */ - /* Portamento down */ - /* Portamento up */ - } else if (entry->volpan <= 192) { - /* Pan */ - channel->pan = entry->volpan - 128; - channel->truepan = channel->pan << IT_ENVELOPE_SHIFT; - } - /* else */ - /* Tone Portamento */ - /* Vibrato */ - } - return 0; + if (entry->mask & IT_ENTRY_VOLPAN) { + if (entry->volpan <= 64) { + /* Volume */ + channel->volume = entry->volpan; + } else if (entry->volpan <= 74) { + /* Fine volume slide up */ + unsigned char v = entry->volpan - 65; + if (v == 0) + v = channel->lastvolslide; + channel->lastvolslide = v; + /* = effect DxF where x == entry->volpan - 65 */ + channel->volume += v; + if (channel->volume > 64) + channel->volume = 64; + } else if (entry->volpan <= 84) { + /* Fine volume slide down */ + unsigned char v = entry->volpan - 75; + if (v == 0) + v = channel->lastvolslide; + channel->lastvolslide = v; + /* = effect DFx where x == entry->volpan - 75 */ + channel->volume -= v; + if (channel->volume > 64) + channel->volume = 0; + } else if (entry->volpan < 128) { + /* Volume slide up */ + /* Volume slide down */ + /* Portamento down */ + /* Portamento up */ + } else if (entry->volpan <= 192) { + /* Pan */ + channel->pan = entry->volpan - 128; + channel->truepan = channel->pan << IT_ENVELOPE_SHIFT; + } + /* else */ + /* Tone Portamento */ + /* Vibrato */ + } + return 0; } - - -static void retrigger_xm_envelopes(IT_PLAYING *playing) -{ - playing->volume_envelope.next_node = 0; - playing->volume_envelope.tick = -1; - playing->pan_envelope.next_node = 0; - playing->pan_envelope.tick = -1; - playing->fadeoutcount = 1024; +static void retrigger_xm_envelopes(IT_PLAYING *playing) { + playing->volume_envelope.next_node = 0; + playing->volume_envelope.tick = -1; + playing->pan_envelope.next_node = 0; + playing->pan_envelope.tick = -1; + playing->fadeoutcount = 1024; } +static void process_xm_note_data(DUMB_IT_SIGRENDERER *sigrenderer, + IT_ENTRY *entry) { + DUMB_IT_SIGDATA *sigdata = sigrenderer->sigdata; + IT_CHANNEL *channel = &sigrenderer->channel[(int)entry->channel]; + IT_PLAYING *playing = NULL; + if (entry->mask & IT_ENTRY_INSTRUMENT) { + int oldsample = channel->sample; + channel->inv_loop_offset = 0; + channel->instrument = entry->instrument; + instrument_to_sample(sigdata, channel); + if (channel->playing && + !((entry->mask & IT_ENTRY_NOTE) && entry->note >= 120) && + !((entry->mask & IT_ENTRY_EFFECT) && + entry->effect == IT_XM_KEY_OFF && entry->effectvalue == 0)) { + playing = dup_playing(channel->playing, channel, channel); + if (!playing) + return; + if (!(sigdata->flags & IT_WAS_A_MOD)) { + /* Retrigger vol/pan envelopes if enabled, and cancel fadeout. + * Also reset vol/pan to that of _original_ instrument. + */ + channel->playing->flags &= + ~(IT_PLAYING_SUSTAINOFF | IT_PLAYING_FADING); + it_playing_update_resamplers(channel->playing); -static void process_xm_note_data(DUMB_IT_SIGRENDERER *sigrenderer, IT_ENTRY *entry) -{ - DUMB_IT_SIGDATA *sigdata = sigrenderer->sigdata; - IT_CHANNEL *channel = &sigrenderer->channel[(int)entry->channel]; - IT_PLAYING * playing = NULL; + channel->volume = channel->playing->sample->default_volume; + channel->truepan = + 32 + channel->playing->sample->default_pan * 64; - if (entry->mask & IT_ENTRY_INSTRUMENT) { - int oldsample = channel->sample; - channel->inv_loop_offset = 0; - channel->instrument = entry->instrument; - instrument_to_sample(sigdata, channel); - if (channel->playing && - !((entry->mask & IT_ENTRY_NOTE) && entry->note >= 120) && - !((entry->mask & IT_ENTRY_EFFECT) && entry->effect == IT_XM_KEY_OFF && entry->effectvalue == 0)) { - playing = dup_playing(channel->playing, channel, channel); - if (!playing) return; - if (!(sigdata->flags & IT_WAS_A_MOD)) { - /* Retrigger vol/pan envelopes if enabled, and cancel fadeout. - * Also reset vol/pan to that of _original_ instrument. - */ - channel->playing->flags &= ~(IT_PLAYING_SUSTAINOFF | IT_PLAYING_FADING); - it_playing_update_resamplers(channel->playing); + retrigger_xm_envelopes(channel->playing); + } else { + /* Switch if sample changed */ + if (oldsample != channel->sample) { + int i; + for (i = 0; i < DUMB_IT_N_NNA_CHANNELS; i++) { + if (!sigrenderer->playing[i]) { + channel->playing->declick_stage = 3; + sigrenderer->playing[i] = channel->playing; + channel->playing = NULL; + break; + } + } - channel->volume = channel->playing->sample->default_volume; - channel->truepan = 32 + channel->playing->sample->default_pan*64; + if (!channel->sample) { + if (channel->playing) { + free_playing(channel->playing); + channel->playing = NULL; + } + } else { + if (channel->playing) { + free_playing(channel->playing); + } + channel->playing = playing; + playing = NULL; + channel->playing->declick_stage = 0; + channel->playing->sampnum = channel->sample; + channel->playing->sample = + &sigdata->sample[channel->sample - 1]; + it_playing_reset_resamplers(channel->playing, 0); + } + } + get_default_volpan(sigdata, channel); + } + } + } - retrigger_xm_envelopes(channel->playing); - } else { - /* Switch if sample changed */ - if (oldsample != channel->sample) { - int i; - for (i = 0; i < DUMB_IT_N_NNA_CHANNELS; i++) { - if (!sigrenderer->playing[i]) { - channel->playing->declick_stage = 3; - sigrenderer->playing[i] = channel->playing; - channel->playing = NULL; - break; - } - } + if (!((entry->mask & IT_ENTRY_EFFECT) && entry->effect == IT_XM_KEY_OFF && + entry->effectvalue == 0) && + (entry->mask & IT_ENTRY_NOTE)) { + if (!(entry->mask & IT_ENTRY_INSTRUMENT)) + instrument_to_sample(sigdata, channel); - if (!channel->sample) { - if (channel->playing) - { - free_playing(channel->playing); - channel->playing = NULL; - } - } else { - if (channel->playing) { - free_playing(channel->playing); - } - channel->playing = playing; - playing = NULL; - channel->playing->declick_stage = 0; - channel->playing->sampnum = channel->sample; - channel->playing->sample = &sigdata->sample[channel->sample-1]; - it_playing_reset_resamplers(channel->playing, 0); - } - } - get_default_volpan(sigdata, channel); - } - } - } + if (channel->note >= 120) + xm_note_off(sigdata, channel); + else if (channel->sample == 0) { + /** If we get here, one of the following is the case: + ** 1. The instrument has never been specified on this channel. + ** 2. The specified instrument is invalid. + ** 3. The instrument has no sample mapped to the selected note. + ** What should happen? + ** + ** Experimentation shows that any existing note stops and cannot + ** be brought back. A subsequent instrument change fixes that. + **/ + if (channel->playing) { + int i; + if (playing) { + free_playing(channel->playing); + channel->playing = playing; + playing = NULL; + } + for (i = 0; i < DUMB_IT_N_NNA_CHANNELS; i++) { + if (!sigrenderer->playing[i]) { + channel->playing->declick_stage = 3; + sigrenderer->playing[i] = channel->playing; + channel->playing = NULL; + break; + } + } + if (channel->playing) { + free_playing(channel->playing); + channel->playing = NULL; + } + } + if (playing) + free_playing(playing); + return; + } else if (channel->playing && (entry->mask & IT_ENTRY_VOLPAN) && + ((entry->volpan >> 4) == 0xF)) { + /* Don't retrigger note; portamento in the volume column. */ + } else if (channel->playing && (entry->mask & IT_ENTRY_EFFECT) && + (entry->effect == IT_TONE_PORTAMENTO || + entry->effect == IT_VOLSLIDE_TONEPORTA)) { + /* Don't retrigger note; portamento in the effects column. */ + } else { + channel->destnote = IT_NOTE_OFF; - if (!((entry->mask & IT_ENTRY_EFFECT) && entry->effect == IT_XM_KEY_OFF && entry->effectvalue == 0) && - (entry->mask & IT_ENTRY_NOTE)) - { - if (!(entry->mask & IT_ENTRY_INSTRUMENT)) - instrument_to_sample(sigdata, channel); + if (!channel->playing) { + channel->playing = new_playing(); + if (!channel->playing) { + if (playing) + free_playing(playing); + return; + } + // Adding the following seems to do the trick for the case where + // a piece starts with an instrument alone and then some notes + // alone. + retrigger_xm_envelopes(channel->playing); + } else if (playing) { + /* volume rampy stuff! move note to NNA */ + int i; + IT_PLAYING *ptemp; + if (playing->sample) + ptemp = playing; + else + ptemp = channel->playing; + if (!ptemp) { + if (playing) + free_playing(playing); + return; + } + playing = NULL; + for (i = 0; i < DUMB_IT_N_NNA_CHANNELS; i++) { + if (!sigrenderer->playing[i]) { + ptemp->declick_stage = 3; + ptemp->flags |= + IT_PLAYING_SUSTAINOFF | IT_PLAYING_FADING; + sigrenderer->playing[i] = ptemp; + ptemp = NULL; + break; + } + } + if (ptemp) + free_playing(ptemp); + } - if (channel->note >= 120) - xm_note_off(sigdata, channel); - else if (channel->sample == 0) { - /** If we get here, one of the following is the case: - ** 1. The instrument has never been specified on this channel. - ** 2. The specified instrument is invalid. - ** 3. The instrument has no sample mapped to the selected note. - ** What should happen? - ** - ** Experimentation shows that any existing note stops and cannot - ** be brought back. A subsequent instrument change fixes that. - **/ - if (channel->playing) { - int i; - if (playing) { - free_playing(channel->playing); - channel->playing = playing; - playing = NULL; - } - for (i = 0; i < DUMB_IT_N_NNA_CHANNELS; i++) { - if (!sigrenderer->playing[i]) { - channel->playing->declick_stage = 3; - sigrenderer->playing[i] = channel->playing; - channel->playing = NULL; - break; - } - } - if (channel->playing) { - free_playing(channel->playing); - channel->playing = NULL; - } - } - if (playing) free_playing(playing); - return; - } else if (channel->playing && (entry->mask & IT_ENTRY_VOLPAN) && ((entry->volpan>>4) == 0xF)) { - /* Don't retrigger note; portamento in the volume column. */ - } else if (channel->playing && - (entry->mask & IT_ENTRY_EFFECT) && - (entry->effect == IT_TONE_PORTAMENTO || - entry->effect == IT_VOLSLIDE_TONEPORTA)) { - /* Don't retrigger note; portamento in the effects column. */ - } else { - channel->destnote = IT_NOTE_OFF; + channel->playing->flags = 0; + channel->playing->resampling_quality = + sigrenderer->resampling_quality; + channel->playing->channel = channel; + channel->playing->sample = &sigdata->sample[channel->sample - 1]; + if (sigdata->flags & IT_USE_INSTRUMENTS) + channel->playing->instrument = + &sigdata->instrument[channel->instrument - 1]; + else + channel->playing->instrument = NULL; + channel->playing->env_instrument = channel->playing->instrument; + channel->playing->sampnum = channel->sample; + channel->playing->instnum = channel->instrument; + channel->playing->declick_stage = 0; + channel->playing->channel_volume = channel->channelvolume; + channel->playing->note = channel->truenote; + channel->playing->enabled_envelopes = 0; + channel->playing->volume_offset = 0; + channel->playing->panning_offset = 0; + // channel->playing->output = channel->output; + if (sigdata->flags & IT_USE_INSTRUMENTS) { + IT_PLAYING *playing = channel->playing; + IT_INSTRUMENT *instrument = playing->instrument; + if (instrument->volume_envelope.flags & IT_ENVELOPE_ON) + playing->enabled_envelopes |= IT_ENV_VOLUME; + if (instrument->pan_envelope.flags & IT_ENVELOPE_ON) + playing->enabled_envelopes |= IT_ENV_PANNING; + // if (instrument->output) playing->output = instrument->output; + } + channel->playing->filter_cutoff = 127; + channel->playing->filter_resonance = 0; + channel->playing->true_filter_cutoff = 127 << 8; + channel->playing->true_filter_resonance = 0; + channel->playing->vibrato_speed = 0; + channel->playing->vibrato_depth = 0; + channel->playing->vibrato_n = 0; + channel->playing->vibrato_time = 0; + channel->playing->vibrato_waveform = 0; + channel->playing->tremolo_speed = 0; + channel->playing->tremolo_depth = 0; + channel->playing->tremolo_time = 0; + channel->playing->tremolo_waveform = 0; + channel->playing->panbrello_speed = 0; + channel->playing->panbrello_depth = 0; + channel->playing->panbrello_time = 0; + channel->playing->panbrello_waveform = 0; + channel->playing->panbrello_random = 0; + channel->playing->sample_vibrato_time = 0; + channel->playing->sample_vibrato_waveform = + channel->playing->sample->vibrato_waveform; + channel->playing->sample_vibrato_depth = 0; + channel->playing->slide = 0; + channel->playing->finetune = channel->playing->sample->finetune; + it_reset_filter_state( + &channel->playing->filter_state[0]); // Are these + it_reset_filter_state( + &channel->playing->filter_state[1]); // necessary? + it_playing_reset_resamplers(channel->playing, 0); - if (!channel->playing) { - channel->playing = new_playing(); - if (!channel->playing) { - if (playing) free_playing(playing); - return; - } - // Adding the following seems to do the trick for the case where a piece starts with an instrument alone and then some notes alone. - retrigger_xm_envelopes(channel->playing); - } - else if (playing) { - /* volume rampy stuff! move note to NNA */ - int i; - IT_PLAYING * ptemp; - if (playing->sample) ptemp = playing; - else ptemp = channel->playing; - if (!ptemp) { - if (playing) free_playing(playing); - return; - } - playing = NULL; - for (i = 0; i < DUMB_IT_N_NNA_CHANNELS; i++) { - if (!sigrenderer->playing[i]) { - ptemp->declick_stage = 3; - ptemp->flags |= IT_PLAYING_SUSTAINOFF | IT_PLAYING_FADING; - sigrenderer->playing[i] = ptemp; - ptemp = NULL; - break; - } - } - if (ptemp) free_playing(ptemp); - } + /** WARNING - is everything initialised? */ + } + } - channel->playing->flags = 0; - channel->playing->resampling_quality = sigrenderer->resampling_quality; - channel->playing->channel = channel; - channel->playing->sample = &sigdata->sample[channel->sample-1]; - if (sigdata->flags & IT_USE_INSTRUMENTS) - channel->playing->instrument = &sigdata->instrument[channel->instrument-1]; - else - channel->playing->instrument = NULL; - channel->playing->env_instrument = channel->playing->instrument; - channel->playing->sampnum = channel->sample; - channel->playing->instnum = channel->instrument; - channel->playing->declick_stage = 0; - channel->playing->channel_volume = channel->channelvolume; - channel->playing->note = channel->truenote; - channel->playing->enabled_envelopes = 0; - channel->playing->volume_offset = 0; - channel->playing->panning_offset = 0; - //channel->playing->output = channel->output; - if (sigdata->flags & IT_USE_INSTRUMENTS) { - IT_PLAYING * playing = channel->playing; - IT_INSTRUMENT * instrument = playing->instrument; - if (instrument->volume_envelope.flags & IT_ENVELOPE_ON) playing->enabled_envelopes |= IT_ENV_VOLUME; - if (instrument->pan_envelope.flags & IT_ENVELOPE_ON) playing->enabled_envelopes |= IT_ENV_PANNING; - //if (instrument->output) playing->output = instrument->output; - } - channel->playing->filter_cutoff = 127; - channel->playing->filter_resonance = 0; - channel->playing->true_filter_cutoff = 127 << 8; - channel->playing->true_filter_resonance = 0; - channel->playing->vibrato_speed = 0; - channel->playing->vibrato_depth = 0; - channel->playing->vibrato_n = 0; - channel->playing->vibrato_time = 0; - channel->playing->vibrato_waveform = 0; - channel->playing->tremolo_speed = 0; - channel->playing->tremolo_depth = 0; - channel->playing->tremolo_time = 0; - channel->playing->tremolo_waveform = 0; - channel->playing->panbrello_speed = 0; - channel->playing->panbrello_depth = 0; - channel->playing->panbrello_time = 0; - channel->playing->panbrello_waveform = 0; - channel->playing->panbrello_random = 0; - channel->playing->sample_vibrato_time = 0; - channel->playing->sample_vibrato_waveform = channel->playing->sample->vibrato_waveform; - channel->playing->sample_vibrato_depth = 0; - channel->playing->slide = 0; - channel->playing->finetune = channel->playing->sample->finetune; - it_reset_filter_state(&channel->playing->filter_state[0]); // Are these - it_reset_filter_state(&channel->playing->filter_state[1]); // necessary? - it_playing_reset_resamplers(channel->playing, 0); + if (!((entry->mask & IT_ENTRY_EFFECT) && entry->effect == IT_XM_KEY_OFF && + entry->effectvalue == 0) && + !((entry->mask & IT_ENTRY_NOTE) && entry->note >= 120) && + (entry->mask & (IT_ENTRY_NOTE | IT_ENTRY_INSTRUMENT)) == + (IT_ENTRY_NOTE | IT_ENTRY_INSTRUMENT)) { + if (channel->playing) + retrigger_xm_envelopes(channel->playing); + get_default_volpan(sigdata, channel); + } - /** WARNING - is everything initialised? */ - } - } + if ((entry->mask & IT_ENTRY_VOLPAN) && ((entry->volpan >> 4) == 0xF)) { + /* Tone Portamento */ + unsigned char v = (entry->volpan & 15) << 4; + if (v == 0) + v = channel->lastG; + channel->lastG = v; + if (entry->mask & IT_ENTRY_NOTE) + if (channel->sample && channel->note < 120) + channel->destnote = channel->truenote; + channel->toneporta = v << 4; + } else if ((entry->mask & IT_ENTRY_EFFECT) && + (entry->effect == IT_TONE_PORTAMENTO || + entry->effect == IT_VOLSLIDE_TONEPORTA)) { + unsigned char v; + if (entry->effect == IT_TONE_PORTAMENTO) + v = entry->effectvalue; + else + v = 0; + if (v == 0) + v = channel->lastG; + channel->lastG = v; + if (entry->mask & IT_ENTRY_NOTE) + if (channel->sample && channel->note < 120) + channel->destnote = channel->truenote; + channel->toneporta = v << 4; + } - if (!((entry->mask & IT_ENTRY_EFFECT) && entry->effect == IT_XM_KEY_OFF && entry->effectvalue == 0) && - !((entry->mask & IT_ENTRY_NOTE) && entry->note >= 120) && - (entry->mask & (IT_ENTRY_NOTE | IT_ENTRY_INSTRUMENT)) == (IT_ENTRY_NOTE | IT_ENTRY_INSTRUMENT)) - { - if (channel->playing) retrigger_xm_envelopes(channel->playing); - get_default_volpan(sigdata, channel); - } + if (entry->mask & IT_ENTRY_VOLPAN) { + int effect = entry->volpan >> 4; + int value = entry->volpan & 15; + switch (effect) { + case 0x6: /* Volume slide down */ + channel->xm_volslide = -value; + break; + case 0x7: /* Volume slide up */ + channel->xm_volslide = value; + break; + case 0x8: /* Fine volume slide down */ + channel->volume -= value; + if (channel->volume > 64) + channel->volume = 0; + break; + case 0x9: /* Fine volume slide up */ + channel->volume += value; + if (channel->volume > 64) + channel->volume = 64; + break; + case 0xA: /* Set vibrato speed */ + if (value) + channel->lastHspeed = value; + if (channel->playing) + channel->playing->vibrato_speed = channel->lastHspeed; + break; + case 0xB: /* Vibrato */ + if (value) + channel->lastHdepth = value << 2; /** WARNING: correct ? */ + if (channel->playing) { + channel->playing->vibrato_depth = channel->lastHdepth; + channel->playing->vibrato_speed = channel->lastHspeed; + channel->playing->vibrato_n++; + } + break; + case 0xC: /* Set panning */ + channel->truepan = 32 + value * (17 * 64); + break; + case 0xD: /* Pan slide left */ + /* -128 is a special case for emulating a 'feature' in FT2. + * As soon as effects are processed, it goes hard left. + */ + channel->panslide = value ? -value : -128; + break; + case 0xE: /* Pan slide Right */ + channel->panslide = value; + break; + case 0xF: /* Tone porta */ + break; + default: /* Volume */ + channel->volume = entry->volpan - 0x10; + break; + } + } - if ((entry->mask & IT_ENTRY_VOLPAN) && ((entry->volpan>>4) == 0xF)) { - /* Tone Portamento */ - unsigned char v = (entry->volpan & 15) << 4; - if (v == 0) - v = channel->lastG; - channel->lastG = v; - if (entry->mask & IT_ENTRY_NOTE) - if (channel->sample && channel->note < 120) - channel->destnote = channel->truenote; - channel->toneporta = v << 4; - } else if ((entry->mask & IT_ENTRY_EFFECT) && - (entry->effect == IT_TONE_PORTAMENTO || - entry->effect == IT_VOLSLIDE_TONEPORTA)) { - unsigned char v; - if (entry->effect == IT_TONE_PORTAMENTO) - v = entry->effectvalue; - else - v = 0; - if (v == 0) - v = channel->lastG; - channel->lastG = v; - if (entry->mask & IT_ENTRY_NOTE) - if (channel->sample && channel->note < 120) - channel->destnote = channel->truenote; - channel->toneporta = v << 4; - } - - if (entry->mask & IT_ENTRY_VOLPAN) { - int effect = entry->volpan >> 4; - int value = entry->volpan & 15; - switch (effect) { - case 0x6: /* Volume slide down */ - channel->xm_volslide = -value; - break; - case 0x7: /* Volume slide up */ - channel->xm_volslide = value; - break; - case 0x8: /* Fine volume slide down */ - channel->volume -= value; - if (channel->volume > 64) channel->volume = 0; - break; - case 0x9: /* Fine volume slide up */ - channel->volume += value; - if (channel->volume > 64) channel->volume = 64; - break; - case 0xA: /* Set vibrato speed */ - if (value) - channel->lastHspeed = value; - if (channel->playing) - channel->playing->vibrato_speed = channel->lastHspeed; - break; - case 0xB: /* Vibrato */ - if (value) - channel->lastHdepth = value << 2; /** WARNING: correct ? */ - if (channel->playing) { - channel->playing->vibrato_depth = channel->lastHdepth; - channel->playing->vibrato_speed = channel->lastHspeed; - channel->playing->vibrato_n++; - } - break; - case 0xC: /* Set panning */ - channel->truepan = 32 + value*(17*64); - break; - case 0xD: /* Pan slide left */ - /* -128 is a special case for emulating a 'feature' in FT2. - * As soon as effects are processed, it goes hard left. - */ - channel->panslide = value ? -value : -128; - break; - case 0xE: /* Pan slide Right */ - channel->panslide = value; - break; - case 0xF: /* Tone porta */ - break; - default: /* Volume */ - channel->volume = entry->volpan - 0x10; - break; - } - } - - if (playing) free_playing(playing); + if (playing) + free_playing(playing); } - - /* This function assumes !IT_IS_END_ROW(entry). */ -static int process_note_data(DUMB_IT_SIGRENDERER *sigrenderer, IT_ENTRY *entry, int ignore_cxx) -{ - DUMB_IT_SIGDATA *sigdata = sigrenderer->sigdata; +static int process_note_data(DUMB_IT_SIGRENDERER *sigrenderer, IT_ENTRY *entry, + int ignore_cxx) { + DUMB_IT_SIGDATA *sigdata = sigrenderer->sigdata; - if (sigdata->flags & IT_WAS_AN_XM) - process_xm_note_data(sigrenderer, entry); - else - if (process_it_note_data(sigrenderer, entry)) return 0; + if (sigdata->flags & IT_WAS_AN_XM) + process_xm_note_data(sigrenderer, entry); + else if (process_it_note_data(sigrenderer, entry)) + return 0; - return process_effects(sigrenderer, entry, ignore_cxx); + return process_effects(sigrenderer, entry, ignore_cxx); } +static int process_entry(DUMB_IT_SIGRENDERER *sigrenderer, IT_ENTRY *entry, + int ignore_cxx) { + IT_CHANNEL *channel = &sigrenderer->channel[(int)entry->channel]; + if (entry->mask & IT_ENTRY_NOTE) + channel->note = entry->note; -static int process_entry(DUMB_IT_SIGRENDERER *sigrenderer, IT_ENTRY *entry, int ignore_cxx) -{ - IT_CHANNEL *channel = &sigrenderer->channel[(int)entry->channel]; + if ((entry->mask & (IT_ENTRY_NOTE | IT_ENTRY_EFFECT)) && + (sigrenderer->sigdata->flags & IT_WAS_A_669)) { + reset_channel_effects(channel); + // XXX unknown + if (channel->playing) + channel->playing->finetune = 0; + } - if (entry->mask & IT_ENTRY_NOTE) - channel->note = entry->note; + if ((entry->mask & IT_ENTRY_EFFECT) && entry->effect == IT_S) { + /* channel->lastS was set in update_pattern_variables(). */ + unsigned char effectvalue = channel->lastS; + if (effectvalue >> 4 == IT_S_NOTE_DELAY) { + channel->note_delay_count = effectvalue & 15; + if (channel->note_delay_count == 0) + channel->note_delay_count = 1; + channel->note_delay_entry = entry; + return 0; + } + } - if ((entry->mask & (IT_ENTRY_NOTE|IT_ENTRY_EFFECT)) && (sigrenderer->sigdata->flags & IT_WAS_A_669)) { - reset_channel_effects(channel); - // XXX unknown - if (channel->playing) channel->playing->finetune = 0; - } - - if ((entry->mask & IT_ENTRY_EFFECT) && entry->effect == IT_S) { - /* channel->lastS was set in update_pattern_variables(). */ - unsigned char effectvalue = channel->lastS; - if (effectvalue >> 4 == IT_S_NOTE_DELAY) { - channel->note_delay_count = effectvalue & 15; - if (channel->note_delay_count == 0) - channel->note_delay_count = 1; - channel->note_delay_entry = entry; - return 0; - } - } - - return process_note_data(sigrenderer, entry, ignore_cxx); + return process_note_data(sigrenderer, entry, ignore_cxx); } +static void update_tick_counts(DUMB_IT_SIGRENDERER *sigrenderer) { + int i; + for (i = 0; i < DUMB_IT_N_CHANNELS; i++) { + IT_CHANNEL *channel = &sigrenderer->channel[i]; -static void update_tick_counts(DUMB_IT_SIGRENDERER *sigrenderer) -{ - int i; - - for (i = 0; i < DUMB_IT_N_CHANNELS; i++) { - IT_CHANNEL *channel = &sigrenderer->channel[i]; - - if (channel->key_off_count) { - channel->key_off_count--; - if (channel->key_off_count == 0) - xm_note_off(sigrenderer->sigdata, channel); - } else if (channel->note_cut_count) { - channel->note_cut_count--; - if (channel->note_cut_count == 0) { - if (sigrenderer->sigdata->flags & (IT_WAS_AN_XM | IT_WAS_A_PTM)) - channel->volume = 0; - else if (channel->playing) { - int i; - for (i = 0; i < DUMB_IT_N_NNA_CHANNELS; i++) { - if (!sigrenderer->playing[i]) { - channel->playing->declick_stage = 3; - sigrenderer->playing[i] = channel->playing; - channel->playing = NULL; - break; - } - } - if (channel->playing) { - free_playing(channel->playing); - channel->playing = NULL; - } - } - } - } else if (channel->note_delay_count && channel->note_delay_entry) { - channel->note_delay_count--; - if (channel->note_delay_count == 0) - process_note_data(sigrenderer, channel->note_delay_entry, 0); - /* Don't bother checking the return value; if the note - * was delayed, there can't have been a speed=0. - */ - } - } + if (channel->key_off_count) { + channel->key_off_count--; + if (channel->key_off_count == 0) + xm_note_off(sigrenderer->sigdata, channel); + } else if (channel->note_cut_count) { + channel->note_cut_count--; + if (channel->note_cut_count == 0) { + if (sigrenderer->sigdata->flags & (IT_WAS_AN_XM | IT_WAS_A_PTM)) + channel->volume = 0; + else if (channel->playing) { + int i; + for (i = 0; i < DUMB_IT_N_NNA_CHANNELS; i++) { + if (!sigrenderer->playing[i]) { + channel->playing->declick_stage = 3; + sigrenderer->playing[i] = channel->playing; + channel->playing = NULL; + break; + } + } + if (channel->playing) { + free_playing(channel->playing); + channel->playing = NULL; + } + } + } + } else if (channel->note_delay_count && channel->note_delay_entry) { + channel->note_delay_count--; + if (channel->note_delay_count == 0) + process_note_data(sigrenderer, channel->note_delay_entry, 0); + /* Don't bother checking the return value; if the note + * was delayed, there can't have been a speed=0. + */ + } + } } - - -static int envelope_get_y(IT_ENVELOPE *envelope, IT_PLAYING_ENVELOPE *pe) -{ +static int envelope_get_y(IT_ENVELOPE *envelope, IT_PLAYING_ENVELOPE *pe) { #if 1 - (void)envelope; //TODO: remove the parameter - return pe->value; + (void)envelope; // TODO: remove the parameter + return pe->value; #else - int ys, ye; - int ts, te; - int t; + int ys, ye; + int ts, te; + int t; - if (pe->next_node <= 0) - return envelope->node_y[0] << IT_ENVELOPE_SHIFT; + if (pe->next_node <= 0) + return envelope->node_y[0] << IT_ENVELOPE_SHIFT; - if (pe->next_node >= envelope->n_nodes) - return envelope->node_y[envelope->n_nodes-1] << IT_ENVELOPE_SHIFT; + if (pe->next_node >= envelope->n_nodes) + return envelope->node_y[envelope->n_nodes - 1] << IT_ENVELOPE_SHIFT; - ys = envelope->node_y[pe->next_node-1] << IT_ENVELOPE_SHIFT; - ts = envelope->node_t[pe->next_node-1]; - te = envelope->node_t[pe->next_node]; + ys = envelope->node_y[pe->next_node - 1] << IT_ENVELOPE_SHIFT; + ts = envelope->node_t[pe->next_node - 1]; + te = envelope->node_t[pe->next_node]; - if (ts == te) - return ys; + if (ts == te) + return ys; - ye = envelope->node_y[pe->next_node] << IT_ENVELOPE_SHIFT; + ye = envelope->node_y[pe->next_node] << IT_ENVELOPE_SHIFT; - t = pe->tick; + t = pe->tick; - return ys + (ye - ys) * (t - ts) / (te - ts); + return ys + (ye - ys) * (t - ts) / (te - ts); #endif } - - #if 0 static int it_envelope_end(IT_PLAYING *playing, IT_ENVELOPE *envelope, IT_PLAYING_ENVELOPE *pe) { @@ -3858,191 +4147,187 @@ static int it_envelope_end(IT_PLAYING *playing, IT_ENVELOPE *envelope, IT_PLAYIN } #endif - - /* Returns 1 when fading should be initiated for a volume envelope. */ -static int update_it_envelope(IT_PLAYING *playing, IT_ENVELOPE *envelope, IT_PLAYING_ENVELOPE *pe, int flags) -{ - if (!(playing->enabled_envelopes & flags) || !envelope->n_nodes) - return 0; +static int update_it_envelope(IT_PLAYING *playing, IT_ENVELOPE *envelope, + IT_PLAYING_ENVELOPE *pe, int flags) { + if (!(playing->enabled_envelopes & flags) || !envelope->n_nodes) + return 0; - ASSERT(envelope->n_nodes > 0); + ASSERT(envelope->n_nodes > 0); - if (pe->tick <= 0) - pe->value = envelope->node_y[0] << IT_ENVELOPE_SHIFT; - else if (pe->tick >= envelope->node_t[envelope->n_nodes-1]) { - pe->value = envelope->node_y[envelope->n_nodes-1] << IT_ENVELOPE_SHIFT; - } else { - int ys = envelope->node_y[pe->next_node-1] << IT_ENVELOPE_SHIFT; - int ts = envelope->node_t[pe->next_node-1]; - int te = envelope->node_t[pe->next_node]; + if (pe->tick <= 0) + pe->value = envelope->node_y[0] << IT_ENVELOPE_SHIFT; + else if (pe->tick >= envelope->node_t[envelope->n_nodes - 1]) { + pe->value = envelope->node_y[envelope->n_nodes - 1] + << IT_ENVELOPE_SHIFT; + } else { + int ys = envelope->node_y[pe->next_node - 1] << IT_ENVELOPE_SHIFT; + int ts = envelope->node_t[pe->next_node - 1]; + int te = envelope->node_t[pe->next_node]; - if (ts == te) - pe->value = ys; - else { - int ye = envelope->node_y[pe->next_node] << IT_ENVELOPE_SHIFT; - int t = pe->tick; + if (ts == te) + pe->value = ys; + else { + int ye = envelope->node_y[pe->next_node] << IT_ENVELOPE_SHIFT; + int t = pe->tick; - pe->value = ys + (ye - ys) * (t - ts) / (te - ts); - } - } + pe->value = ys + (ye - ys) * (t - ts) / (te - ts); + } + } - pe->tick++; + pe->tick++; - recalculate_it_envelope_node(pe, envelope); + recalculate_it_envelope_node(pe, envelope); - if ((envelope->flags & IT_ENVELOPE_SUSTAIN_LOOP) && !(playing->flags & IT_PLAYING_SUSTAINOFF)) { - if (pe->tick > envelope->node_t[envelope->sus_loop_end]) { - pe->next_node = envelope->sus_loop_start + 1; - ASSERT(pe->next_node <= envelope->n_nodes); - pe->tick = envelope->node_t[envelope->sus_loop_start]; - return 0; - } - } else if (envelope->flags & IT_ENVELOPE_LOOP_ON) { - if (pe->tick > envelope->node_t[envelope->loop_end]) { - pe->next_node = envelope->loop_start + 1; - ASSERT(pe->next_node <= envelope->n_nodes); - pe->tick = envelope->node_t[envelope->loop_start]; - return 0; - } - } - else if (pe->tick > envelope->node_t[envelope->n_nodes - 1]) - return 1; + if ((envelope->flags & IT_ENVELOPE_SUSTAIN_LOOP) && + !(playing->flags & IT_PLAYING_SUSTAINOFF)) { + if (pe->tick > envelope->node_t[envelope->sus_loop_end]) { + pe->next_node = envelope->sus_loop_start + 1; + ASSERT(pe->next_node <= envelope->n_nodes); + pe->tick = envelope->node_t[envelope->sus_loop_start]; + return 0; + } + } else if (envelope->flags & IT_ENVELOPE_LOOP_ON) { + if (pe->tick > envelope->node_t[envelope->loop_end]) { + pe->next_node = envelope->loop_start + 1; + ASSERT(pe->next_node <= envelope->n_nodes); + pe->tick = envelope->node_t[envelope->loop_start]; + return 0; + } + } else if (pe->tick > envelope->node_t[envelope->n_nodes - 1]) + return 1; - return 0; + return 0; } +static void update_it_envelopes(IT_PLAYING *playing) { + IT_ENVELOPE *envelope = &playing->env_instrument->volume_envelope; + IT_PLAYING_ENVELOPE *pe = &playing->volume_envelope; + if (update_it_envelope(playing, envelope, pe, IT_ENV_VOLUME)) { + playing->flags |= IT_PLAYING_FADING; + if (pe->value == 0) + playing->flags |= IT_PLAYING_DEAD; + } -static void update_it_envelopes(IT_PLAYING *playing) -{ - IT_ENVELOPE *envelope = &playing->env_instrument->volume_envelope; - IT_PLAYING_ENVELOPE *pe = &playing->volume_envelope; - - if (update_it_envelope(playing, envelope, pe, IT_ENV_VOLUME)) { - playing->flags |= IT_PLAYING_FADING; - if (pe->value == 0) - playing->flags |= IT_PLAYING_DEAD; - } - - update_it_envelope(playing, &playing->env_instrument->pan_envelope, &playing->pan_envelope, IT_ENV_PANNING); - update_it_envelope(playing, &playing->env_instrument->pitch_envelope, &playing->pitch_envelope, IT_ENV_PITCH); + update_it_envelope(playing, &playing->env_instrument->pan_envelope, + &playing->pan_envelope, IT_ENV_PANNING); + update_it_envelope(playing, &playing->env_instrument->pitch_envelope, + &playing->pitch_envelope, IT_ENV_PITCH); } - - -static int xm_envelope_is_sustaining(IT_PLAYING *playing, IT_ENVELOPE *envelope, IT_PLAYING_ENVELOPE *pe) -{ - if ((envelope->flags & IT_ENVELOPE_SUSTAIN_LOOP) && !(playing->flags & IT_PLAYING_SUSTAINOFF)) - if (envelope->sus_loop_start < envelope->n_nodes) - if (pe->tick == envelope->node_t[envelope->sus_loop_start]) - return 1; - return 0; +static int xm_envelope_is_sustaining(IT_PLAYING *playing, IT_ENVELOPE *envelope, + IT_PLAYING_ENVELOPE *pe) { + if ((envelope->flags & IT_ENVELOPE_SUSTAIN_LOOP) && + !(playing->flags & IT_PLAYING_SUSTAINOFF)) + if (envelope->sus_loop_start < envelope->n_nodes) + if (pe->tick == envelope->node_t[envelope->sus_loop_start]) + return 1; + return 0; } +static void update_xm_envelope(IT_PLAYING *playing, IT_ENVELOPE *envelope, + IT_PLAYING_ENVELOPE *pe) { + if (!(envelope->flags & IT_ENVELOPE_ON)) + return; + if (xm_envelope_is_sustaining(playing, envelope, pe)) + return; -static void update_xm_envelope(IT_PLAYING *playing, IT_ENVELOPE *envelope, IT_PLAYING_ENVELOPE *pe) -{ - if (!(envelope->flags & IT_ENVELOPE_ON)) - return; + if (pe->tick >= envelope->node_t[envelope->n_nodes - 1]) + return; - if (xm_envelope_is_sustaining(playing, envelope, pe)) - return; + pe->tick++; - if (pe->tick >= envelope->node_t[envelope->n_nodes-1]) - return; + /* pe->next_node must be kept up to date for envelope_get_y(). */ + while (pe->tick > envelope->node_t[pe->next_node]) + pe->next_node++; - pe->tick++; + if ((envelope->flags & IT_ENVELOPE_LOOP_ON) && + envelope->loop_end < envelope->n_nodes) { + if (pe->tick == envelope->node_t[envelope->loop_end]) { + pe->next_node = MID(0, envelope->loop_start, envelope->n_nodes - 1); + pe->tick = envelope->node_t[pe->next_node]; + } + } - /* pe->next_node must be kept up to date for envelope_get_y(). */ - while (pe->tick > envelope->node_t[pe->next_node]) - pe->next_node++; - - if ((envelope->flags & IT_ENVELOPE_LOOP_ON) && envelope->loop_end < envelope->n_nodes) { - if (pe->tick == envelope->node_t[envelope->loop_end]) { - pe->next_node = MID(0, envelope->loop_start, envelope->n_nodes - 1); - pe->tick = envelope->node_t[pe->next_node]; - } - } - - xm_envelope_calculate_value(envelope, pe); + xm_envelope_calculate_value(envelope, pe); } - - -static void update_xm_envelopes(IT_PLAYING *playing) -{ - update_xm_envelope(playing, &playing->env_instrument->volume_envelope, &playing->volume_envelope); - update_xm_envelope(playing, &playing->env_instrument->pan_envelope, &playing->pan_envelope); +static void update_xm_envelopes(IT_PLAYING *playing) { + update_xm_envelope(playing, &playing->env_instrument->volume_envelope, + &playing->volume_envelope); + update_xm_envelope(playing, &playing->env_instrument->pan_envelope, + &playing->pan_envelope); } - - -static void update_fadeout(DUMB_IT_SIGDATA *sigdata, IT_PLAYING *playing) -{ - if (playing->flags & IT_PLAYING_FADING) { - playing->fadeoutcount -= playing->env_instrument->fadeout; - if (playing->fadeoutcount <= 0) { - playing->fadeoutcount = 0; - if (!(sigdata->flags & IT_WAS_AN_XM)) - playing->flags |= IT_PLAYING_DEAD; - } - } +static void update_fadeout(DUMB_IT_SIGDATA *sigdata, IT_PLAYING *playing) { + if (playing->flags & IT_PLAYING_FADING) { + playing->fadeoutcount -= playing->env_instrument->fadeout; + if (playing->fadeoutcount <= 0) { + playing->fadeoutcount = 0; + if (!(sigdata->flags & IT_WAS_AN_XM)) + playing->flags |= IT_PLAYING_DEAD; + } + } } static int apply_pan_envelope(IT_PLAYING *playing); -static float calculate_volume(DUMB_IT_SIGRENDERER *sigrenderer, IT_PLAYING *playing, float volume); +static float calculate_volume(DUMB_IT_SIGRENDERER *sigrenderer, + IT_PLAYING *playing, float volume); -static void playing_volume_setup(DUMB_IT_SIGRENDERER * sigrenderer, IT_PLAYING * playing, float invt2g) -{ - DUMB_IT_SIGDATA * sigdata = sigrenderer->sigdata; - int pan; - float vol, span; +static void playing_volume_setup(DUMB_IT_SIGRENDERER *sigrenderer, + IT_PLAYING *playing, float invt2g) { + DUMB_IT_SIGDATA *sigdata = sigrenderer->sigdata; + int pan; + float vol, span; float rampScale; int ramp_style = sigrenderer->ramp_style; - - pan = apply_pan_envelope(playing); - if ((sigrenderer->n_channels >= 2) && (sigdata->flags & IT_STEREO) && (sigrenderer->n_channels != 3 || !IT_IS_SURROUND_SHIFTED(pan))) { - if (!IT_IS_SURROUND_SHIFTED(pan)) { - span = (pan - (32<<8)) * sigdata->pan_separation * (1.0f / ((32<<8) * 128)); - vol = 0.5f * (1.0f - span); - playing->float_volume[0] = vol; - playing->float_volume[1] = 1.0f - vol; - } else { - playing->float_volume[0] = -0.5f; - playing->float_volume[1] = 0.5f; - } - } else { - playing->float_volume[0] = 1.0f; - playing->float_volume[1] = 1.0f; - } + pan = apply_pan_envelope(playing); + + if ((sigrenderer->n_channels >= 2) && (sigdata->flags & IT_STEREO) && + (sigrenderer->n_channels != 3 || !IT_IS_SURROUND_SHIFTED(pan))) { + if (!IT_IS_SURROUND_SHIFTED(pan)) { + span = (pan - (32 << 8)) * sigdata->pan_separation * + (1.0f / ((32 << 8) * 128)); + vol = 0.5f * (1.0f - span); + playing->float_volume[0] = vol; + playing->float_volume[1] = 1.0f - vol; + } else { + playing->float_volume[0] = -0.5f; + playing->float_volume[1] = 0.5f; + } + } else { + playing->float_volume[0] = 1.0f; + playing->float_volume[1] = 1.0f; + } + + vol = calculate_volume(sigrenderer, playing, 1.0f); + playing->float_volume[0] *= vol; + playing->float_volume[1] *= vol; - vol = calculate_volume(sigrenderer, playing, 1.0f); - playing->float_volume[0] *= vol; - playing->float_volume[1] *= vol; - rampScale = 4; if (ramp_style > 0 && playing->declick_stage == 2) { - if ((playing->ramp_volume[0] == 0 && playing->ramp_volume[1] == 0) || vol == 0) + if ((playing->ramp_volume[0] == 0 && playing->ramp_volume[1] == 0) || + vol == 0) rampScale = 48; } if (ramp_style == 0 || (ramp_style < 2 && playing->declick_stage == 2)) { - if (playing->declick_stage <= 2) { - playing->ramp_volume[0] = playing->float_volume[0]; - playing->ramp_volume[1] = playing->float_volume[1]; - playing->declick_stage = 2; - } else { - playing->float_volume[0] = 0; - playing->float_volume[1] = 0; - playing->ramp_volume[0] = 0; - playing->ramp_volume[1] = 0; - playing->declick_stage = 5; - } - playing->ramp_delta[0] = 0; + if (playing->declick_stage <= 2) { + playing->ramp_volume[0] = playing->float_volume[0]; + playing->ramp_volume[1] = playing->float_volume[1]; + playing->declick_stage = 2; + } else { + playing->float_volume[0] = 0; + playing->float_volume[1] = 0; + playing->ramp_volume[0] = 0; + playing->ramp_volume[1] = 0; + playing->declick_stage = 5; + } + playing->ramp_delta[0] = 0; playing->ramp_delta[1] = 0; } else { if (playing->declick_stage == 0) { @@ -4059,49 +4344,54 @@ static void playing_volume_setup(DUMB_IT_SIGRENDERER * sigrenderer, IT_PLAYING * playing->declick_stage++; rampScale = 48; } - playing->ramp_delta[0] = rampScale * invt2g * (playing->float_volume[0] - playing->ramp_volume[0]); - playing->ramp_delta[1] = rampScale * invt2g * (playing->float_volume[1] - playing->ramp_volume[1]); + playing->ramp_delta[0] = + rampScale * invt2g * + (playing->float_volume[0] - playing->ramp_volume[0]); + playing->ramp_delta[1] = + rampScale * invt2g * + (playing->float_volume[1] - playing->ramp_volume[1]); } } -static void process_playing(DUMB_IT_SIGRENDERER *sigrenderer, IT_PLAYING *playing, float invt2g) -{ - DUMB_IT_SIGDATA * sigdata = sigrenderer->sigdata; +static void process_playing(DUMB_IT_SIGRENDERER *sigrenderer, + IT_PLAYING *playing, float invt2g) { + DUMB_IT_SIGDATA *sigdata = sigrenderer->sigdata; - if (playing->instrument) { - if (sigdata->flags & IT_WAS_AN_XM) - update_xm_envelopes(playing); - else - update_it_envelopes(playing); - update_fadeout(sigdata, playing); - } + if (playing->instrument) { + if (sigdata->flags & IT_WAS_AN_XM) + update_xm_envelopes(playing); + else + update_it_envelopes(playing); + update_fadeout(sigdata, playing); + } - playing_volume_setup(sigrenderer, playing, invt2g); + playing_volume_setup(sigrenderer, playing, invt2g); - if (sigdata->flags & IT_WAS_AN_XM) { - /* 'depth' is used to store the tick number for XM files. */ - if (playing->sample_vibrato_depth < playing->sample->vibrato_rate) - playing->sample_vibrato_depth++; - } else { - playing->sample_vibrato_depth += playing->sample->vibrato_rate; - if (playing->sample_vibrato_depth > playing->sample->vibrato_depth << 8) - playing->sample_vibrato_depth = playing->sample->vibrato_depth << 8; - } + if (sigdata->flags & IT_WAS_AN_XM) { + /* 'depth' is used to store the tick number for XM files. */ + if (playing->sample_vibrato_depth < playing->sample->vibrato_rate) + playing->sample_vibrato_depth++; + } else { + playing->sample_vibrato_depth += playing->sample->vibrato_rate; + if (playing->sample_vibrato_depth > playing->sample->vibrato_depth << 8) + playing->sample_vibrato_depth = playing->sample->vibrato_depth << 8; + } - playing->sample_vibrato_time += playing->sample->vibrato_speed; + playing->sample_vibrato_time += playing->sample->vibrato_speed; } #if (defined(_MSC_VER) && _MSC_VER < 1800) || defined(__ANDROID__) -static float log2(float x) {return (float)log(x)/(float)log(2.0f);} +static float log2(float x) { return (float)log(x) / (float)log(2.0f); } #endif -static int delta_to_note(float delta, int base) -{ - float note; - note = log2(delta * 65536.f / (float)base)*12.0f+60.5f; - if (note > 119) note = 119; - else if (note < 0) note = 0; - return (int)note; +static int delta_to_note(float delta, int base) { + float note; + note = log2(delta * 65536.f / (float)base) * 12.0f + 60.5f; + if (note > 119) + note = 119; + else if (note < 0) + note = 0; + return (int)note; } // Period table for Protracker octaves 0-5: @@ -4138,465 +4428,519 @@ static const unsigned short ProTrackerTunedPeriods[16*12] = }; #endif -static void process_all_playing(DUMB_IT_SIGRENDERER *sigrenderer) -{ - DUMB_IT_SIGDATA *sigdata = sigrenderer->sigdata; - int i; +static void process_all_playing(DUMB_IT_SIGRENDERER *sigrenderer) { + DUMB_IT_SIGDATA *sigdata = sigrenderer->sigdata; + int i; - float invt2g = 1.0f / ((float)TICK_TIME_DIVIDEND / (float)sigrenderer->tempo / 256.0f); + float invt2g = + 1.0f / ((float)TICK_TIME_DIVIDEND / (float)sigrenderer->tempo / 256.0f); - for (i = 0; i < DUMB_IT_N_CHANNELS; i++) { - IT_CHANNEL *channel = &sigrenderer->channel[i]; - IT_PLAYING *playing = channel->playing; + for (i = 0; i < DUMB_IT_N_CHANNELS; i++) { + IT_CHANNEL *channel = &sigrenderer->channel[i]; + IT_PLAYING *playing = channel->playing; - if (playing) { - int vibrato_shift; - switch (playing->vibrato_waveform) - { - default: - vibrato_shift = it_sine[playing->vibrato_time]; - break; - case 1: - vibrato_shift = it_sawtooth[playing->vibrato_time]; - break; - case 2: - vibrato_shift = it_squarewave[playing->vibrato_time]; - break; - case 3: - vibrato_shift = (rand() % 129) - 64; - break; - case 4: - vibrato_shift = it_xm_squarewave[playing->vibrato_time]; - break; - case 5: - vibrato_shift = it_xm_ramp[playing->vibrato_time]; - break; - case 6: - vibrato_shift = it_xm_ramp[255-playing->vibrato_time]; - break; - } - vibrato_shift *= playing->vibrato_n; - vibrato_shift *= playing->vibrato_depth; - vibrato_shift >>= 4; + if (playing) { + int vibrato_shift; + switch (playing->vibrato_waveform) { + default: + vibrato_shift = it_sine[playing->vibrato_time]; + break; + case 1: + vibrato_shift = it_sawtooth[playing->vibrato_time]; + break; + case 2: + vibrato_shift = it_squarewave[playing->vibrato_time]; + break; + case 3: + vibrato_shift = (rand() % 129) - 64; + break; + case 4: + vibrato_shift = it_xm_squarewave[playing->vibrato_time]; + break; + case 5: + vibrato_shift = it_xm_ramp[playing->vibrato_time]; + break; + case 6: + vibrato_shift = it_xm_ramp[255 - playing->vibrato_time]; + break; + } + vibrato_shift *= playing->vibrato_n; + vibrato_shift *= playing->vibrato_depth; + vibrato_shift >>= 4; - if (sigdata->flags & IT_OLD_EFFECTS) - vibrato_shift = -vibrato_shift; + if (sigdata->flags & IT_OLD_EFFECTS) + vibrato_shift = -vibrato_shift; - playing->volume = channel->volume; - playing->pan = channel->truepan; + playing->volume = channel->volume; + playing->pan = channel->truepan; - if (playing->volume_offset) { - playing->volume += (playing->volume_offset * playing->volume) >> 7; - if (playing->volume > 64) { - if (playing->volume_offset < 0) playing->volume = 0; - else playing->volume = 64; - } - } + if (playing->volume_offset) { + playing->volume += + (playing->volume_offset * playing->volume) >> 7; + if (playing->volume > 64) { + if (playing->volume_offset < 0) + playing->volume = 0; + else + playing->volume = 64; + } + } - if (playing->panning_offset && !IT_IS_SURROUND_SHIFTED(playing->pan)) { - playing->pan += playing->panning_offset << IT_ENVELOPE_SHIFT; - if (playing->pan > 64 << IT_ENVELOPE_SHIFT) { - if (playing->panning_offset < 0) playing->pan = 0; - else playing->pan = 64 << IT_ENVELOPE_SHIFT; - } - } + if (playing->panning_offset && + !IT_IS_SURROUND_SHIFTED(playing->pan)) { + playing->pan += playing->panning_offset << IT_ENVELOPE_SHIFT; + if (playing->pan > 64 << IT_ENVELOPE_SHIFT) { + if (playing->panning_offset < 0) + playing->pan = 0; + else + playing->pan = 64 << IT_ENVELOPE_SHIFT; + } + } - if (sigdata->flags & IT_LINEAR_SLIDES) { - int currpitch = ((playing->note - 60) << 8) + playing->slide - + vibrato_shift - + playing->finetune; + if (sigdata->flags & IT_LINEAR_SLIDES) { + int currpitch = ((playing->note - 60) << 8) + playing->slide + + vibrato_shift + playing->finetune; - /* We add a feature here, which is that of keeping the pitch - * within range. Otherwise it crashes. Trust me. It happened. - * The limit 32768 gives almost 11 octaves either way. - */ - if (currpitch < -32768) - currpitch = -32768; - else if (currpitch > 32767) - currpitch = 32767; + /* We add a feature here, which is that of keeping the pitch + * within range. Otherwise it crashes. Trust me. It happened. + * The limit 32768 gives almost 11 octaves either way. + */ + if (currpitch < -32768) + currpitch = -32768; + else if (currpitch > 32767) + currpitch = 32767; - playing->delta = (float)pow(DUMB_PITCH_BASE, currpitch); - playing->delta *= playing->sample->C5_speed * (1.f / 65536.0f); - } else { - int slide = playing->slide + vibrato_shift; + playing->delta = (float)pow(DUMB_PITCH_BASE, currpitch); + playing->delta *= playing->sample->C5_speed * (1.f / 65536.0f); + } else { + int slide = playing->slide + vibrato_shift; - playing->delta = (float)pow(DUMB_PITCH_BASE, ((60 - playing->note) << 8) - playing->finetune ); - /* playing->delta is 1.0 for C-5, 0.5 for C-6, etc. */ + playing->delta = + (float)pow(DUMB_PITCH_BASE, + ((60 - playing->note) << 8) - playing->finetune); + /* playing->delta is 1.0 for C-5, 0.5 for C-6, etc. */ - playing->delta *= 1.0f / playing->sample->C5_speed; + playing->delta *= 1.0f / playing->sample->C5_speed; - playing->delta -= slide / AMIGA_DIVISOR; + playing->delta -= slide / AMIGA_DIVISOR; - if (playing->delta < (1.0f / 65536.0f) / 32768.0f) { - // Should XM notes die if Amiga slides go out of range? - playing->flags |= IT_PLAYING_DEAD; - playing->delta = 1. / 32768.; - continue; - } + if (playing->delta < (1.0f / 65536.0f) / 32768.0f) { + // Should XM notes die if Amiga slides go out of range? + playing->flags |= IT_PLAYING_DEAD; + playing->delta = 1. / 32768.; + continue; + } - playing->delta = (1.0f / 65536.0f) / playing->delta; - } + playing->delta = (1.0f / 65536.0f) / playing->delta; + } - if (playing->channel->glissando && playing->channel->toneporta && playing->channel->destnote < 120) { - playing->delta = (float)pow(DUMB_SEMITONE_BASE, delta_to_note(playing->delta, (int)playing->sample->C5_speed) - 60) - * playing->sample->C5_speed * (1.f / 65536.f); - } + if (playing->channel->glissando && playing->channel->toneporta && + playing->channel->destnote < 120) { + playing->delta = + (float)pow(DUMB_SEMITONE_BASE, + delta_to_note(playing->delta, + (int)playing->sample->C5_speed) - + 60) * + playing->sample->C5_speed * (1.f / 65536.f); + } - /* - if ( channel->arpeggio ) { // another FT2 bug... - if ((sigdata->flags & (IT_LINEAR_SLIDES|IT_WAS_AN_XM|IT_WAS_A_MOD)) == (IT_WAS_AN_XM|IT_LINEAR_SLIDES) && - playing->flags & IT_PLAYING_SUSTAINOFF) - { - if ( channel->arpeggio > 0xFF ) - playing->delta = playing->sample->C5_speed * (1.f / 65536.f); - } - else*/ - { - int tick = sigrenderer->tick - 1; - if ((sigrenderer->sigdata->flags & (IT_WAS_AN_XM|IT_WAS_A_MOD))!=IT_WAS_AN_XM) - tick = sigrenderer->speed - tick - 1; - else if (tick == sigrenderer->speed - 1) - tick = 0; - else - ++tick; - if (sigrenderer->sigdata->flags & IT_WAS_AN_STM) - tick /= 16; - playing->delta *= (float)pow(DUMB_SEMITONE_BASE, channel->arpeggio_offsets[channel->arpeggio_table[tick&31]]); - } - /* - }*/ + /* + if ( channel->arpeggio ) { // another FT2 bug... + if ((sigdata->flags & + (IT_LINEAR_SLIDES|IT_WAS_AN_XM|IT_WAS_A_MOD)) == + (IT_WAS_AN_XM|IT_LINEAR_SLIDES) && playing->flags & + IT_PLAYING_SUSTAINOFF) + { + if ( channel->arpeggio > 0xFF ) + playing->delta = playing->sample->C5_speed * + (1.f / 65536.f); + } + else*/ + { + int tick = sigrenderer->tick - 1; + if ((sigrenderer->sigdata->flags & + (IT_WAS_AN_XM | IT_WAS_A_MOD)) != IT_WAS_AN_XM) + tick = sigrenderer->speed - tick - 1; + else if (tick == sigrenderer->speed - 1) + tick = 0; + else + ++tick; + if (sigrenderer->sigdata->flags & IT_WAS_AN_STM) + tick /= 16; + playing->delta *= (float)pow( + DUMB_SEMITONE_BASE, + channel + ->arpeggio_offsets[channel->arpeggio_table[tick & 31]]); + } + /* + }*/ - playing->filter_cutoff = channel->filter_cutoff; - playing->filter_resonance = channel->filter_resonance; - } - } + playing->filter_cutoff = channel->filter_cutoff; + playing->filter_resonance = channel->filter_resonance; + } + } - for (i = 0; i < DUMB_IT_N_CHANNELS; i++) { - if (sigrenderer->channel[i].playing) { - process_playing(sigrenderer, sigrenderer->channel[i].playing, invt2g); - if (!(sigdata->flags & IT_WAS_AN_XM)) { - //if ((sigrenderer->channel[i].playing->flags & (IT_PLAYING_BACKGROUND | IT_PLAYING_DEAD)) == (IT_PLAYING_BACKGROUND | IT_PLAYING_DEAD)) { - // This change was made so Gxx would work correctly when a note faded out or whatever. Let's hope nothing else was broken by it. - if (sigrenderer->channel[i].playing->flags & IT_PLAYING_DEAD) { - free_playing(sigrenderer->channel[i].playing); - sigrenderer->channel[i].playing = NULL; - } - } - } - } + for (i = 0; i < DUMB_IT_N_CHANNELS; i++) { + if (sigrenderer->channel[i].playing) { + process_playing(sigrenderer, sigrenderer->channel[i].playing, + invt2g); + if (!(sigdata->flags & IT_WAS_AN_XM)) { + // if ((sigrenderer->channel[i].playing->flags & + // (IT_PLAYING_BACKGROUND | IT_PLAYING_DEAD)) == + // (IT_PLAYING_BACKGROUND | IT_PLAYING_DEAD)) { + // This change was made so Gxx would work correctly when a note + // faded out or whatever. Let's hope nothing else was broken by + // it. + if (sigrenderer->channel[i].playing->flags & IT_PLAYING_DEAD) { + free_playing(sigrenderer->channel[i].playing); + sigrenderer->channel[i].playing = NULL; + } + } + } + } - for (i = 0; i < DUMB_IT_N_NNA_CHANNELS; i++) { - if (sigrenderer->playing[i]) { - process_playing(sigrenderer, sigrenderer->playing[i], invt2g); - if (sigrenderer->playing[i]->flags & IT_PLAYING_DEAD) { - free_playing(sigrenderer->playing[i]); - sigrenderer->playing[i] = NULL; - } - } - } + for (i = 0; i < DUMB_IT_N_NNA_CHANNELS; i++) { + if (sigrenderer->playing[i]) { + process_playing(sigrenderer, sigrenderer->playing[i], invt2g); + if (sigrenderer->playing[i]->flags & IT_PLAYING_DEAD) { + free_playing(sigrenderer->playing[i]); + sigrenderer->playing[i] = NULL; + } + } + } } +static int process_tick(DUMB_IT_SIGRENDERER *sigrenderer) { + DUMB_IT_SIGDATA *sigdata = sigrenderer->sigdata; + if (sigrenderer->tempo < 32 || sigrenderer->tempo > 255) // problematic + return 1; -static int process_tick(DUMB_IT_SIGRENDERER *sigrenderer) -{ - DUMB_IT_SIGDATA *sigdata = sigrenderer->sigdata; - - if ( sigrenderer->tempo < 32 || sigrenderer->tempo > 255 ) // problematic - return 1; + // Set note vol/freq to vol/freq set for each channel - // Set note vol/freq to vol/freq set for each channel - - if (sigrenderer->speed && --sigrenderer->tick == 0) { - reset_tick_counts(sigrenderer); - sigrenderer->tick = sigrenderer->speed; - sigrenderer->rowcount--; - if (sigrenderer->rowcount == 0) { - sigrenderer->rowcount = 1; + if (sigrenderer->speed && --sigrenderer->tick == 0) { + reset_tick_counts(sigrenderer); + sigrenderer->tick = sigrenderer->speed; + sigrenderer->rowcount--; + if (sigrenderer->rowcount == 0) { + sigrenderer->rowcount = 1; #ifdef BIT_ARRAY_BULLSHIT - if (sigrenderer->n_rows) - { + if (sigrenderer->n_rows) { #if 1 - /* - if (bit_array_test(sigrenderer->played, sigrenderer->order * 256 + sigrenderer->row)) - { - if (sigrenderer->callbacks->loop) { - if ((*sigrenderer->callbacks->loop)(sigrenderer->callbacks->loop_data)) - return 1; - bit_array_reset(sigrenderer->played); - if (sigrenderer->speed == 0) - goto speed0; I love goto - } - } - */ + /* + if (bit_array_test(sigrenderer->played, sigrenderer->order * 256 + + sigrenderer->row)) + { + if (sigrenderer->callbacks->loop) { + if + ((*sigrenderer->callbacks->loop)(sigrenderer->callbacks->loop_data)) + return 1; + bit_array_reset(sigrenderer->played); + if (sigrenderer->speed == 0) + goto speed0; I love goto + } + } + */ #endif - bit_array_set(sigrenderer->played, sigrenderer->order * 256 + sigrenderer->row); - { - int n; - for (n = 0; n < DUMB_IT_N_CHANNELS; n++) - { - IT_CHANNEL * channel = &sigrenderer->channel[n]; - if (channel->played_patjump) - { - if (channel->played_patjump_order == sigrenderer->order) - { - bit_array_set(channel->played_patjump, sigrenderer->row); - } - /* - else if ((channel->played_patjump_order & 0x7FFF) == sigrenderer->order) - { - channel->played_patjump_order |= 0x4000; - } - else if ((channel->played_patjump_order & 0x3FFF) == sigrenderer->order) - { - if ((sigdata->flags & (IT_WAS_AN_XM|IT_WAS_A_MOD)) == IT_WAS_AN_XM) - { - joy, was XM, pattern loop bug triggered break to row in same order - bit_array_mask(sigrenderer->played, channel->played_patjump, sigrenderer->order * 256); - } - bit_array_destroy(channel->played_patjump); - channel->played_patjump = 0; - channel->played_patjump_order = 0xFFFE; - } - */ - else - { - bit_array_destroy(channel->played_patjump); - channel->played_patjump = 0; - channel->played_patjump_order = 0xFFFE; - } - } - } - } - } + bit_array_set(sigrenderer->played, + sigrenderer->order * 256 + sigrenderer->row); + { + int n; + for (n = 0; n < DUMB_IT_N_CHANNELS; n++) { + IT_CHANNEL *channel = &sigrenderer->channel[n]; + if (channel->played_patjump) { + if (channel->played_patjump_order == + sigrenderer->order) { + bit_array_set(channel->played_patjump, + sigrenderer->row); + } + /* + else if ((channel->played_patjump_order & 0x7FFF) == + sigrenderer->order) + { + channel->played_patjump_order |= 0x4000; + } + else if ((channel->played_patjump_order & 0x3FFF) == + sigrenderer->order) + { + if ((sigdata->flags & + (IT_WAS_AN_XM|IT_WAS_A_MOD)) == IT_WAS_AN_XM) + { + joy, was XM, pattern loop bug triggered break to row in same order + bit_array_mask(sigrenderer->played, + channel->played_patjump, sigrenderer->order * 256); + } + bit_array_destroy(channel->played_patjump); + channel->played_patjump = 0; + channel->played_patjump_order = 0xFFFE; + } + */ + else { + bit_array_destroy(channel->played_patjump); + channel->played_patjump = 0; + channel->played_patjump_order = 0xFFFE; + } + } + } + } + } #endif - sigrenderer->processrow++; + sigrenderer->processrow++; - if (sigrenderer->processrow >= sigrenderer->n_rows) { - IT_PATTERN *pattern; - int n; - int processorder = sigrenderer->processorder; + if (sigrenderer->processrow >= sigrenderer->n_rows) { + IT_PATTERN *pattern; + int n; + int processorder = sigrenderer->processorder; - if ((sigrenderer->processrow|0xC00) == 0xFFFE + 1) { /* It was incremented above! */ - sigrenderer->processrow = sigrenderer->breakrow; - sigrenderer->breakrow = 0; - for (n = 0; n < DUMB_IT_N_CHANNELS; n++) sigrenderer->channel[n].pat_loop_end_row = 0; - } else { - sigrenderer->processrow = sigrenderer->breakrow; - sigrenderer->breakrow = 0; // XXX lolwut - } + if ((sigrenderer->processrow | 0xC00) == + 0xFFFE + 1) { /* It was incremented above! */ + sigrenderer->processrow = sigrenderer->breakrow; + sigrenderer->breakrow = 0; + for (n = 0; n < DUMB_IT_N_CHANNELS; n++) + sigrenderer->channel[n].pat_loop_end_row = 0; + } else { + sigrenderer->processrow = sigrenderer->breakrow; + sigrenderer->breakrow = 0; // XXX lolwut + } - if (sigrenderer->processorder == 0xFFFF) - sigrenderer->processorder = sigrenderer->order - 1; + if (sigrenderer->processorder == 0xFFFF) + sigrenderer->processorder = sigrenderer->order - 1; - for (;;) { - sigrenderer->processorder++; + for (;;) { + sigrenderer->processorder++; - if (sigrenderer->processorder >= sigdata->n_orders) { - sigrenderer->processorder = sigrenderer->restart_position; - if (sigrenderer->processorder >= sigdata->n_orders) { - /* Restarting beyond end. We'll loop for now. */ - sigrenderer->processorder = -1; - continue; - } - if (sigdata->flags & IT_WAS_AN_OKT) { - /* Reset some things */ - sigrenderer->speed = sigdata->speed; - sigrenderer->tempo = sigdata->tempo; - for (n = 0; n < DUMB_IT_N_CHANNELS; n++) { - xm_note_off(sigdata, &sigrenderer->channel[n]); - } - } - } + if (sigrenderer->processorder >= sigdata->n_orders) { + sigrenderer->processorder = + sigrenderer->restart_position; + if (sigrenderer->processorder >= sigdata->n_orders) { + /* Restarting beyond end. We'll loop for now. */ + sigrenderer->processorder = -1; + continue; + } + if (sigdata->flags & IT_WAS_AN_OKT) { + /* Reset some things */ + sigrenderer->speed = sigdata->speed; + sigrenderer->tempo = sigdata->tempo; + for (n = 0; n < DUMB_IT_N_CHANNELS; n++) { + xm_note_off(sigdata, &sigrenderer->channel[n]); + } + } + } - n = sigdata->order[sigrenderer->processorder]; + n = sigdata->order[sigrenderer->processorder]; - if (n < sigdata->n_patterns) - break; + if (n < sigdata->n_patterns) + break; #ifdef INVALID_ORDERS_END_SONG - if (n != IT_ORDER_SKIP) + if (n != IT_ORDER_SKIP) #else - if (n == IT_ORDER_END) + if (n == IT_ORDER_END) #endif - { - sigrenderer->processorder = sigrenderer->restart_position - 1; - } + { + sigrenderer->processorder = + sigrenderer->restart_position - 1; + } #ifdef BIT_ARRAY_BULLSHIT - /* Fix play tracking and timekeeping for orders containing skip commands */ - for (n = 0; n < 256; n++) { - bit_array_set(sigrenderer->played, sigrenderer->processorder * 256 + n); - timekeeping_array_push(sigrenderer->row_timekeeper, sigrenderer->processorder * 256 + n, sigrenderer->time_played); - timekeeping_array_bump(sigrenderer->row_timekeeper, sigrenderer->processorder * 256 + n); - } + /* Fix play tracking and timekeeping for orders containing + * skip commands */ + for (n = 0; n < 256; n++) { + bit_array_set(sigrenderer->played, + sigrenderer->processorder * 256 + n); + timekeeping_array_push(sigrenderer->row_timekeeper, + sigrenderer->processorder * 256 + + n, + sigrenderer->time_played); + timekeeping_array_bump(sigrenderer->row_timekeeper, + sigrenderer->processorder * 256 + + n); + } #endif - } + } - pattern = &sigdata->pattern[n]; + pattern = &sigdata->pattern[n]; - n = sigrenderer->n_rows; - sigrenderer->n_rows = pattern->n_rows; + n = sigrenderer->n_rows; + sigrenderer->n_rows = pattern->n_rows; - if (sigrenderer->processrow >= sigrenderer->n_rows) - sigrenderer->processrow = 0; + if (sigrenderer->processrow >= sigrenderer->n_rows) + sigrenderer->processrow = 0; -/** WARNING - everything pertaining to a new pattern initialised? */ + /** WARNING - everything pertaining to a new pattern + * initialised? */ - if ( pattern->entry ) { - sigrenderer->entry = sigrenderer->entry_start = pattern->entry; - sigrenderer->entry_end = sigrenderer->entry + pattern->n_entries; - } else { - sigrenderer->entry = sigrenderer->entry_start = 0; - sigrenderer->entry_end = 0; - } + if (pattern->entry) { + sigrenderer->entry = sigrenderer->entry_start = + pattern->entry; + sigrenderer->entry_end = + sigrenderer->entry + pattern->n_entries; + } else { + sigrenderer->entry = sigrenderer->entry_start = 0; + sigrenderer->entry_end = 0; + } - /* If n_rows was 0, we're only just starting. Don't do anything weird here. */ - /* added: process row check, for break to row spooniness */ - if (n && (processorder == 0xFFFF ? sigrenderer->order > sigrenderer->processorder : sigrenderer->order >= sigrenderer->processorder) + /* If n_rows was 0, we're only just starting. Don't do anything + * weird here. */ + /* added: process row check, for break to row spooniness */ + if (n && + (processorder == 0xFFFF + ? sigrenderer->order > sigrenderer->processorder + : sigrenderer->order >= sigrenderer->processorder) #ifdef BIT_ARRAY_BULLSHIT - && bit_array_test(sigrenderer->played, sigrenderer->processorder * 256 + sigrenderer->processrow) + && bit_array_test(sigrenderer->played, + sigrenderer->processorder * 256 + + sigrenderer->processrow) #endif - ) { + ) { #ifdef BIT_ARRAY_BULLSHIT - sigrenderer->looped = 1; + sigrenderer->looped = 1; #endif - if (sigrenderer->callbacks->loop) { - if ((*sigrenderer->callbacks->loop)(sigrenderer->callbacks->loop_data)) - return 1; + if (sigrenderer->callbacks->loop) { + if ((*sigrenderer->callbacks->loop)( + sigrenderer->callbacks->loop_data)) + return 1; #ifdef BIT_ARRAY_BULLSHIT - bit_array_reset(sigrenderer->played); + bit_array_reset(sigrenderer->played); #endif - if (sigrenderer->speed == 0) - goto speed0; /* I love goto */ - } - } - sigrenderer->order = sigrenderer->processorder; + if (sigrenderer->speed == 0) + goto speed0; /* I love goto */ + } + } + sigrenderer->order = sigrenderer->processorder; - n = sigrenderer->processrow; - while (n) { - while (sigrenderer->entry < sigrenderer->entry_end) { - if (IT_IS_END_ROW(sigrenderer->entry)) { - sigrenderer->entry++; - break; - } - sigrenderer->entry++; - } - n--; - } - sigrenderer->row = sigrenderer->processrow; - } else { - if (sigrenderer->entry) { - while (sigrenderer->entry < sigrenderer->entry_end) { - if (IT_IS_END_ROW(sigrenderer->entry)) { - sigrenderer->entry++; - break; - } - sigrenderer->entry++; - } - sigrenderer->row++; - } else { + n = sigrenderer->processrow; + while (n) { + while (sigrenderer->entry < sigrenderer->entry_end) { + if (IT_IS_END_ROW(sigrenderer->entry)) { + sigrenderer->entry++; + break; + } + sigrenderer->entry++; + } + n--; + } + sigrenderer->row = sigrenderer->processrow; + } else { + if (sigrenderer->entry) { + while (sigrenderer->entry < sigrenderer->entry_end) { + if (IT_IS_END_ROW(sigrenderer->entry)) { + sigrenderer->entry++; + break; + } + sigrenderer->entry++; + } + sigrenderer->row++; + } else { #ifdef BIT_ARRAY_BULLSHIT - bit_array_clear(sigrenderer->played, sigrenderer->order * 256); + bit_array_clear(sigrenderer->played, + sigrenderer->order * 256); #endif - sigrenderer->entry = sigrenderer->entry_start; - sigrenderer->row = 0; - } - } + sigrenderer->entry = sigrenderer->entry_start; + sigrenderer->row = 0; + } + } #ifdef BIT_ARRAY_BULLSHIT - if (sigrenderer->looped == 0) { - timekeeping_array_push(sigrenderer->row_timekeeper, sigrenderer->order * 256 + sigrenderer->row, sigrenderer->time_played); - } - timekeeping_array_bump(sigrenderer->row_timekeeper, sigrenderer->order * 256 + sigrenderer->row); + if (sigrenderer->looped == 0) { + timekeeping_array_push(sigrenderer->row_timekeeper, + sigrenderer->order * 256 + + sigrenderer->row, + sigrenderer->time_played); + } + timekeeping_array_bump(sigrenderer->row_timekeeper, + sigrenderer->order * 256 + sigrenderer->row); #endif - if (!(sigdata->flags & IT_WAS_A_669)) - reset_effects(sigrenderer); + if (!(sigdata->flags & IT_WAS_A_669)) + reset_effects(sigrenderer); - if ( sigrenderer->entry ) - { - IT_ENTRY *entry = sigrenderer->entry; - int ignore_cxx = 0; + if (sigrenderer->entry) { + IT_ENTRY *entry = sigrenderer->entry; + int ignore_cxx = 0; - while (entry < sigrenderer->entry_end && !IT_IS_END_ROW(entry)) - ignore_cxx |= update_pattern_variables(sigrenderer, entry++); + while (entry < sigrenderer->entry_end && !IT_IS_END_ROW(entry)) + ignore_cxx |= + update_pattern_variables(sigrenderer, entry++); - entry = sigrenderer->entry; + entry = sigrenderer->entry; - while (entry < sigrenderer->entry_end && !IT_IS_END_ROW(entry)) - if (process_entry(sigrenderer, entry++, sigdata->flags & IT_WAS_AN_XM ? 0 : ignore_cxx)) - return 1; - } + while (entry < sigrenderer->entry_end && !IT_IS_END_ROW(entry)) + if (process_entry( + sigrenderer, entry++, + sigdata->flags & IT_WAS_AN_XM ? 0 : ignore_cxx)) + return 1; + } - if (sigdata->flags & IT_WAS_AN_OKT) - update_effects(sigrenderer); - else if (!(sigdata->flags & IT_OLD_EFFECTS)) - update_smooth_effects(sigrenderer); - } else { - if ( sigrenderer->entry ) - { - IT_ENTRY *entry = sigrenderer->entry; + if (sigdata->flags & IT_WAS_AN_OKT) + update_effects(sigrenderer); + else if (!(sigdata->flags & IT_OLD_EFFECTS)) + update_smooth_effects(sigrenderer); + } else { + if (sigrenderer->entry) { + IT_ENTRY *entry = sigrenderer->entry; - while (entry < sigrenderer->entry_end && !IT_IS_END_ROW(entry)) { - if (entry->mask & IT_ENTRY_EFFECT && entry->effect != IT_SET_SAMPLE_OFFSET) - process_effects(sigrenderer, entry, 0); - /* Don't bother checking the return value; if there - * was a pattern delay, there can't be a speed=0. - */ - entry++; - } - } + while (entry < sigrenderer->entry_end && + !IT_IS_END_ROW(entry)) { + if (entry->mask & IT_ENTRY_EFFECT && + entry->effect != IT_SET_SAMPLE_OFFSET) + process_effects(sigrenderer, entry, 0); + /* Don't bother checking the return value; if there + * was a pattern delay, there can't be a speed=0. + */ + entry++; + } + } - update_effects(sigrenderer); - } - } else { - if ( !(sigdata->flags & IT_WAS_AN_STM) || !(sigrenderer->tick & 15)) { - speed0: - update_effects(sigrenderer); - update_tick_counts(sigrenderer); - } - } + update_effects(sigrenderer); + } + } else { + if (!(sigdata->flags & IT_WAS_AN_STM) || !(sigrenderer->tick & 15)) { + speed0: + update_effects(sigrenderer); + update_tick_counts(sigrenderer); + } + } - if (sigrenderer->globalvolume == 0) { - if (sigrenderer->callbacks->global_volume_zero) { - LONG_LONG t = sigrenderer->gvz_sub_time + ((TICK_TIME_DIVIDEND / (sigrenderer->tempo << 8)) << 16); - sigrenderer->gvz_time += (int)(t >> 16); - sigrenderer->gvz_sub_time = (int)t & 65535; - if (sigrenderer->gvz_time >= 65536 * 12) { + if (sigrenderer->globalvolume == 0) { + if (sigrenderer->callbacks->global_volume_zero) { + LONG_LONG t = + sigrenderer->gvz_sub_time + + ((TICK_TIME_DIVIDEND / (sigrenderer->tempo << 8)) << 16); + sigrenderer->gvz_time += (int)(t >> 16); + sigrenderer->gvz_sub_time = (int)t & 65535; + if (sigrenderer->gvz_time >= 65536 * 12) { #ifdef BIT_ARRAY_BULLSHIT - sigrenderer->looped = 1; + sigrenderer->looped = 1; #endif - if ((*sigrenderer->callbacks->global_volume_zero)(sigrenderer->callbacks->global_volume_zero_data)) - return 1; - } - } - } else { - if (sigrenderer->callbacks->global_volume_zero) { - sigrenderer->gvz_time = 0; - sigrenderer->gvz_sub_time = 0; - } - } + if ((*sigrenderer->callbacks->global_volume_zero)( + sigrenderer->callbacks->global_volume_zero_data)) + return 1; + } + } + } else { + if (sigrenderer->callbacks->global_volume_zero) { + sigrenderer->gvz_time = 0; + sigrenderer->gvz_sub_time = 0; + } + } - process_all_playing(sigrenderer); + process_all_playing(sigrenderer); - { - LONG_LONG t = (TICK_TIME_DIVIDEND / (sigrenderer->tempo << 8)) << 16; - if ( sigrenderer->sigdata->flags & IT_WAS_AN_STM ) { - t /= 16; - } - t += sigrenderer->sub_time_left; - sigrenderer->time_left += (int)(t >> 16); - sigrenderer->sub_time_left = (int)t & 65535; - } + { + LONG_LONG t = (TICK_TIME_DIVIDEND / (sigrenderer->tempo << 8)) << 16; + if (sigrenderer->sigdata->flags & IT_WAS_AN_STM) { + t /= 16; + } + t += sigrenderer->sub_time_left; + sigrenderer->time_left += (int)(t >> 16); + sigrenderer->sub_time_left = (int)t & 65535; + } - return 0; + return 0; } - - int dumb_it_max_to_mix = 64; #if 0 @@ -4614,1510 +4958,1638 @@ static const int aiMODVol[] = }; #endif -static const int aiPTMVolScaled[] = -{ - 0, - 31, 54, 73, 96, 111, 130, 153, 172, - 191, 206, 222, 237, 252, 275, 298, 317, - 336, 351, 370, 386, 401, 416, 428, 443, - 454, 466, 477, 489, 512, 531, 553, 573, - 592, 611, 626, 645, 660, 679, 695, 710, - 725, 740, 756, 767, 782, 798, 809, 820, - 836, 847, 859, 870, 881, 897, 908, 916, - 927, 939, 950, 962, 969, 983, 1005, 1024 -}; +static const int aiPTMVolScaled[] = { + 0, 31, 54, 73, 96, 111, 130, 153, 172, 191, 206, 222, 237, + 252, 275, 298, 317, 336, 351, 370, 386, 401, 416, 428, 443, 454, + 466, 477, 489, 512, 531, 553, 573, 592, 611, 626, 645, 660, 679, + 695, 710, 725, 740, 756, 767, 782, 798, 809, 820, 836, 847, 859, + 870, 881, 897, 908, 916, 927, 939, 950, 962, 969, 983, 1005, 1024}; -static float calculate_volume(DUMB_IT_SIGRENDERER *sigrenderer, IT_PLAYING *playing, float volume) -{ - if (volume != 0) { - int vol; +static float calculate_volume(DUMB_IT_SIGRENDERER *sigrenderer, + IT_PLAYING *playing, float volume) { + if (volume != 0) { + int vol; - if (playing->channel->flags & IT_CHANNEL_MUTED) - return 0; + if (playing->channel->flags & IT_CHANNEL_MUTED) + return 0; - if ((playing->channel->tremor_time & 192) == 128) - return 0; + if ((playing->channel->tremor_time & 192) == 128) + return 0; - switch (playing->tremolo_waveform) - { - default: - vol = it_sine[playing->tremolo_time]; - break; - case 1: - vol = it_sawtooth[playing->tremolo_time]; - break; - case 2: - vol = it_squarewave[playing->tremolo_time]; - break; - case 3: - vol = (rand() % 129) - 64; - break; - case 4: - vol = it_xm_squarewave[playing->tremolo_time]; - break; - case 5: - vol = it_xm_ramp[playing->tremolo_time]; - break; - case 6: - vol = it_xm_ramp[255-((sigrenderer->sigdata->flags & IT_WAS_A_MOD)?playing->vibrato_time:playing->tremolo_time)]; - break; - } - vol *= playing->tremolo_depth; + switch (playing->tremolo_waveform) { + default: + vol = it_sine[playing->tremolo_time]; + break; + case 1: + vol = it_sawtooth[playing->tremolo_time]; + break; + case 2: + vol = it_squarewave[playing->tremolo_time]; + break; + case 3: + vol = (rand() % 129) - 64; + break; + case 4: + vol = it_xm_squarewave[playing->tremolo_time]; + break; + case 5: + vol = it_xm_ramp[playing->tremolo_time]; + break; + case 6: + vol = it_xm_ramp[255 - ((sigrenderer->sigdata->flags & IT_WAS_A_MOD) + ? playing->vibrato_time + : playing->tremolo_time)]; + break; + } + vol *= playing->tremolo_depth; - vol = (playing->volume << 5) + vol; + vol = (playing->volume << 5) + vol; - if (vol <= 0) - return 0; + if (vol <= 0) + return 0; - if (vol > 64 << 5) - vol = 64 << 5; + if (vol > 64 << 5) + vol = 64 << 5; - if ( sigrenderer->sigdata->flags & IT_WAS_A_PTM ) - { - int v = aiPTMVolScaled[ vol >> 5 ]; - if ( vol < 64 << 5 ) - { - int f = vol & ( ( 1 << 5 ) - 1 ); - int f2 = ( 1 << 5 ) - f; - int v2 = aiPTMVolScaled[ ( vol >> 5 ) + 1 ]; - v = ( v * f2 + v2 * f ) >> 5; - } - vol = v << 1; - } + if (sigrenderer->sigdata->flags & IT_WAS_A_PTM) { + int v = aiPTMVolScaled[vol >> 5]; + if (vol < 64 << 5) { + int f = vol & ((1 << 5) - 1); + int f2 = (1 << 5) - f; + int v2 = aiPTMVolScaled[(vol >> 5) + 1]; + v = (v * f2 + v2 * f) >> 5; + } + vol = v << 1; + } - volume *= vol; /* 64 << 5 */ - volume *= playing->sample->global_volume; /* 64 */ - volume *= playing->channel_volume; /* 64 */ - volume *= sigrenderer->globalvolume; /* 128 */ - volume *= sigrenderer->sigdata->mixing_volume; /* 128 */ - volume *= 1.0f / ((64 << 5) * 64.0f * 64.0f * 128.0f * 128.0f); + volume *= vol; /* 64 << 5 */ + volume *= playing->sample->global_volume; /* 64 */ + volume *= playing->channel_volume; /* 64 */ + volume *= sigrenderer->globalvolume; /* 128 */ + volume *= sigrenderer->sigdata->mixing_volume; /* 128 */ + volume *= 1.0f / ((64 << 5) * 64.0f * 64.0f * 128.0f * 128.0f); - if (volume && playing->instrument) { - if (playing->enabled_envelopes & IT_ENV_VOLUME && playing->env_instrument->volume_envelope.n_nodes) { - volume *= envelope_get_y(&playing->env_instrument->volume_envelope, &playing->volume_envelope); - volume *= 1.0f / (64 << IT_ENVELOPE_SHIFT); - } - volume *= playing->instrument->global_volume; /* 128 */ - volume *= playing->fadeoutcount; /* 1024 */ - volume *= 1.0f / (128.0f * 1024.0f); - } - } + if (volume && playing->instrument) { + if (playing->enabled_envelopes & IT_ENV_VOLUME && + playing->env_instrument->volume_envelope.n_nodes) { + volume *= + envelope_get_y(&playing->env_instrument->volume_envelope, + &playing->volume_envelope); + volume *= 1.0f / (64 << IT_ENVELOPE_SHIFT); + } + volume *= playing->instrument->global_volume; /* 128 */ + volume *= playing->fadeoutcount; /* 1024 */ + volume *= 1.0f / (128.0f * 1024.0f); + } + } - return volume; + return volume; } +static int apply_pan_envelope(IT_PLAYING *playing) { + if (playing->pan <= 64 << IT_ENVELOPE_SHIFT) { + int pan; + if (playing->panbrello_depth) { + switch (playing->panbrello_waveform) { + default: + pan = it_sine[playing->panbrello_time]; + break; + case 1: + pan = it_sawtooth[playing->panbrello_time]; + break; + case 2: + pan = it_squarewave[playing->panbrello_time]; + break; + case 3: + pan = playing->panbrello_random; + break; + } + pan *= playing->panbrello_depth << 3; + pan += playing->pan; + if (pan < 0) + pan = 0; + else if (pan > 64 << IT_ENVELOPE_SHIFT) + pan = 64 << IT_ENVELOPE_SHIFT; + } else { + pan = playing->pan; + } -static int apply_pan_envelope(IT_PLAYING *playing) -{ - if (playing->pan <= 64 << IT_ENVELOPE_SHIFT) { - int pan; - if (playing->panbrello_depth) { - switch (playing->panbrello_waveform) { - default: - pan = it_sine[playing->panbrello_time]; - break; - case 1: - pan = it_sawtooth[playing->panbrello_time]; - break; - case 2: - pan = it_squarewave[playing->panbrello_time]; - break; - case 3: - pan = playing->panbrello_random; - break; - } - pan *= playing->panbrello_depth << 3; - - pan += playing->pan; - if (pan < 0) pan = 0; - else if (pan > 64 << IT_ENVELOPE_SHIFT) pan = 64 << IT_ENVELOPE_SHIFT; - } else { - pan = playing->pan; - } - - if (playing->env_instrument && (playing->enabled_envelopes & IT_ENV_PANNING)) { - int p = envelope_get_y(&playing->env_instrument->pan_envelope, &playing->pan_envelope); - if (pan > 32 << IT_ENVELOPE_SHIFT) - p *= (64 << IT_ENVELOPE_SHIFT) - pan; - else - p *= pan; - pan += p >> (5 + IT_ENVELOPE_SHIFT); - } - return pan; - } - return playing->pan; + if (playing->env_instrument && + (playing->enabled_envelopes & IT_ENV_PANNING)) { + int p = envelope_get_y(&playing->env_instrument->pan_envelope, + &playing->pan_envelope); + if (pan > 32 << IT_ENVELOPE_SHIFT) + p *= (64 << IT_ENVELOPE_SHIFT) - pan; + else + p *= pan; + pan += p >> (5 + IT_ENVELOPE_SHIFT); + } + return pan; + } + return playing->pan; } - - /* Note: if a click remover is provided, and store_end_sample is set, then * the end point will be computed twice. This situation should not arise. */ -static long render_playing(DUMB_IT_SIGRENDERER *sigrenderer, IT_PLAYING *playing, float volume, float main_delta, float delta, long pos, long size, sample_t **samples, int store_end_sample, int *left_to_mix) -{ - int bits; +static long render_playing(DUMB_IT_SIGRENDERER *sigrenderer, + IT_PLAYING *playing, float volume, float main_delta, + float delta, long pos, long size, sample_t **samples, + int store_end_sample, int *left_to_mix) { + int bits; - long size_rendered; + long size_rendered; - DUMB_VOLUME_RAMP_INFO lvol, rvol; + DUMB_VOLUME_RAMP_INFO lvol, rvol; - if (playing->flags & IT_PLAYING_DEAD) - return 0; + if (playing->flags & IT_PLAYING_DEAD) + return 0; - if (*left_to_mix <= 0) - volume = 0; + if (*left_to_mix <= 0) + volume = 0; - { - int quality = sigrenderer->resampling_quality; - if (playing->sample->max_resampling_quality >= 0 && quality > playing->sample->max_resampling_quality) - quality = playing->sample->max_resampling_quality; - playing->resampler.quality = quality; - resampler_set_quality(playing->resampler.fir_resampler[0], quality); - resampler_set_quality(playing->resampler.fir_resampler[1], quality); - } + { + int quality = sigrenderer->resampling_quality; + if (playing->sample->max_resampling_quality >= 0 && + quality > playing->sample->max_resampling_quality) + quality = playing->sample->max_resampling_quality; + playing->resampler.quality = quality; + resampler_set_quality(playing->resampler.fir_resampler[0], quality); + resampler_set_quality(playing->resampler.fir_resampler[1], quality); + } - bits = playing->sample->flags & IT_SAMPLE_16BIT ? 16 : 8; + bits = playing->sample->flags & IT_SAMPLE_16BIT ? 16 : 8; - if (volume == 0) { - if (playing->sample->flags & IT_SAMPLE_STEREO) - size_rendered = dumb_resample_n_2_1(bits, &playing->resampler, NULL, size, 0, 0, delta); - else - size_rendered = dumb_resample_n_1_1(bits, &playing->resampler, NULL, size, 0, delta); - } else { - lvol.volume = playing->ramp_volume [0]; - rvol.volume = playing->ramp_volume [1]; - lvol.delta = playing->ramp_delta [0] * main_delta; - rvol.delta = playing->ramp_delta [1] * main_delta; - lvol.target = playing->float_volume [0]; - rvol.target = playing->float_volume [1]; - rvol.mix = lvol.mix = volume; + if (volume == 0) { + if (playing->sample->flags & IT_SAMPLE_STEREO) + size_rendered = dumb_resample_n_2_1(bits, &playing->resampler, NULL, + size, 0, 0, delta); + else + size_rendered = dumb_resample_n_1_1(bits, &playing->resampler, NULL, + size, 0, delta); + } else { + lvol.volume = playing->ramp_volume[0]; + rvol.volume = playing->ramp_volume[1]; + lvol.delta = playing->ramp_delta[0] * main_delta; + rvol.delta = playing->ramp_delta[1] * main_delta; + lvol.target = playing->float_volume[0]; + rvol.target = playing->float_volume[1]; + rvol.mix = lvol.mix = volume; lvol.declick_stage = rvol.declick_stage = playing->declick_stage; - if (sigrenderer->n_channels >= 2) { - if (playing->sample->flags & IT_SAMPLE_STEREO) { - if (sigrenderer->click_remover) { - sample_t click[2]; - dumb_resample_get_current_sample_n_2_2(bits, &playing->resampler, &lvol, &rvol, click); - dumb_record_click(sigrenderer->click_remover[0], pos, click[0]); - dumb_record_click(sigrenderer->click_remover[1], pos, click[1]); - } - size_rendered = dumb_resample_n_2_2(bits, &playing->resampler, samples[0] + pos*2, size, &lvol, &rvol, delta); - if (store_end_sample) { - sample_t click[2]; - dumb_resample_get_current_sample_n_2_2(bits, &playing->resampler, &lvol, &rvol, click); - samples[0][(pos + size_rendered) * 2] = click[0]; - samples[0][(pos + size_rendered) * 2 + 1] = click[1]; - } - if (sigrenderer->click_remover) { - sample_t click[2]; - dumb_resample_get_current_sample_n_2_2(bits, &playing->resampler, &lvol, &rvol, click); - dumb_record_click(sigrenderer->click_remover[0], pos + size_rendered, -click[0]); - dumb_record_click(sigrenderer->click_remover[1], pos + size_rendered, -click[1]); - } - } else { - if (sigrenderer->click_remover) { - sample_t click[2]; - dumb_resample_get_current_sample_n_1_2(bits, &playing->resampler, &lvol, &rvol, click); - dumb_record_click(sigrenderer->click_remover[0], pos, click[0]); - dumb_record_click(sigrenderer->click_remover[1], pos, click[1]); - } - size_rendered = dumb_resample_n_1_2(bits, &playing->resampler, samples[0] + pos*2, size, &lvol, &rvol, delta); - if (store_end_sample) { - sample_t click[2]; - dumb_resample_get_current_sample_n_1_2(bits, &playing->resampler, &lvol, &rvol, click); - samples[0][(pos + size_rendered) * 2] = click[0]; - samples[0][(pos + size_rendered) * 2 + 1] = click[1]; - } - if (sigrenderer->click_remover) { - sample_t click[2]; - dumb_resample_get_current_sample_n_1_2(bits, &playing->resampler, &lvol, &rvol, click); - dumb_record_click(sigrenderer->click_remover[0], pos + size_rendered, -click[0]); - dumb_record_click(sigrenderer->click_remover[1], pos + size_rendered, -click[1]); - } - } - } else { - if (playing->sample->flags & IT_SAMPLE_STEREO) { - if (sigrenderer->click_remover) { - sample_t click; - dumb_resample_get_current_sample_n_2_1(bits, &playing->resampler, &lvol, &rvol, &click); - dumb_record_click(sigrenderer->click_remover[0], pos, click); - } - size_rendered = dumb_resample_n_2_1(bits, &playing->resampler, samples[0] + pos, size, &lvol, &rvol, delta); - if (store_end_sample) - dumb_resample_get_current_sample_n_2_1(bits, &playing->resampler, &lvol, &rvol, &samples[0][pos + size_rendered]); - if (sigrenderer->click_remover) { - sample_t click; - dumb_resample_get_current_sample_n_2_1(bits, &playing->resampler, &lvol, &rvol, &click); - dumb_record_click(sigrenderer->click_remover[0], pos + size_rendered, -click); - } - } else { - if (sigrenderer->click_remover) { - sample_t click; - dumb_resample_get_current_sample_n_1_1(bits, &playing->resampler, &lvol, &click); - dumb_record_click(sigrenderer->click_remover[0], pos, click); - } - size_rendered = dumb_resample_n_1_1(bits, &playing->resampler, samples[0] + pos, size, &lvol, delta); - if (store_end_sample) - dumb_resample_get_current_sample_n_1_1(bits, &playing->resampler, &lvol, &samples[0][pos + size_rendered]); - if (sigrenderer->click_remover) { - sample_t click; - dumb_resample_get_current_sample_n_1_1(bits, &playing->resampler, &lvol, &click); - dumb_record_click(sigrenderer->click_remover[0], pos + size_rendered, -click); - } - } - } - playing->ramp_volume [0] = lvol.volume; - playing->ramp_volume [1] = rvol.volume; - playing->declick_stage = (lvol.declick_stage > rvol.declick_stage) ? lvol.declick_stage : rvol.declick_stage; + if (sigrenderer->n_channels >= 2) { + if (playing->sample->flags & IT_SAMPLE_STEREO) { + if (sigrenderer->click_remover) { + sample_t click[2]; + dumb_resample_get_current_sample_n_2_2( + bits, &playing->resampler, &lvol, &rvol, click); + dumb_record_click(sigrenderer->click_remover[0], pos, + click[0]); + dumb_record_click(sigrenderer->click_remover[1], pos, + click[1]); + } + size_rendered = dumb_resample_n_2_2(bits, &playing->resampler, + samples[0] + pos * 2, size, + &lvol, &rvol, delta); + if (store_end_sample) { + sample_t click[2]; + dumb_resample_get_current_sample_n_2_2( + bits, &playing->resampler, &lvol, &rvol, click); + samples[0][(pos + size_rendered) * 2] = click[0]; + samples[0][(pos + size_rendered) * 2 + 1] = click[1]; + } + if (sigrenderer->click_remover) { + sample_t click[2]; + dumb_resample_get_current_sample_n_2_2( + bits, &playing->resampler, &lvol, &rvol, click); + dumb_record_click(sigrenderer->click_remover[0], + pos + size_rendered, -click[0]); + dumb_record_click(sigrenderer->click_remover[1], + pos + size_rendered, -click[1]); + } + } else { + if (sigrenderer->click_remover) { + sample_t click[2]; + dumb_resample_get_current_sample_n_1_2( + bits, &playing->resampler, &lvol, &rvol, click); + dumb_record_click(sigrenderer->click_remover[0], pos, + click[0]); + dumb_record_click(sigrenderer->click_remover[1], pos, + click[1]); + } + size_rendered = dumb_resample_n_1_2(bits, &playing->resampler, + samples[0] + pos * 2, size, + &lvol, &rvol, delta); + if (store_end_sample) { + sample_t click[2]; + dumb_resample_get_current_sample_n_1_2( + bits, &playing->resampler, &lvol, &rvol, click); + samples[0][(pos + size_rendered) * 2] = click[0]; + samples[0][(pos + size_rendered) * 2 + 1] = click[1]; + } + if (sigrenderer->click_remover) { + sample_t click[2]; + dumb_resample_get_current_sample_n_1_2( + bits, &playing->resampler, &lvol, &rvol, click); + dumb_record_click(sigrenderer->click_remover[0], + pos + size_rendered, -click[0]); + dumb_record_click(sigrenderer->click_remover[1], + pos + size_rendered, -click[1]); + } + } + } else { + if (playing->sample->flags & IT_SAMPLE_STEREO) { + if (sigrenderer->click_remover) { + sample_t click; + dumb_resample_get_current_sample_n_2_1( + bits, &playing->resampler, &lvol, &rvol, &click); + dumb_record_click(sigrenderer->click_remover[0], pos, + click); + } + size_rendered = dumb_resample_n_2_1(bits, &playing->resampler, + samples[0] + pos, size, + &lvol, &rvol, delta); + if (store_end_sample) + dumb_resample_get_current_sample_n_2_1( + bits, &playing->resampler, &lvol, &rvol, + &samples[0][pos + size_rendered]); + if (sigrenderer->click_remover) { + sample_t click; + dumb_resample_get_current_sample_n_2_1( + bits, &playing->resampler, &lvol, &rvol, &click); + dumb_record_click(sigrenderer->click_remover[0], + pos + size_rendered, -click); + } + } else { + if (sigrenderer->click_remover) { + sample_t click; + dumb_resample_get_current_sample_n_1_1( + bits, &playing->resampler, &lvol, &click); + dumb_record_click(sigrenderer->click_remover[0], pos, + click); + } + size_rendered = + dumb_resample_n_1_1(bits, &playing->resampler, + samples[0] + pos, size, &lvol, delta); + if (store_end_sample) + dumb_resample_get_current_sample_n_1_1( + bits, &playing->resampler, &lvol, + &samples[0][pos + size_rendered]); + if (sigrenderer->click_remover) { + sample_t click; + dumb_resample_get_current_sample_n_1_1( + bits, &playing->resampler, &lvol, &click); + dumb_record_click(sigrenderer->click_remover[0], + pos + size_rendered, -click); + } + } + } + playing->ramp_volume[0] = lvol.volume; + playing->ramp_volume[1] = rvol.volume; + playing->declick_stage = (lvol.declick_stage > rvol.declick_stage) + ? lvol.declick_stage + : rvol.declick_stage; if (playing->declick_stage >= 4) playing->flags |= IT_PLAYING_DEAD; - (*left_to_mix)--; - } + (*left_to_mix)--; + } - if (playing->resampler.dir == 0) - playing->flags |= IT_PLAYING_DEAD; + if (playing->resampler.dir == 0) + playing->flags |= IT_PLAYING_DEAD; - return size_rendered; + return size_rendered; } -typedef struct IT_TO_MIX -{ - IT_PLAYING *playing; - float volume; -} -IT_TO_MIX; +typedef struct IT_TO_MIX { + IT_PLAYING *playing; + float volume; +} IT_TO_MIX; +static int it_to_mix_compare(const void *e1, const void *e2) { + if (((const IT_TO_MIX *)e1)->volume > ((const IT_TO_MIX *)e2)->volume) + return -1; + if (((const IT_TO_MIX *)e1)->volume < ((const IT_TO_MIX *)e2)->volume) + return 1; -static int it_to_mix_compare(const void *e1, const void *e2) -{ - if (((const IT_TO_MIX *)e1)->volume > ((const IT_TO_MIX *)e2)->volume) - return -1; - - if (((const IT_TO_MIX *)e1)->volume < ((const IT_TO_MIX *)e2)->volume) - return 1; - - return 0; + return 0; } +static void apply_pitch_modifications(DUMB_IT_SIGDATA *sigdata, + IT_PLAYING *playing, float *delta, + int *cutoff) { + { + int sample_vibrato_shift; + switch (playing->sample_vibrato_waveform) { + default: + sample_vibrato_shift = it_sine[playing->sample_vibrato_time]; + break; + case 1: + sample_vibrato_shift = it_sawtooth[playing->sample_vibrato_time]; + break; + case 2: + sample_vibrato_shift = it_squarewave[playing->sample_vibrato_time]; + break; + case 3: + sample_vibrato_shift = (rand() % 129) - 64; + break; + case 4: + sample_vibrato_shift = + it_xm_squarewave[playing->sample_vibrato_time]; + break; + case 5: + sample_vibrato_shift = it_xm_ramp[playing->sample_vibrato_time]; + break; + case 6: + sample_vibrato_shift = + it_xm_ramp[255 - playing->sample_vibrato_time]; + break; + } + if (sigdata->flags & IT_WAS_AN_XM) { + int depth = playing->sample->vibrato_depth; /* True depth */ + if (playing->sample->vibrato_rate) { + depth *= playing->sample_vibrato_depth; /* Tick number */ + depth /= playing->sample->vibrato_rate; /* XM sweep */ + } + sample_vibrato_shift *= depth; + } else + sample_vibrato_shift *= playing->sample_vibrato_depth >> 8; -static void apply_pitch_modifications(DUMB_IT_SIGDATA *sigdata, IT_PLAYING *playing, float *delta, int *cutoff) -{ - { - int sample_vibrato_shift; - switch (playing->sample_vibrato_waveform) - { - default: - sample_vibrato_shift = it_sine[playing->sample_vibrato_time]; - break; - case 1: - sample_vibrato_shift = it_sawtooth[playing->sample_vibrato_time]; - break; - case 2: - sample_vibrato_shift = it_squarewave[playing->sample_vibrato_time]; - break; - case 3: - sample_vibrato_shift = (rand() % 129) - 64; - break; - case 4: - sample_vibrato_shift = it_xm_squarewave[playing->sample_vibrato_time]; - break; - case 5: - sample_vibrato_shift = it_xm_ramp[playing->sample_vibrato_time]; - break; - case 6: - sample_vibrato_shift = it_xm_ramp[255-playing->sample_vibrato_time]; - break; - } + sample_vibrato_shift >>= 4; - if (sigdata->flags & IT_WAS_AN_XM) { - int depth = playing->sample->vibrato_depth; /* True depth */ - if (playing->sample->vibrato_rate) { - depth *= playing->sample_vibrato_depth; /* Tick number */ - depth /= playing->sample->vibrato_rate; /* XM sweep */ - } - sample_vibrato_shift *= depth; - } else - sample_vibrato_shift *= playing->sample_vibrato_depth >> 8; + if (sample_vibrato_shift) { + if ((sigdata->flags & IT_LINEAR_SLIDES) || + !(sigdata->flags & IT_WAS_AN_XM)) + *delta *= (float)pow(DUMB_PITCH_BASE, sample_vibrato_shift); + else { + /* complicated! */ + float scale = *delta / playing->delta; - sample_vibrato_shift >>= 4; + *delta = (1.0f / 65536.0f) / playing->delta; - if (sample_vibrato_shift) { - if ((sigdata->flags & IT_LINEAR_SLIDES) || !(sigdata->flags & IT_WAS_AN_XM)) - *delta *= (float)pow(DUMB_PITCH_BASE, sample_vibrato_shift); - else { - /* complicated! */ - float scale = *delta / playing->delta; + *delta -= sample_vibrato_shift / AMIGA_DIVISOR; - *delta = (1.0f / 65536.0f) / playing->delta; + if (*delta < (1.0f / 65536.0f) / 32767.0f) { + *delta = (1.0f / 65536.0f) / 32767.0f; + } - *delta -= sample_vibrato_shift / AMIGA_DIVISOR; + *delta = (1.0f / 65536.0f) / *delta * scale; + } + } + } - if (*delta < (1.0f / 65536.0f) / 32767.0f) { - *delta = (1.0f / 65536.0f) / 32767.0f; - } - - *delta = (1.0f / 65536.0f) / *delta * scale; - } - } - } - - if (playing->env_instrument && - (playing->enabled_envelopes & IT_ENV_PITCH)) - { - int p = envelope_get_y(&playing->env_instrument->pitch_envelope, &playing->pitch_envelope); - if (playing->env_instrument->pitch_envelope.flags & IT_ENVELOPE_PITCH_IS_FILTER) - *cutoff = (*cutoff * (p+(32<> (6 + IT_ENVELOPE_SHIFT); - else - *delta *= (float)pow(DUMB_PITCH_BASE, p >> (IT_ENVELOPE_SHIFT - 7)); - } + if (playing->env_instrument && + (playing->enabled_envelopes & IT_ENV_PITCH)) { + int p = envelope_get_y(&playing->env_instrument->pitch_envelope, + &playing->pitch_envelope); + if (playing->env_instrument->pitch_envelope.flags & + IT_ENVELOPE_PITCH_IS_FILTER) + *cutoff = (*cutoff * (p + (32 << IT_ENVELOPE_SHIFT))) >> + (6 + IT_ENVELOPE_SHIFT); + else + *delta *= (float)pow(DUMB_PITCH_BASE, p >> (IT_ENVELOPE_SHIFT - 7)); + } } +static void render_normal(DUMB_IT_SIGRENDERER *sigrenderer, float volume, + float delta, long pos, long size, + sample_t **samples) { + int i; + int n_to_mix = 0; + IT_TO_MIX to_mix[DUMB_IT_TOTAL_CHANNELS]; + int left_to_mix = dumb_it_max_to_mix; -static void render_normal(DUMB_IT_SIGRENDERER *sigrenderer, float volume, float delta, long pos, long size, sample_t **samples) -{ - int i; + sample_t **samples_to_filter = NULL; - int n_to_mix = 0; - IT_TO_MIX to_mix[DUMB_IT_TOTAL_CHANNELS]; - int left_to_mix = dumb_it_max_to_mix; + // int max_output = sigrenderer->max_output; - sample_t **samples_to_filter = NULL; + for (i = 0; i < DUMB_IT_N_CHANNELS; i++) { + if (sigrenderer->channel[i].playing && + !(sigrenderer->channel[i].playing->flags & IT_PLAYING_DEAD)) { + to_mix[n_to_mix].playing = sigrenderer->channel[i].playing; + to_mix[n_to_mix].volume = + volume == 0 + ? 0 + : calculate_volume(sigrenderer, + sigrenderer->channel[i].playing, volume); + n_to_mix++; + } + } - //int max_output = sigrenderer->max_output; + for (i = 0; i < DUMB_IT_N_NNA_CHANNELS; i++) { + if (sigrenderer + ->playing[i]) { /* Won't be dead; it would have been freed. */ + to_mix[n_to_mix].playing = sigrenderer->playing[i]; + to_mix[n_to_mix].volume = + volume == 0 ? 0 + : calculate_volume(sigrenderer, + sigrenderer->playing[i], volume); + n_to_mix++; + } + } - for (i = 0; i < DUMB_IT_N_CHANNELS; i++) { - if (sigrenderer->channel[i].playing && !(sigrenderer->channel[i].playing->flags & IT_PLAYING_DEAD)) { - to_mix[n_to_mix].playing = sigrenderer->channel[i].playing; - to_mix[n_to_mix].volume = volume == 0 ? 0 : calculate_volume(sigrenderer, sigrenderer->channel[i].playing, volume); - n_to_mix++; - } - } + if (volume != 0) + qsort(to_mix, n_to_mix, sizeof(IT_TO_MIX), &it_to_mix_compare); - for (i = 0; i < DUMB_IT_N_NNA_CHANNELS; i++) { - if (sigrenderer->playing[i]) { /* Won't be dead; it would have been freed. */ - to_mix[n_to_mix].playing = sigrenderer->playing[i]; - to_mix[n_to_mix].volume = volume == 0 ? 0 : calculate_volume(sigrenderer, sigrenderer->playing[i], volume); - n_to_mix++; - } - } + for (i = 0; i < n_to_mix; i++) { + IT_PLAYING *playing = to_mix[i].playing; + float note_delta = delta * playing->delta; + int cutoff = playing->filter_cutoff << IT_ENVELOPE_SHIFT; + // int output = min( playing->output, max_output ); - if (volume != 0) - qsort(to_mix, n_to_mix, sizeof(IT_TO_MIX), &it_to_mix_compare); + apply_pitch_modifications(sigrenderer->sigdata, playing, ¬e_delta, + &cutoff); - for (i = 0; i < n_to_mix; i++) { - IT_PLAYING *playing = to_mix[i].playing; - float note_delta = delta * playing->delta; - int cutoff = playing->filter_cutoff << IT_ENVELOPE_SHIFT; - //int output = min( playing->output, max_output ); + if (cutoff != 127 << IT_ENVELOPE_SHIFT || + playing->filter_resonance != 0) { + playing->true_filter_cutoff = cutoff; + playing->true_filter_resonance = playing->filter_resonance; + } - apply_pitch_modifications(sigrenderer->sigdata, playing, ¬e_delta, &cutoff); + if (volume && + (playing->true_filter_cutoff != 127 << IT_ENVELOPE_SHIFT || + playing->true_filter_resonance != 0)) { + if (!samples_to_filter) { + samples_to_filter = + allocate_sample_buffer(sigrenderer->n_channels, size + 1); + if (!samples_to_filter) { + render_playing(sigrenderer, playing, 0, delta, note_delta, + pos, size, NULL, 0, &left_to_mix); + continue; + } + } + { + long size_rendered; + DUMB_CLICK_REMOVER **cr = sigrenderer->click_remover; + dumb_silence(samples_to_filter[0], + sigrenderer->n_channels * (size + 1)); + sigrenderer->click_remover = NULL; + size_rendered = render_playing( + sigrenderer, playing, volume, delta, note_delta, 0, size, + samples_to_filter, 1, &left_to_mix); + sigrenderer->click_remover = cr; + if (sigrenderer->n_channels == 2) { + it_filter(cr ? cr[0] : NULL, &playing->filter_state[0], + samples[0 /*output*/], pos, samples_to_filter[0], + size_rendered, 2, (int)(65536.0f / delta), + playing->true_filter_cutoff, + playing->true_filter_resonance); + it_filter(cr ? cr[1] : NULL, &playing->filter_state[1], + samples[0 /*output*/] + 1, pos, + samples_to_filter[0] + 1, size_rendered, 2, + (int)(65536.0f / delta), + playing->true_filter_cutoff, + playing->true_filter_resonance); + } else { + it_filter(cr ? cr[0] : NULL, &playing->filter_state[0], + samples[0 /*output*/], pos, samples_to_filter[0], + size_rendered, 1, (int)(65536.0f / delta), + playing->true_filter_cutoff, + playing->true_filter_resonance); + } + // FIXME: filtering is not prevented by low left_to_mix! + // FIXME: change 'warning' to 'FIXME' everywhere + } + } else { + it_reset_filter_state(&playing->filter_state[0]); + it_reset_filter_state(&playing->filter_state[1]); + render_playing(sigrenderer, playing, volume, delta, note_delta, pos, + size, samples /*&samples[output]*/, 0, &left_to_mix); + } + } - if (cutoff != 127 << IT_ENVELOPE_SHIFT || playing->filter_resonance != 0) { - playing->true_filter_cutoff = cutoff; - playing->true_filter_resonance = playing->filter_resonance; - } + destroy_sample_buffer(samples_to_filter); - if (volume && (playing->true_filter_cutoff != 127 << IT_ENVELOPE_SHIFT || playing->true_filter_resonance != 0)) { - if (!samples_to_filter) { - samples_to_filter = allocate_sample_buffer(sigrenderer->n_channels, size + 1); - if (!samples_to_filter) { - render_playing(sigrenderer, playing, 0, delta, note_delta, pos, size, NULL, 0, &left_to_mix); - continue; - } - } - { - long size_rendered; - DUMB_CLICK_REMOVER **cr = sigrenderer->click_remover; - dumb_silence(samples_to_filter[0], sigrenderer->n_channels * (size + 1)); - sigrenderer->click_remover = NULL; - size_rendered = render_playing(sigrenderer, playing, volume, delta, note_delta, 0, size, samples_to_filter, 1, &left_to_mix); - sigrenderer->click_remover = cr; - if (sigrenderer->n_channels == 2) { - it_filter(cr ? cr[0] : NULL, &playing->filter_state[0], samples[0 /*output*/], pos, samples_to_filter[0], size_rendered, - 2, (int)(65536.0f/delta), playing->true_filter_cutoff, playing->true_filter_resonance); - it_filter(cr ? cr[1] : NULL, &playing->filter_state[1], samples[0 /*output*/]+1, pos, samples_to_filter[0]+1, size_rendered, - 2, (int)(65536.0f/delta), playing->true_filter_cutoff, playing->true_filter_resonance); - } else { - it_filter(cr ? cr[0] : NULL, &playing->filter_state[0], samples[0 /*output*/], pos, samples_to_filter[0], size_rendered, - 1, (int)(65536.0f/delta), playing->true_filter_cutoff, playing->true_filter_resonance); - } - // FIXME: filtering is not prevented by low left_to_mix! - // FIXME: change 'warning' to 'FIXME' everywhere - } - } else { - it_reset_filter_state(&playing->filter_state[0]); - it_reset_filter_state(&playing->filter_state[1]); - render_playing(sigrenderer, playing, volume, delta, note_delta, pos, size, samples /*&samples[output]*/, 0, &left_to_mix); - } - } + for (i = 0; i < DUMB_IT_N_CHANNELS; i++) { + if (sigrenderer->channel[i].playing) { + // if ((sigrenderer->channel[i].playing->flags & + // (IT_PLAYING_BACKGROUND | IT_PLAYING_DEAD)) == + // (IT_PLAYING_BACKGROUND | IT_PLAYING_DEAD)) { + // This change was made so Gxx would work correctly when a note + // faded out or whatever. Let's hope nothing else was broken by it. + if (sigrenderer->channel[i].playing->flags & IT_PLAYING_DEAD) { + free_playing(sigrenderer->channel[i].playing); + sigrenderer->channel[i].playing = NULL; + } + } + } - destroy_sample_buffer(samples_to_filter); - - for (i = 0; i < DUMB_IT_N_CHANNELS; i++) { - if (sigrenderer->channel[i].playing) { - //if ((sigrenderer->channel[i].playing->flags & (IT_PLAYING_BACKGROUND | IT_PLAYING_DEAD)) == (IT_PLAYING_BACKGROUND | IT_PLAYING_DEAD)) { - // This change was made so Gxx would work correctly when a note faded out or whatever. Let's hope nothing else was broken by it. - if (sigrenderer->channel[i].playing->flags & IT_PLAYING_DEAD) { - free_playing(sigrenderer->channel[i].playing); - sigrenderer->channel[i].playing = NULL; - } - } - } - - for (i = 0; i < DUMB_IT_N_NNA_CHANNELS; i++) { - if (sigrenderer->playing[i]) { - if (sigrenderer->playing[i]->flags & IT_PLAYING_DEAD) { - free_playing(sigrenderer->playing[i]); - sigrenderer->playing[i] = NULL; - } - } - } + for (i = 0; i < DUMB_IT_N_NNA_CHANNELS; i++) { + if (sigrenderer->playing[i]) { + if (sigrenderer->playing[i]->flags & IT_PLAYING_DEAD) { + free_playing(sigrenderer->playing[i]); + sigrenderer->playing[i] = NULL; + } + } + } } +static void render_surround(DUMB_IT_SIGRENDERER *sigrenderer, float volume, + float delta, long pos, long size, + sample_t **samples) { + int i; + int n_to_mix = 0, n_to_mix_surround = 0; + IT_TO_MIX to_mix[DUMB_IT_TOTAL_CHANNELS]; + IT_TO_MIX to_mix_surround[DUMB_IT_TOTAL_CHANNELS]; + int left_to_mix = dumb_it_max_to_mix; -static void render_surround(DUMB_IT_SIGRENDERER *sigrenderer, float volume, float delta, long pos, long size, sample_t **samples) -{ - int i; + int saved_channels = sigrenderer->n_channels; - int n_to_mix = 0, n_to_mix_surround = 0; - IT_TO_MIX to_mix[DUMB_IT_TOTAL_CHANNELS]; - IT_TO_MIX to_mix_surround[DUMB_IT_TOTAL_CHANNELS]; - int left_to_mix = dumb_it_max_to_mix; + sample_t **samples_to_filter = NULL; - int saved_channels = sigrenderer->n_channels; + DUMB_CLICK_REMOVER **saved_cr = sigrenderer->click_remover; - sample_t **samples_to_filter = NULL; + // int max_output = sigrenderer->max_output; - DUMB_CLICK_REMOVER **saved_cr = sigrenderer->click_remover; + for (i = 0; i < DUMB_IT_N_CHANNELS; i++) { + if (sigrenderer->channel[i].playing && + !(sigrenderer->channel[i].playing->flags & IT_PLAYING_DEAD)) { + IT_PLAYING *playing = sigrenderer->channel[i].playing; + IT_TO_MIX *_to_mix = IT_IS_SURROUND_SHIFTED(playing->pan) + ? to_mix_surround + n_to_mix_surround++ + : to_mix + n_to_mix++; + _to_mix->playing = playing; + _to_mix->volume = + volume == 0 ? 0 + : calculate_volume(sigrenderer, playing, volume); + } + } - //int max_output = sigrenderer->max_output; + for (i = 0; i < DUMB_IT_N_NNA_CHANNELS; i++) { + if (sigrenderer + ->playing[i]) { /* Won't be dead; it would have been freed. */ + IT_PLAYING *playing = sigrenderer->playing[i]; + IT_TO_MIX *_to_mix = IT_IS_SURROUND_SHIFTED(playing->pan) + ? to_mix_surround + n_to_mix_surround++ + : to_mix + n_to_mix++; + _to_mix->playing = playing; + _to_mix->volume = + volume == 0 ? 0 + : calculate_volume(sigrenderer, playing, volume); + } + } - for (i = 0; i < DUMB_IT_N_CHANNELS; i++) { - if (sigrenderer->channel[i].playing && !(sigrenderer->channel[i].playing->flags & IT_PLAYING_DEAD)) { - IT_PLAYING *playing = sigrenderer->channel[i].playing; - IT_TO_MIX *_to_mix = IT_IS_SURROUND_SHIFTED(playing->pan) ? to_mix_surround + n_to_mix_surround++ : to_mix + n_to_mix++; - _to_mix->playing = playing; - _to_mix->volume = volume == 0 ? 0 : calculate_volume(sigrenderer, playing, volume); - } - } + if (volume != 0) { + qsort(to_mix, n_to_mix, sizeof(IT_TO_MIX), &it_to_mix_compare); + qsort(to_mix_surround, n_to_mix_surround, sizeof(IT_TO_MIX), + &it_to_mix_compare); + } - for (i = 0; i < DUMB_IT_N_NNA_CHANNELS; i++) { - if (sigrenderer->playing[i]) { /* Won't be dead; it would have been freed. */ - IT_PLAYING *playing = sigrenderer->playing[i]; - IT_TO_MIX *_to_mix = IT_IS_SURROUND_SHIFTED(playing->pan) ? to_mix_surround + n_to_mix_surround++ : to_mix + n_to_mix++; - _to_mix->playing = playing; - _to_mix->volume = volume == 0 ? 0 : calculate_volume(sigrenderer, playing, volume); - } - } + sigrenderer->n_channels = 2; - if (volume != 0) { - qsort(to_mix, n_to_mix, sizeof(IT_TO_MIX), &it_to_mix_compare); - qsort(to_mix_surround, n_to_mix_surround, sizeof(IT_TO_MIX), &it_to_mix_compare); - } + for (i = 0; i < n_to_mix; i++) { + IT_PLAYING *playing = to_mix[i].playing; + float note_delta = delta * playing->delta; + int cutoff = playing->filter_cutoff << IT_ENVELOPE_SHIFT; + // int output = min( playing->output, max_output ); - sigrenderer->n_channels = 2; + apply_pitch_modifications(sigrenderer->sigdata, playing, ¬e_delta, + &cutoff); - for (i = 0; i < n_to_mix; i++) { - IT_PLAYING *playing = to_mix[i].playing; - float note_delta = delta * playing->delta; - int cutoff = playing->filter_cutoff << IT_ENVELOPE_SHIFT; - //int output = min( playing->output, max_output ); + if (cutoff != 127 << IT_ENVELOPE_SHIFT || + playing->filter_resonance != 0) { + playing->true_filter_cutoff = cutoff; + playing->true_filter_resonance = playing->filter_resonance; + } - apply_pitch_modifications(sigrenderer->sigdata, playing, ¬e_delta, &cutoff); + if (volume && + (playing->true_filter_cutoff != 127 << IT_ENVELOPE_SHIFT || + playing->true_filter_resonance != 0)) { + if (!samples_to_filter) { + samples_to_filter = + allocate_sample_buffer(sigrenderer->n_channels, size + 1); + if (!samples_to_filter) { + render_playing(sigrenderer, playing, 0, delta, note_delta, + pos, size, NULL, 0, &left_to_mix); + continue; + } + } + { + long size_rendered; + DUMB_CLICK_REMOVER **cr = sigrenderer->click_remover; + dumb_silence(samples_to_filter[0], + sigrenderer->n_channels * (size + 1)); + sigrenderer->click_remover = NULL; + size_rendered = render_playing( + sigrenderer, playing, volume, delta, note_delta, 0, size, + samples_to_filter, 1, &left_to_mix); + sigrenderer->click_remover = cr; + it_filter(cr ? cr[0] : NULL, &playing->filter_state[0], + samples[0 /*output*/], pos, samples_to_filter[0], + size_rendered, 2, (int)(65536.0f / delta), + playing->true_filter_cutoff, + playing->true_filter_resonance); + it_filter(cr ? cr[1] : NULL, &playing->filter_state[1], + samples[0 /*output*/] + 1, pos, + samples_to_filter[0] + 1, size_rendered, 2, + (int)(65536.0f / delta), playing->true_filter_cutoff, + playing->true_filter_resonance); + } + } else { + it_reset_filter_state(&playing->filter_state[0]); + it_reset_filter_state(&playing->filter_state[1]); + render_playing(sigrenderer, playing, volume, delta, note_delta, pos, + size, samples /*&samples[output]*/, 0, &left_to_mix); + } + } - if (cutoff != 127 << IT_ENVELOPE_SHIFT || playing->filter_resonance != 0) { - playing->true_filter_cutoff = cutoff; - playing->true_filter_resonance = playing->filter_resonance; - } + sigrenderer->n_channels = 1; + sigrenderer->click_remover = saved_cr ? saved_cr + 2 : 0; - if (volume && (playing->true_filter_cutoff != 127 << IT_ENVELOPE_SHIFT || playing->true_filter_resonance != 0)) { - if (!samples_to_filter) { - samples_to_filter = allocate_sample_buffer(sigrenderer->n_channels, size + 1); - if (!samples_to_filter) { - render_playing(sigrenderer, playing, 0, delta, note_delta, pos, size, NULL, 0, &left_to_mix); - continue; - } - } - { - long size_rendered; - DUMB_CLICK_REMOVER **cr = sigrenderer->click_remover; - dumb_silence(samples_to_filter[0], sigrenderer->n_channels * (size + 1)); - sigrenderer->click_remover = NULL; - size_rendered = render_playing(sigrenderer, playing, volume, delta, note_delta, 0, size, samples_to_filter, 1, &left_to_mix); - sigrenderer->click_remover = cr; - it_filter(cr ? cr[0] : NULL, &playing->filter_state[0], samples[0 /*output*/], pos, samples_to_filter[0], size_rendered, - 2, (int)(65536.0f/delta), playing->true_filter_cutoff, playing->true_filter_resonance); - it_filter(cr ? cr[1] : NULL, &playing->filter_state[1], samples[0 /*output*/]+1, pos, samples_to_filter[0]+1, size_rendered, - 2, (int)(65536.0f/delta), playing->true_filter_cutoff, playing->true_filter_resonance); - } - } else { - it_reset_filter_state(&playing->filter_state[0]); - it_reset_filter_state(&playing->filter_state[1]); - render_playing(sigrenderer, playing, volume, delta, note_delta, pos, size, samples /*&samples[output]*/, 0, &left_to_mix); - } - } + for (i = 0; i < n_to_mix_surround; i++) { + IT_PLAYING *playing = to_mix_surround[i].playing; + float note_delta = delta * playing->delta; + int cutoff = playing->filter_cutoff << IT_ENVELOPE_SHIFT; + // int output = min( playing->output, max_output ); - sigrenderer->n_channels = 1; - sigrenderer->click_remover = saved_cr ? saved_cr + 2 : 0; + apply_pitch_modifications(sigrenderer->sigdata, playing, ¬e_delta, + &cutoff); - for (i = 0; i < n_to_mix_surround; i++) { - IT_PLAYING *playing = to_mix_surround[i].playing; - float note_delta = delta * playing->delta; - int cutoff = playing->filter_cutoff << IT_ENVELOPE_SHIFT; - //int output = min( playing->output, max_output ); + if (cutoff != 127 << IT_ENVELOPE_SHIFT || + playing->filter_resonance != 0) { + playing->true_filter_cutoff = cutoff; + playing->true_filter_resonance = playing->filter_resonance; + } - apply_pitch_modifications(sigrenderer->sigdata, playing, ¬e_delta, &cutoff); + if (volume && + (playing->true_filter_cutoff != 127 << IT_ENVELOPE_SHIFT || + playing->true_filter_resonance != 0)) { + if (!samples_to_filter) { + samples_to_filter = + allocate_sample_buffer(sigrenderer->n_channels, size + 1); + if (!samples_to_filter) { + render_playing(sigrenderer, playing, 0, delta, note_delta, + pos, size, NULL, 0, &left_to_mix); + continue; + } + } + { + long size_rendered; + DUMB_CLICK_REMOVER **cr = sigrenderer->click_remover; + dumb_silence(samples_to_filter[0], size + 1); + sigrenderer->click_remover = NULL; + size_rendered = render_playing( + sigrenderer, playing, volume, delta, note_delta, 0, size, + samples_to_filter, 1, &left_to_mix); + sigrenderer->click_remover = cr; + it_filter(cr ? cr[0] : NULL, &playing->filter_state[0], + samples[1 /*output*/], pos, samples_to_filter[0], + size_rendered, 1, (int)(65536.0f / delta), + playing->true_filter_cutoff, + playing->true_filter_resonance); + // FIXME: filtering is not prevented by low left_to_mix! + // FIXME: change 'warning' to 'FIXME' everywhere + } + } else { + it_reset_filter_state(&playing->filter_state[0]); + it_reset_filter_state(&playing->filter_state[1]); + render_playing(sigrenderer, playing, volume, delta, note_delta, pos, + size, &samples[1], 0, &left_to_mix); + } + } - if (cutoff != 127 << IT_ENVELOPE_SHIFT || playing->filter_resonance != 0) { - playing->true_filter_cutoff = cutoff; - playing->true_filter_resonance = playing->filter_resonance; - } + sigrenderer->n_channels = saved_channels; + sigrenderer->click_remover = saved_cr; - if (volume && (playing->true_filter_cutoff != 127 << IT_ENVELOPE_SHIFT || playing->true_filter_resonance != 0)) { - if (!samples_to_filter) { - samples_to_filter = allocate_sample_buffer(sigrenderer->n_channels, size + 1); - if (!samples_to_filter) { - render_playing(sigrenderer, playing, 0, delta, note_delta, pos, size, NULL, 0, &left_to_mix); - continue; - } - } - { - long size_rendered; - DUMB_CLICK_REMOVER **cr = sigrenderer->click_remover; - dumb_silence(samples_to_filter[0], size + 1); - sigrenderer->click_remover = NULL; - size_rendered = render_playing(sigrenderer, playing, volume, delta, note_delta, 0, size, samples_to_filter, 1, &left_to_mix); - sigrenderer->click_remover = cr; - it_filter(cr ? cr[0] : NULL, &playing->filter_state[0], samples[1 /*output*/], pos, samples_to_filter[0], size_rendered, - 1, (int)(65536.0f/delta), playing->true_filter_cutoff, playing->true_filter_resonance); - // FIXME: filtering is not prevented by low left_to_mix! - // FIXME: change 'warning' to 'FIXME' everywhere - } - } else { - it_reset_filter_state(&playing->filter_state[0]); - it_reset_filter_state(&playing->filter_state[1]); - render_playing(sigrenderer, playing, volume, delta, note_delta, pos, size, &samples[1], 0, &left_to_mix); - } - } + destroy_sample_buffer(samples_to_filter); - sigrenderer->n_channels = saved_channels; - sigrenderer->click_remover = saved_cr; + for (i = 0; i < DUMB_IT_N_CHANNELS; i++) { + if (sigrenderer->channel[i].playing) { + // if ((sigrenderer->channel[i].playing->flags & + // (IT_PLAYING_BACKGROUND | IT_PLAYING_DEAD)) == + // (IT_PLAYING_BACKGROUND | IT_PLAYING_DEAD)) { + // This change was made so Gxx would work correctly when a note + // faded out or whatever. Let's hope nothing else was broken by it. + if (sigrenderer->channel[i].playing->flags & IT_PLAYING_DEAD) { + free_playing(sigrenderer->channel[i].playing); + sigrenderer->channel[i].playing = NULL; + } + } + } - destroy_sample_buffer(samples_to_filter); - - for (i = 0; i < DUMB_IT_N_CHANNELS; i++) { - if (sigrenderer->channel[i].playing) { - //if ((sigrenderer->channel[i].playing->flags & (IT_PLAYING_BACKGROUND | IT_PLAYING_DEAD)) == (IT_PLAYING_BACKGROUND | IT_PLAYING_DEAD)) { - // This change was made so Gxx would work correctly when a note faded out or whatever. Let's hope nothing else was broken by it. - if (sigrenderer->channel[i].playing->flags & IT_PLAYING_DEAD) { - free_playing(sigrenderer->channel[i].playing); - sigrenderer->channel[i].playing = NULL; - } - } - } - - for (i = 0; i < DUMB_IT_N_NNA_CHANNELS; i++) { - if (sigrenderer->playing[i]) { - if (sigrenderer->playing[i]->flags & IT_PLAYING_DEAD) { - free_playing(sigrenderer->playing[i]); - sigrenderer->playing[i] = NULL; - } - } - } + for (i = 0; i < DUMB_IT_N_NNA_CHANNELS; i++) { + if (sigrenderer->playing[i]) { + if (sigrenderer->playing[i]->flags & IT_PLAYING_DEAD) { + free_playing(sigrenderer->playing[i]); + sigrenderer->playing[i] = NULL; + } + } + } } - - -static void render(DUMB_IT_SIGRENDERER *sigrenderer, float volume, float delta, long pos, long size, sample_t **samples) -{ - if (size == 0) return; - if (sigrenderer->n_channels == 1 || sigrenderer->n_channels == 2) - render_normal(sigrenderer, volume, delta, pos, size, samples); - else if (sigrenderer->n_channels == 3) - render_surround(sigrenderer, volume, delta, pos, size, samples); +static void render(DUMB_IT_SIGRENDERER *sigrenderer, float volume, float delta, + long pos, long size, sample_t **samples) { + if (size == 0) + return; + if (sigrenderer->n_channels == 1 || sigrenderer->n_channels == 2) + render_normal(sigrenderer, volume, delta, pos, size, samples); + else if (sigrenderer->n_channels == 3) + render_surround(sigrenderer, volume, delta, pos, size, samples); } +static DUMB_IT_SIGRENDERER *init_sigrenderer(DUMB_IT_SIGDATA *sigdata, + int n_channels, int startorder, + IT_CALLBACKS *callbacks, + DUMB_CLICK_REMOVER **cr) { + DUMB_IT_SIGRENDERER *sigrenderer; + int i; + if (startorder > sigdata->n_orders) { + free(callbacks); + dumb_destroy_click_remover_array(n_channels, cr); + return NULL; + } -static DUMB_IT_SIGRENDERER *init_sigrenderer(DUMB_IT_SIGDATA *sigdata, int n_channels, int startorder, IT_CALLBACKS *callbacks, DUMB_CLICK_REMOVER **cr) -{ - DUMB_IT_SIGRENDERER *sigrenderer; - int i; + sigrenderer = malloc(sizeof(*sigrenderer)); + if (!sigrenderer) { + free(callbacks); + dumb_destroy_click_remover_array(n_channels, cr); + return NULL; + } - if (startorder > sigdata->n_orders) { - free(callbacks); - dumb_destroy_click_remover_array(n_channels, cr); - return NULL; - } + sigrenderer->callbacks = callbacks; + sigrenderer->click_remover = cr; - sigrenderer = malloc(sizeof(*sigrenderer)); - if (!sigrenderer) { - free(callbacks); - dumb_destroy_click_remover_array(n_channels, cr); - return NULL; - } - - sigrenderer->callbacks = callbacks; - sigrenderer->click_remover = cr; - - sigrenderer->sigdata = sigdata; - sigrenderer->n_channels = n_channels; - sigrenderer->resampling_quality = dumb_resampling_quality; + sigrenderer->sigdata = sigdata; + sigrenderer->n_channels = n_channels; + sigrenderer->resampling_quality = dumb_resampling_quality; sigrenderer->ramp_style = DUMB_IT_RAMP_FULL; - sigrenderer->globalvolume = sigdata->global_volume; - sigrenderer->tempo = sigdata->tempo; + sigrenderer->globalvolume = sigdata->global_volume; + sigrenderer->tempo = sigdata->tempo; - for (i = 0; i < DUMB_IT_N_CHANNELS; i++) { - IT_CHANNEL *channel = &sigrenderer->channel[i]; + for (i = 0; i < DUMB_IT_N_CHANNELS; i++) { + IT_CHANNEL *channel = &sigrenderer->channel[i]; #if IT_CHANNEL_MUTED != 1 #error this is wrong #endif - channel->flags = sigdata->channel_pan[i] >> 7; - channel->volume = (sigdata->flags & IT_WAS_AN_XM) ? 0 : 64; - channel->pan = sigdata->channel_pan[i] & 0x7F; - channel->truepan = channel->pan << IT_ENVELOPE_SHIFT; - channel->channelvolume = sigdata->channel_volume[i]; - channel->instrument = 0; - channel->sample = 0; - channel->note = IT_NOTE_OFF; - channel->SFmacro = 0; - channel->filter_cutoff = 127; - channel->filter_resonance = 0; - channel->new_note_action = 0xFF; - channel->xm_retrig = 0; - channel->retrig_tick = 0; - channel->tremor_time = 0; - channel->vibrato_waveform = 0; - channel->tremolo_waveform = 0; - channel->panbrello_waveform = 0; - channel->glissando = 0; - channel->toneslide = 0; - channel->ptm_toneslide = 0; - channel->ptm_last_toneslide = 0; - channel->okt_toneslide = 0; - channel->midi_state = 0; - channel->lastvolslide = 0; - channel->lastDKL = 0; - channel->lastEF = 0; - channel->lastG = 0; - channel->lastHspeed = 0; - channel->lastHdepth = 0; - channel->lastRspeed = 0; - channel->lastRdepth = 0; - channel->lastYspeed = 0; - channel->lastYdepth = 0; - channel->lastI = 0; - channel->lastJ = 0; - channel->lastN = 0; - channel->lastO = 0; - channel->high_offset = 0; - channel->lastP = 0; - channel->lastQ = 0; - channel->lastS = 0; - channel->pat_loop_row = 0; - channel->pat_loop_count = 0; - channel->pat_loop_end_row = 0; - channel->lastW = 0; - channel->xm_lastE1 = 0; - channel->xm_lastE2 = 0; - channel->xm_lastEA = 0; - channel->xm_lastEB = 0; - channel->xm_lastX1 = 0; - channel->xm_lastX2 = 0; - channel->inv_loop_delay = 0; - channel->inv_loop_speed = 0; - channel->inv_loop_offset = 0; - channel->playing = NULL; - channel->key_off_count = 0; - channel->note_cut_count = 0; - channel->note_delay_count = 0; - channel->note_delay_entry = 0; + channel->flags = sigdata->channel_pan[i] >> 7; + channel->volume = (sigdata->flags & IT_WAS_AN_XM) ? 0 : 64; + channel->pan = sigdata->channel_pan[i] & 0x7F; + channel->truepan = channel->pan << IT_ENVELOPE_SHIFT; + channel->channelvolume = sigdata->channel_volume[i]; + channel->instrument = 0; + channel->sample = 0; + channel->note = IT_NOTE_OFF; + channel->SFmacro = 0; + channel->filter_cutoff = 127; + channel->filter_resonance = 0; + channel->new_note_action = 0xFF; + channel->xm_retrig = 0; + channel->retrig_tick = 0; + channel->tremor_time = 0; + channel->vibrato_waveform = 0; + channel->tremolo_waveform = 0; + channel->panbrello_waveform = 0; + channel->glissando = 0; + channel->toneslide = 0; + channel->ptm_toneslide = 0; + channel->ptm_last_toneslide = 0; + channel->okt_toneslide = 0; + channel->midi_state = 0; + channel->lastvolslide = 0; + channel->lastDKL = 0; + channel->lastEF = 0; + channel->lastG = 0; + channel->lastHspeed = 0; + channel->lastHdepth = 0; + channel->lastRspeed = 0; + channel->lastRdepth = 0; + channel->lastYspeed = 0; + channel->lastYdepth = 0; + channel->lastI = 0; + channel->lastJ = 0; + channel->lastN = 0; + channel->lastO = 0; + channel->high_offset = 0; + channel->lastP = 0; + channel->lastQ = 0; + channel->lastS = 0; + channel->pat_loop_row = 0; + channel->pat_loop_count = 0; + channel->pat_loop_end_row = 0; + channel->lastW = 0; + channel->xm_lastE1 = 0; + channel->xm_lastE2 = 0; + channel->xm_lastEA = 0; + channel->xm_lastEB = 0; + channel->xm_lastX1 = 0; + channel->xm_lastX2 = 0; + channel->inv_loop_delay = 0; + channel->inv_loop_speed = 0; + channel->inv_loop_offset = 0; + channel->playing = NULL; + channel->key_off_count = 0; + channel->note_cut_count = 0; + channel->note_delay_count = 0; + channel->note_delay_entry = 0; #ifdef BIT_ARRAY_BULLSHIT - channel->played_patjump = NULL; - channel->played_patjump_order = 0xFFFE; + channel->played_patjump = NULL; + channel->played_patjump_order = 0xFFFE; #endif - //channel->output = 0; - } + // channel->output = 0; + } - if (sigdata->flags & IT_WAS_A_669) - reset_effects(sigrenderer); + if (sigdata->flags & IT_WAS_A_669) + reset_effects(sigrenderer); - for (i = 0; i < DUMB_IT_N_NNA_CHANNELS; i++) - sigrenderer->playing[i] = NULL; + for (i = 0; i < DUMB_IT_N_NNA_CHANNELS; i++) + sigrenderer->playing[i] = NULL; - sigrenderer->speed = sigdata->speed; + sigrenderer->speed = sigdata->speed; - sigrenderer->processrow = 0xFFFE; - sigrenderer->n_rows = 0; - sigrenderer->breakrow = 0; - sigrenderer->rowcount = 1; - sigrenderer->order = startorder; - /* meh! - if (startorder > 0) { - int n; - for (n = startorder - 1; n >= 0; n--) { - if (sigdata->order[n] > sigdata->n_patterns) { - sigrenderer->restart_position = n + 1; - break; - } - } - } - */ - if (startorder > 0) { - sigrenderer->restart_position = startorder; - } else { - sigrenderer->restart_position = sigdata->restart_position; - } + sigrenderer->processrow = 0xFFFE; + sigrenderer->n_rows = 0; + sigrenderer->breakrow = 0; + sigrenderer->rowcount = 1; + sigrenderer->order = startorder; + /* meh! + if (startorder > 0) { + int n; + for (n = startorder - 1; n >= 0; n--) { + if (sigdata->order[n] > sigdata->n_patterns) { + sigrenderer->restart_position = n + 1; + break; + } + } + } + */ + if (startorder > 0) { + sigrenderer->restart_position = startorder; + } else { + sigrenderer->restart_position = sigdata->restart_position; + } - sigrenderer->row = 0; - sigrenderer->processorder = startorder - 1; - sigrenderer->tick = 1; + sigrenderer->row = 0; + sigrenderer->processorder = startorder - 1; + sigrenderer->tick = 1; #ifdef BIT_ARRAY_BULLSHIT - sigrenderer->played = bit_array_create(sigdata->n_orders * 256); + sigrenderer->played = bit_array_create(sigdata->n_orders * 256); - sigrenderer->looped = 0; - sigrenderer->time_played = 0; - sigrenderer->row_timekeeper = timekeeping_array_create(sigdata->n_orders * 256); + sigrenderer->looped = 0; + sigrenderer->time_played = 0; + sigrenderer->row_timekeeper = + timekeeping_array_create(sigdata->n_orders * 256); #endif - { - int order; - for (order = 0; order < sigdata->n_orders; order++) { - int n = sigdata->order[order]; - if (n < sigdata->n_patterns) goto found_valid_order; + { + int order; + for (order = 0; order < sigdata->n_orders; order++) { + int n = sigdata->order[order]; + if (n < sigdata->n_patterns) + goto found_valid_order; #ifdef INVALID_ORDERS_END_SONG - if (n != IT_ORDER_SKIP) + if (n != IT_ORDER_SKIP) #else - if (n == IT_ORDER_END) + if (n == IT_ORDER_END) #endif - break; + break; #ifdef BIT_ARRAY_BULLSHIT - /* Fix for played order detection for songs which have skips at the start of the orders list */ - for (n = 0; n < 256; n++) { - bit_array_set(sigrenderer->played, order * 256 + n); - timekeeping_array_push(sigrenderer->row_timekeeper, order * 256 + n, 0); - timekeeping_array_bump(sigrenderer->row_timekeeper, order * 256 + n); - } + /* Fix for played order detection for songs which have skips at the + * start of the orders list */ + for (n = 0; n < 256; n++) { + bit_array_set(sigrenderer->played, order * 256 + n); + timekeeping_array_push(sigrenderer->row_timekeeper, + order * 256 + n, 0); + timekeeping_array_bump(sigrenderer->row_timekeeper, + order * 256 + n); + } #endif - } - /* If we get here, there were no valid orders in the song. */ - _dumb_it_end_sigrenderer(sigrenderer); - return NULL; - } - found_valid_order: + } + /* If we get here, there were no valid orders in the song. */ + _dumb_it_end_sigrenderer(sigrenderer); + return NULL; + } +found_valid_order: - sigrenderer->time_left = 0; - sigrenderer->sub_time_left = 0; + sigrenderer->time_left = 0; + sigrenderer->sub_time_left = 0; - sigrenderer->gvz_time = 0; - sigrenderer->gvz_sub_time = 0; + sigrenderer->gvz_time = 0; + sigrenderer->gvz_sub_time = 0; - //sigrenderer->max_output = 0; + // sigrenderer->max_output = 0; - if ( !(sigdata->flags & IT_WAS_PROCESSED) ) { - if ( dumb_it_add_lpc( sigdata ) < 0 ) { - _dumb_it_end_sigrenderer( sigrenderer ); - return NULL; - } + if (!(sigdata->flags & IT_WAS_PROCESSED)) { + if (dumb_it_add_lpc(sigdata) < 0) { + _dumb_it_end_sigrenderer(sigrenderer); + return NULL; + } - sigdata->flags |= IT_WAS_PROCESSED; - } + sigdata->flags |= IT_WAS_PROCESSED; + } - return sigrenderer; + return sigrenderer; } - -void dumb_it_set_resampling_quality(DUMB_IT_SIGRENDERER * sigrenderer, int quality) -{ - if (sigrenderer && quality >= 0 && quality < DUMB_RQ_N_LEVELS) - { - int i; - sigrenderer->resampling_quality = quality; - for (i = 0; i < DUMB_IT_N_CHANNELS; i++) { - if (sigrenderer->channel[i].playing) - { - IT_PLAYING * playing = sigrenderer->channel[i].playing; - playing->resampling_quality = quality; - playing->resampler.quality = quality; - resampler_set_quality(playing->resampler.fir_resampler[0], quality); - resampler_set_quality(playing->resampler.fir_resampler[1], quality); - } - } - for (i = 0; i < DUMB_IT_N_NNA_CHANNELS; i++) { - if (sigrenderer->playing[i]) { - IT_PLAYING * playing = sigrenderer->playing[i]; - playing->resampling_quality = quality; - playing->resampler.quality = quality; - resampler_set_quality(playing->resampler.fir_resampler[0], quality); - resampler_set_quality(playing->resampler.fir_resampler[1], quality); - } - } - } +void dumb_it_set_resampling_quality(DUMB_IT_SIGRENDERER *sigrenderer, + int quality) { + if (sigrenderer && quality >= 0 && quality < DUMB_RQ_N_LEVELS) { + int i; + sigrenderer->resampling_quality = quality; + for (i = 0; i < DUMB_IT_N_CHANNELS; i++) { + if (sigrenderer->channel[i].playing) { + IT_PLAYING *playing = sigrenderer->channel[i].playing; + playing->resampling_quality = quality; + playing->resampler.quality = quality; + resampler_set_quality(playing->resampler.fir_resampler[0], + quality); + resampler_set_quality(playing->resampler.fir_resampler[1], + quality); + } + } + for (i = 0; i < DUMB_IT_N_NNA_CHANNELS; i++) { + if (sigrenderer->playing[i]) { + IT_PLAYING *playing = sigrenderer->playing[i]; + playing->resampling_quality = quality; + playing->resampler.quality = quality; + resampler_set_quality(playing->resampler.fir_resampler[0], + quality); + resampler_set_quality(playing->resampler.fir_resampler[1], + quality); + } + } + } } - -void dumb_it_set_ramp_style(DUMB_IT_SIGRENDERER * sigrenderer, int ramp_style) { - if (sigrenderer && ramp_style >= 0 && ramp_style <= 2) { - sigrenderer->ramp_style = ramp_style; - } +void dumb_it_set_ramp_style(DUMB_IT_SIGRENDERER *sigrenderer, int ramp_style) { + if (sigrenderer && ramp_style >= 0 && ramp_style <= 2) { + sigrenderer->ramp_style = ramp_style; + } } - -void dumb_it_set_loop_callback(DUMB_IT_SIGRENDERER *sigrenderer, int (*callback)(void *data), void *data) -{ - if (sigrenderer) { - sigrenderer->callbacks->loop = callback; - sigrenderer->callbacks->loop_data = data; - } +void dumb_it_set_loop_callback(DUMB_IT_SIGRENDERER *sigrenderer, + int (*callback)(void *data), void *data) { + if (sigrenderer) { + sigrenderer->callbacks->loop = callback; + sigrenderer->callbacks->loop_data = data; + } } - - -void dumb_it_set_xm_speed_zero_callback(DUMB_IT_SIGRENDERER *sigrenderer, int (*callback)(void *data), void *data) -{ - if (sigrenderer) { - sigrenderer->callbacks->xm_speed_zero = callback; - sigrenderer->callbacks->xm_speed_zero_data = data; - } +void dumb_it_set_xm_speed_zero_callback(DUMB_IT_SIGRENDERER *sigrenderer, + int (*callback)(void *data), + void *data) { + if (sigrenderer) { + sigrenderer->callbacks->xm_speed_zero = callback; + sigrenderer->callbacks->xm_speed_zero_data = data; + } } - - -void dumb_it_set_midi_callback(DUMB_IT_SIGRENDERER *sigrenderer, int (*callback)(void *data, int channel, unsigned char midi_byte), void *data) -{ - if (sigrenderer) { - sigrenderer->callbacks->midi = callback; - sigrenderer->callbacks->midi_data = data; - } +void dumb_it_set_midi_callback(DUMB_IT_SIGRENDERER *sigrenderer, + int (*callback)(void *data, int channel, + unsigned char midi_byte), + void *data) { + if (sigrenderer) { + sigrenderer->callbacks->midi = callback; + sigrenderer->callbacks->midi_data = data; + } } - - -void dumb_it_set_global_volume_zero_callback(DUMB_IT_SIGRENDERER *sigrenderer, int (*callback)(void *data), void *data) -{ - if (sigrenderer) { - sigrenderer->callbacks->global_volume_zero = callback; - sigrenderer->callbacks->global_volume_zero_data = data; - } +void dumb_it_set_global_volume_zero_callback(DUMB_IT_SIGRENDERER *sigrenderer, + int (*callback)(void *data), + void *data) { + if (sigrenderer) { + sigrenderer->callbacks->global_volume_zero = callback; + sigrenderer->callbacks->global_volume_zero_data = data; + } } - - -static IT_CALLBACKS *create_callbacks(void) -{ - IT_CALLBACKS *callbacks = malloc(sizeof(*callbacks)); - if (!callbacks) return NULL; - callbacks->loop = NULL; - callbacks->xm_speed_zero = NULL; - callbacks->midi = NULL; - callbacks->global_volume_zero = NULL; - return callbacks; +static IT_CALLBACKS *create_callbacks(void) { + IT_CALLBACKS *callbacks = malloc(sizeof(*callbacks)); + if (!callbacks) + return NULL; + callbacks->loop = NULL; + callbacks->xm_speed_zero = NULL; + callbacks->midi = NULL; + callbacks->global_volume_zero = NULL; + return callbacks; } +static DUMB_IT_SIGRENDERER *dumb_it_init_sigrenderer(DUMB_IT_SIGDATA *sigdata, + int n_channels, + int startorder) { + IT_CALLBACKS *callbacks; + if (!sigdata) + return NULL; -static DUMB_IT_SIGRENDERER *dumb_it_init_sigrenderer(DUMB_IT_SIGDATA *sigdata, int n_channels, int startorder) -{ - IT_CALLBACKS *callbacks; + callbacks = create_callbacks(); + if (!callbacks) + return NULL; - if (!sigdata) return NULL; - - callbacks = create_callbacks(); - if (!callbacks) return NULL; - - return init_sigrenderer(sigdata, n_channels, startorder, callbacks, - dumb_create_click_remover_array(n_channels)); + return init_sigrenderer(sigdata, n_channels, startorder, callbacks, + dumb_create_click_remover_array(n_channels)); } - - -DUH_SIGRENDERER *dumb_it_start_at_order(DUH *duh, int n_channels, int startorder) -{ - DUMB_IT_SIGDATA *itsd = duh_get_it_sigdata(duh); - DUMB_IT_SIGRENDERER *itsr = dumb_it_init_sigrenderer(itsd, n_channels, startorder); - /*duh->length = dumb_it_build_checkpoints(itsd, startorder);*/ - return duh_encapsulate_it_sigrenderer(itsr, n_channels, 0); +DUH_SIGRENDERER *dumb_it_start_at_order(DUH *duh, int n_channels, + int startorder) { + DUMB_IT_SIGDATA *itsd = duh_get_it_sigdata(duh); + DUMB_IT_SIGRENDERER *itsr = + dumb_it_init_sigrenderer(itsd, n_channels, startorder); + /*duh->length = dumb_it_build_checkpoints(itsd, startorder);*/ + return duh_encapsulate_it_sigrenderer(itsr, n_channels, 0); } +static sigrenderer_t *it_start_sigrenderer(DUH *duh, sigdata_t *vsigdata, + int n_channels, long pos) { + DUMB_IT_SIGDATA *sigdata = vsigdata; + DUMB_IT_SIGRENDERER *sigrenderer; + (void)duh; -static sigrenderer_t *it_start_sigrenderer(DUH *duh, sigdata_t *vsigdata, int n_channels, long pos) -{ - DUMB_IT_SIGDATA *sigdata = vsigdata; - DUMB_IT_SIGRENDERER *sigrenderer; + { + IT_CALLBACKS *callbacks = create_callbacks(); + if (!callbacks) + return NULL; - (void)duh; + if (sigdata->checkpoint) { + IT_CHECKPOINT *checkpoint = sigdata->checkpoint; + while (checkpoint->next && checkpoint->next->time < pos) + checkpoint = checkpoint->next; + sigrenderer = + dup_sigrenderer(checkpoint->sigrenderer, n_channels, callbacks); + if (!sigrenderer) + return NULL; + sigrenderer->click_remover = + dumb_create_click_remover_array(n_channels); + pos -= checkpoint->time; + } else { + sigrenderer = + init_sigrenderer(sigdata, n_channels, 0, callbacks, + dumb_create_click_remover_array(n_channels)); + if (!sigrenderer) + return NULL; + } + } - { - IT_CALLBACKS *callbacks = create_callbacks(); - if (!callbacks) return NULL; - - if (sigdata->checkpoint) { - IT_CHECKPOINT *checkpoint = sigdata->checkpoint; - while (checkpoint->next && checkpoint->next->time < pos) - checkpoint = checkpoint->next; - sigrenderer = dup_sigrenderer(checkpoint->sigrenderer, n_channels, callbacks); - if (!sigrenderer) return NULL; - sigrenderer->click_remover = dumb_create_click_remover_array(n_channels); - pos -= checkpoint->time; - } else { - sigrenderer = init_sigrenderer(sigdata, n_channels, 0, callbacks, - dumb_create_click_remover_array(n_channels)); - if (!sigrenderer) return NULL; - } - } - - while (pos > 0 && pos >= sigrenderer->time_left) { - render(sigrenderer, 0, 1.0f, 0, sigrenderer->time_left, NULL); + while (pos > 0 && pos >= sigrenderer->time_left) { + render(sigrenderer, 0, 1.0f, 0, sigrenderer->time_left, NULL); #ifdef BIT_ARRAY_BULLSHIT - sigrenderer->time_played += (LONG_LONG)sigrenderer->time_left << 16; + sigrenderer->time_played += (LONG_LONG)sigrenderer->time_left << 16; #endif - pos -= sigrenderer->time_left; - sigrenderer->time_left = 0; + pos -= sigrenderer->time_left; + sigrenderer->time_left = 0; - if (process_tick(sigrenderer)) { - _dumb_it_end_sigrenderer(sigrenderer); - return NULL; - } - } + if (process_tick(sigrenderer)) { + _dumb_it_end_sigrenderer(sigrenderer); + return NULL; + } + } - render(sigrenderer, 0, 1.0f, 0, pos, NULL); - sigrenderer->time_left -= pos; + render(sigrenderer, 0, 1.0f, 0, pos, NULL); + sigrenderer->time_left -= pos; #ifdef BIT_ARRAY_BULLSHIT - sigrenderer->time_played += (LONG_LONG)pos << 16; + sigrenderer->time_played += (LONG_LONG)pos << 16; #endif - return sigrenderer; + return sigrenderer; } +static long it_sigrenderer_get_samples(sigrenderer_t *vsigrenderer, + float volume, float delta, long size, + sample_t **samples) { + DUMB_IT_SIGRENDERER *sigrenderer = vsigrenderer; + long pos; + int dt; + long todo; + int ret; + LONG_LONG t; + if (sigrenderer->order < 0) + return 0; // problematic -static long it_sigrenderer_get_samples( - sigrenderer_t *vsigrenderer, - float volume, float delta, - long size, sample_t **samples -) -{ - DUMB_IT_SIGRENDERER *sigrenderer = vsigrenderer; - long pos; - int dt; - long todo; - int ret; - LONG_LONG t; + if (!sigrenderer->tempo) + return 0; // also problematic - if (sigrenderer->order < 0) return 0; // problematic - - if (!sigrenderer->tempo) return 0; // also problematic + pos = 0; + dt = (int)(delta * 65536.0f + 0.5f); - pos = 0; - dt = (int)(delta * 65536.0f + 0.5f); + /* When samples is finally used in render_playing(), it won't be used if + * volume is 0. + */ + if (!samples) + volume = 0; - /* When samples is finally used in render_playing(), it won't be used if - * volume is 0. - */ - if (!samples) volume = 0; + for (;;) { + todo = (long)((((LONG_LONG)sigrenderer->time_left << 16) | + sigrenderer->sub_time_left) / + dt); - for (;;) { - todo = (long)((((LONG_LONG)sigrenderer->time_left << 16) | sigrenderer->sub_time_left) / dt); + if (todo >= size) + break; - if (todo >= size) - break; + render(sigrenderer, volume, delta, pos, todo, samples); - render(sigrenderer, volume, delta, pos, todo, samples); + pos += todo; + size -= todo; - pos += todo; - size -= todo; - - t = sigrenderer->sub_time_left - (LONG_LONG)todo * dt; - sigrenderer->sub_time_left = (long)t & 65535; - sigrenderer->time_left += (long)(t >> 16); + t = sigrenderer->sub_time_left - (LONG_LONG)todo * dt; + sigrenderer->sub_time_left = (long)t & 65535; + sigrenderer->time_left += (long)(t >> 16); #ifdef BIT_ARRAY_BULLSHIT - sigrenderer->time_played += (LONG_LONG)todo * dt; + sigrenderer->time_played += (LONG_LONG)todo * dt; #endif - ret = process_tick(sigrenderer); + ret = process_tick(sigrenderer); - if (ret) { - sigrenderer->order = -1; - sigrenderer->row = -1; - } + if (ret) { + sigrenderer->order = -1; + sigrenderer->row = -1; + } #ifdef BIT_ARRAY_BULLSHIT - if (sigrenderer->looped == 1) { - sigrenderer->looped = -1; - size = 0; - timekeeping_array_reset(sigrenderer->row_timekeeper, sigrenderer->order * 256 + sigrenderer->row); - sigrenderer->time_played = timekeeping_array_get_item(sigrenderer->row_timekeeper, sigrenderer->order * 256 + sigrenderer->row); - break; - } + if (sigrenderer->looped == 1) { + sigrenderer->looped = -1; + size = 0; + timekeeping_array_reset(sigrenderer->row_timekeeper, + sigrenderer->order * 256 + + sigrenderer->row); + sigrenderer->time_played = timekeeping_array_get_item( + sigrenderer->row_timekeeper, + sigrenderer->order * 256 + sigrenderer->row); + break; + } #endif - if (ret) { - return pos; - } - } + if (ret) { + return pos; + } + } - render(sigrenderer, volume, delta, pos, size, samples); + render(sigrenderer, volume, delta, pos, size, samples); - pos += size; + pos += size; - t = sigrenderer->sub_time_left - (LONG_LONG)size * dt; - sigrenderer->sub_time_left = (long)t & 65535; - sigrenderer->time_left += (long)(t >> 16); + t = sigrenderer->sub_time_left - (LONG_LONG)size * dt; + sigrenderer->sub_time_left = (long)t & 65535; + sigrenderer->time_left += (long)(t >> 16); #ifdef BIT_ARRAY_BULLSHIT - sigrenderer->time_played += (LONG_LONG)size * dt; + sigrenderer->time_played += (LONG_LONG)size * dt; #endif - if (samples) - dumb_remove_clicks_array(sigrenderer->n_channels, sigrenderer->click_remover, samples, pos, 512.0f / delta); + if (samples) + dumb_remove_clicks_array(sigrenderer->n_channels, + sigrenderer->click_remover, samples, pos, + 512.0f / delta); - return pos; + return pos; } - - -static void it_sigrenderer_get_current_sample(sigrenderer_t *vsigrenderer, float volume, sample_t *samples) -{ - DUMB_IT_SIGRENDERER *sigrenderer = vsigrenderer; - (void)volume; // for consideration: in any of these such functions, is 'volume' going to be required? - dumb_click_remover_get_offset_array(sigrenderer->n_channels, sigrenderer->click_remover, samples); +static void it_sigrenderer_get_current_sample(sigrenderer_t *vsigrenderer, + float volume, sample_t *samples) { + DUMB_IT_SIGRENDERER *sigrenderer = vsigrenderer; + (void)volume; // for consideration: in any of these such functions, is + // 'volume' going to be required? + dumb_click_remover_get_offset_array(sigrenderer->n_channels, + sigrenderer->click_remover, samples); } +void _dumb_it_end_sigrenderer(sigrenderer_t *vsigrenderer) { + DUMB_IT_SIGRENDERER *sigrenderer = vsigrenderer; + int i; -void _dumb_it_end_sigrenderer(sigrenderer_t *vsigrenderer) -{ - DUMB_IT_SIGRENDERER *sigrenderer = vsigrenderer; - - int i; - - if (sigrenderer) { - for (i = 0; i < DUMB_IT_N_CHANNELS; i++) { - if (sigrenderer->channel[i].playing) - free_playing(sigrenderer->channel[i].playing); + if (sigrenderer) { + for (i = 0; i < DUMB_IT_N_CHANNELS; i++) { + if (sigrenderer->channel[i].playing) + free_playing(sigrenderer->channel[i].playing); #ifdef BIT_ARRAY_BULLSHIT - bit_array_destroy(sigrenderer->channel[i].played_patjump); + bit_array_destroy(sigrenderer->channel[i].played_patjump); #endif - } + } - for (i = 0; i < DUMB_IT_N_NNA_CHANNELS; i++) - if (sigrenderer->playing[i]) - free_playing(sigrenderer->playing[i]); + for (i = 0; i < DUMB_IT_N_NNA_CHANNELS; i++) + if (sigrenderer->playing[i]) + free_playing(sigrenderer->playing[i]); - dumb_destroy_click_remover_array(sigrenderer->n_channels, sigrenderer->click_remover); + dumb_destroy_click_remover_array(sigrenderer->n_channels, + sigrenderer->click_remover); - if (sigrenderer->callbacks) - free(sigrenderer->callbacks); + if (sigrenderer->callbacks) + free(sigrenderer->callbacks); #ifdef BIT_ARRAY_BULLSHIT - bit_array_destroy(sigrenderer->played); + bit_array_destroy(sigrenderer->played); - timekeeping_array_destroy(sigrenderer->row_timekeeper); + timekeeping_array_destroy(sigrenderer->row_timekeeper); #endif - free(vsigrenderer); - } + free(vsigrenderer); + } } - - #ifdef BIT_ARRAY_BULLSHIT -static long it_sigrenderer_get_position(sigrenderer_t *vsigrenderer) -{ - DUMB_IT_SIGRENDERER *sigrenderer = (DUMB_IT_SIGRENDERER *) vsigrenderer; +static long it_sigrenderer_get_position(sigrenderer_t *vsigrenderer) { + DUMB_IT_SIGRENDERER *sigrenderer = (DUMB_IT_SIGRENDERER *)vsigrenderer; - return (long)(sigrenderer->time_played >> 16); + return (long)(sigrenderer->time_played >> 16); } #endif - - -DUH_SIGTYPE_DESC _dumb_sigtype_it = { - SIGTYPE_IT, - NULL, - &it_start_sigrenderer, - NULL, - &it_sigrenderer_get_samples, - &it_sigrenderer_get_current_sample, +DUH_SIGTYPE_DESC _dumb_sigtype_it = {SIGTYPE_IT, + NULL, + &it_start_sigrenderer, + NULL, + &it_sigrenderer_get_samples, + &it_sigrenderer_get_current_sample, #ifdef BIT_ARRAY_BULLSHIT - &it_sigrenderer_get_position, + &it_sigrenderer_get_position, #else - NULL, + NULL, #endif - &_dumb_it_end_sigrenderer, - &_dumb_it_unload_sigdata -}; + &_dumb_it_end_sigrenderer, + &_dumb_it_unload_sigdata}; - - -DUH_SIGRENDERER *duh_encapsulate_it_sigrenderer(DUMB_IT_SIGRENDERER *it_sigrenderer, int n_channels, long pos) -{ - return duh_encapsulate_raw_sigrenderer(it_sigrenderer, &_dumb_sigtype_it, n_channels, pos); +DUH_SIGRENDERER * +duh_encapsulate_it_sigrenderer(DUMB_IT_SIGRENDERER *it_sigrenderer, + int n_channels, long pos) { + return duh_encapsulate_raw_sigrenderer(it_sigrenderer, &_dumb_sigtype_it, + n_channels, pos); } - - -DUMB_IT_SIGRENDERER *duh_get_it_sigrenderer(DUH_SIGRENDERER *sigrenderer) -{ - return duh_get_raw_sigrenderer(sigrenderer, SIGTYPE_IT); +DUMB_IT_SIGRENDERER *duh_get_it_sigrenderer(DUH_SIGRENDERER *sigrenderer) { + return duh_get_raw_sigrenderer(sigrenderer, SIGTYPE_IT); } - - /* Values of 64 or more will access NNA channels here. */ -void dumb_it_sr_get_channel_state(DUMB_IT_SIGRENDERER *sr, int channel, DUMB_IT_CHANNEL_STATE *state) -{ - IT_PLAYING *playing; - int t; /* temporary var for holding accurate pan and filter cutoff */ - float delta; - ASSERT(channel < DUMB_IT_TOTAL_CHANNELS); - if (!sr) { state->sample = 0; return; } - if (channel >= DUMB_IT_N_CHANNELS) { - playing = sr->playing[channel - DUMB_IT_N_CHANNELS]; - if (!playing) { state->sample = 0; return; } - } else { - playing = sr->channel[channel].playing; - if (!playing) { state->sample = 0; return; } - } +void dumb_it_sr_get_channel_state(DUMB_IT_SIGRENDERER *sr, int channel, + DUMB_IT_CHANNEL_STATE *state) { + IT_PLAYING *playing; + int t; /* temporary var for holding accurate pan and filter cutoff */ + float delta; + ASSERT(channel < DUMB_IT_TOTAL_CHANNELS); + if (!sr) { + state->sample = 0; + return; + } + if (channel >= DUMB_IT_N_CHANNELS) { + playing = sr->playing[channel - DUMB_IT_N_CHANNELS]; + if (!playing) { + state->sample = 0; + return; + } + } else { + playing = sr->channel[channel].playing; + if (!playing) { + state->sample = 0; + return; + } + } - if (playing->flags & IT_PLAYING_DEAD) { state->sample = 0; return; } + if (playing->flags & IT_PLAYING_DEAD) { + state->sample = 0; + return; + } - state->channel = (int)(playing->channel - sr->channel); - state->sample = playing->sampnum; - state->volume = calculate_volume(sr, playing, 1.0f); + state->channel = (int)(playing->channel - sr->channel); + state->sample = playing->sampnum; + state->volume = calculate_volume(sr, playing, 1.0f); - t = apply_pan_envelope(playing); - state->pan = (unsigned char)((t + 128) >> IT_ENVELOPE_SHIFT); - state->subpan = (signed char)t; + t = apply_pan_envelope(playing); + state->pan = (unsigned char)((t + 128) >> IT_ENVELOPE_SHIFT); + state->subpan = (signed char)t; - delta = playing->delta * 65536.0f; - t = playing->filter_cutoff << IT_ENVELOPE_SHIFT; - apply_pitch_modifications(sr->sigdata, playing, &delta, &t); - state->freq = (int)delta; - if (t == 127 << IT_ENVELOPE_SHIFT && playing->filter_resonance == 0) { - state->filter_resonance = playing->true_filter_resonance; - t = playing->true_filter_cutoff; - } else - state->filter_resonance = playing->filter_resonance; - state->filter_cutoff = (unsigned char)(t >> 8); - state->filter_subcutoff = (unsigned char)t; + delta = playing->delta * 65536.0f; + t = playing->filter_cutoff << IT_ENVELOPE_SHIFT; + apply_pitch_modifications(sr->sigdata, playing, &delta, &t); + state->freq = (int)delta; + if (t == 127 << IT_ENVELOPE_SHIFT && playing->filter_resonance == 0) { + state->filter_resonance = playing->true_filter_resonance; + t = playing->true_filter_cutoff; + } else + state->filter_resonance = playing->filter_resonance; + state->filter_cutoff = (unsigned char)(t >> 8); + state->filter_subcutoff = (unsigned char)t; } - - -int dumb_it_callback_terminate(void *data) -{ - (void)data; - return 1; +int dumb_it_callback_terminate(void *data) { + (void)data; + return 1; } - - -int dumb_it_callback_midi_block(void *data, int channel, unsigned char midi_byte) -{ - (void)data; - (void)channel; - (void)midi_byte; - return 1; +int dumb_it_callback_midi_block(void *data, int channel, + unsigned char midi_byte) { + (void)data; + (void)channel; + (void)midi_byte; + return 1; } - - #define IT_CHECKPOINT_INTERVAL (30 * 65536) /* Half a minute */ -#define FUCKIT_THRESHOLD (120 * 60 * 65536) /* two hours? probably a pattern loop mess... */ +#define FUCKIT_THRESHOLD \ + (120 * 60 * 65536) /* two hours? probably a pattern loop mess... */ /* Returns the length of the module, up until it first loops. */ -long dumb_it_build_checkpoints(DUMB_IT_SIGDATA *sigdata, int startorder) -{ - IT_CHECKPOINT *checkpoint; - if (!sigdata) return 0; - checkpoint = sigdata->checkpoint; - while (checkpoint) { - IT_CHECKPOINT *next = checkpoint->next; - _dumb_it_end_sigrenderer(checkpoint->sigrenderer); - free(checkpoint); - checkpoint = next; - } - sigdata->checkpoint = NULL; - checkpoint = malloc(sizeof(*checkpoint)); - if (!checkpoint) return 0; - checkpoint->time = 0; - checkpoint->sigrenderer = dumb_it_init_sigrenderer(sigdata, 0, startorder); - if (!checkpoint->sigrenderer) { - free(checkpoint); - return 0; - } - checkpoint->sigrenderer->callbacks->loop = &dumb_it_callback_terminate; - checkpoint->sigrenderer->callbacks->xm_speed_zero = &dumb_it_callback_terminate; - checkpoint->sigrenderer->callbacks->global_volume_zero = &dumb_it_callback_terminate; +long dumb_it_build_checkpoints(DUMB_IT_SIGDATA *sigdata, int startorder) { + IT_CHECKPOINT *checkpoint; + if (!sigdata) + return 0; + checkpoint = sigdata->checkpoint; + while (checkpoint) { + IT_CHECKPOINT *next = checkpoint->next; + _dumb_it_end_sigrenderer(checkpoint->sigrenderer); + free(checkpoint); + checkpoint = next; + } + sigdata->checkpoint = NULL; + checkpoint = malloc(sizeof(*checkpoint)); + if (!checkpoint) + return 0; + checkpoint->time = 0; + checkpoint->sigrenderer = dumb_it_init_sigrenderer(sigdata, 0, startorder); + if (!checkpoint->sigrenderer) { + free(checkpoint); + return 0; + } + checkpoint->sigrenderer->callbacks->loop = &dumb_it_callback_terminate; + checkpoint->sigrenderer->callbacks->xm_speed_zero = + &dumb_it_callback_terminate; + checkpoint->sigrenderer->callbacks->global_volume_zero = + &dumb_it_callback_terminate; - if (sigdata->checkpoint) - { - IT_CHECKPOINT *checkpoint = sigdata->checkpoint; - while (checkpoint) { - IT_CHECKPOINT *next = checkpoint->next; - _dumb_it_end_sigrenderer(checkpoint->sigrenderer); - free(checkpoint); - checkpoint = next; - } - } + if (sigdata->checkpoint) { + IT_CHECKPOINT *checkpoint = sigdata->checkpoint; + while (checkpoint) { + IT_CHECKPOINT *next = checkpoint->next; + _dumb_it_end_sigrenderer(checkpoint->sigrenderer); + free(checkpoint); + checkpoint = next; + } + } - sigdata->checkpoint = checkpoint; + sigdata->checkpoint = checkpoint; - for (;;) { - long l; - DUMB_IT_SIGRENDERER *sigrenderer = dup_sigrenderer(checkpoint->sigrenderer, 0, checkpoint->sigrenderer->callbacks); - checkpoint->sigrenderer->callbacks = NULL; - if (!sigrenderer) { - checkpoint->next = NULL; - return checkpoint->time; - } + for (;;) { + long l; + DUMB_IT_SIGRENDERER *sigrenderer = dup_sigrenderer( + checkpoint->sigrenderer, 0, checkpoint->sigrenderer->callbacks); + checkpoint->sigrenderer->callbacks = NULL; + if (!sigrenderer) { + checkpoint->next = NULL; + return checkpoint->time; + } - l = it_sigrenderer_get_samples(sigrenderer, 0, 1.0f, IT_CHECKPOINT_INTERVAL, NULL); - if (l < IT_CHECKPOINT_INTERVAL) { - _dumb_it_end_sigrenderer(sigrenderer); - checkpoint->next = NULL; - return checkpoint->time + l; - } + l = it_sigrenderer_get_samples(sigrenderer, 0, 1.0f, + IT_CHECKPOINT_INTERVAL, NULL); + if (l < IT_CHECKPOINT_INTERVAL) { + _dumb_it_end_sigrenderer(sigrenderer); + checkpoint->next = NULL; + return checkpoint->time + l; + } - checkpoint->next = malloc(sizeof(*checkpoint->next)); - if (!checkpoint->next) { - _dumb_it_end_sigrenderer(sigrenderer); - return checkpoint->time + IT_CHECKPOINT_INTERVAL; - } + checkpoint->next = malloc(sizeof(*checkpoint->next)); + if (!checkpoint->next) { + _dumb_it_end_sigrenderer(sigrenderer); + return checkpoint->time + IT_CHECKPOINT_INTERVAL; + } - checkpoint->next->time = checkpoint->time + IT_CHECKPOINT_INTERVAL; - checkpoint = checkpoint->next; - checkpoint->sigrenderer = sigrenderer; + checkpoint->next->time = checkpoint->time + IT_CHECKPOINT_INTERVAL; + checkpoint = checkpoint->next; + checkpoint->sigrenderer = sigrenderer; - if (checkpoint->time >= FUCKIT_THRESHOLD) { - checkpoint->next = NULL; - return 0; - } - } + if (checkpoint->time >= FUCKIT_THRESHOLD) { + checkpoint->next = NULL; + return 0; + } + } } +void dumb_it_do_initial_runthrough(DUH *duh) { + if (duh) { + DUMB_IT_SIGDATA *sigdata = duh_get_it_sigdata(duh); - -void dumb_it_do_initial_runthrough(DUH *duh) -{ - if (duh) { - DUMB_IT_SIGDATA *sigdata = duh_get_it_sigdata(duh); - - if (sigdata) - duh_set_length(duh, dumb_it_build_checkpoints(sigdata, 0)); - } + if (sigdata) + duh_set_length(duh, dumb_it_build_checkpoints(sigdata, 0)); + } } -static int is_pattern_silent(IT_PATTERN * pattern, int order) { - int ret = 1; - IT_ENTRY * entry, * end; - if (!pattern || !pattern->n_rows || !pattern->n_entries || !pattern->entry) return 2; +static int is_pattern_silent(IT_PATTERN *pattern, int order) { + int ret = 1; + IT_ENTRY *entry, *end; + if (!pattern || !pattern->n_rows || !pattern->n_entries || !pattern->entry) + return 2; - if ( pattern->n_entries == pattern->n_rows ) { - int n; - entry = pattern->entry; - for ( n = 0; n < pattern->n_entries; ++n, ++entry ) { - if ( !IT_IS_END_ROW(entry) ) break; - } - if ( n == pattern->n_entries ) return 2; - // broken? - } + if (pattern->n_entries == pattern->n_rows) { + int n; + entry = pattern->entry; + for (n = 0; n < pattern->n_entries; ++n, ++entry) { + if (!IT_IS_END_ROW(entry)) + break; + } + if (n == pattern->n_entries) + return 2; + // broken? + } - entry = pattern->entry; - end = entry + pattern->n_entries; + entry = pattern->entry; + end = entry + pattern->n_entries; - while (entry < end) { - if (!IT_IS_END_ROW(entry)) { - if (entry->mask & (IT_ENTRY_INSTRUMENT | IT_ENTRY_VOLPAN)) - return 0; - if (entry->mask & IT_ENTRY_NOTE && entry->note < 120) - return 0; - if (entry->mask & IT_ENTRY_EFFECT) { - switch (entry->effect) { - case IT_SET_GLOBAL_VOLUME: - if (entry->effectvalue) return 0; - break; + while (entry < end) { + if (!IT_IS_END_ROW(entry)) { + if (entry->mask & (IT_ENTRY_INSTRUMENT | IT_ENTRY_VOLPAN)) + return 0; + if (entry->mask & IT_ENTRY_NOTE && entry->note < 120) + return 0; + if (entry->mask & IT_ENTRY_EFFECT) { + switch (entry->effect) { + case IT_SET_GLOBAL_VOLUME: + if (entry->effectvalue) + return 0; + break; - case IT_SET_SPEED: - if (entry->effectvalue > 64) ret++; - break; + case IT_SET_SPEED: + if (entry->effectvalue > 64) + ret++; + break; - case IT_SET_SONG_TEMPO: - case IT_XM_KEY_OFF: - break; + case IT_SET_SONG_TEMPO: + case IT_XM_KEY_OFF: + break; - case IT_JUMP_TO_ORDER: - if (entry->effectvalue != order) - return 0; - break; + case IT_JUMP_TO_ORDER: + if (entry->effectvalue != order) + return 0; + break; - case IT_S: - switch (entry->effectvalue >> 4) { - case 0: // meh bastard - if ( entry->effectvalue != 0 ) return 0; - break; + case IT_S: + switch (entry->effectvalue >> 4) { + case 0: // meh bastard + if (entry->effectvalue != 0) + return 0; + break; - case IT_S_FINE_PATTERN_DELAY: - case IT_S_PATTERN_LOOP: - case IT_S_PATTERN_DELAY: - ret++; - break; + case IT_S_FINE_PATTERN_DELAY: + case IT_S_PATTERN_LOOP: + case IT_S_PATTERN_DELAY: + ret++; + break; - case IT_S7: - if ((entry->effectvalue & 15) > 2) - return 0; - break; + case IT_S7: + if ((entry->effectvalue & 15) > 2) + return 0; + break; - default: - return 0; - } - break; + default: + return 0; + } + break; - // clever idiot with his S L O W crap; do nothing - case IT_VOLSLIDE_TONEPORTA: - case IT_SET_SAMPLE_OFFSET: - case IT_GLOBAL_VOLUME_SLIDE: - if ( entry->effectvalue != 0 ) return 0; - break; + // clever idiot with his S L O W crap; do nothing + case IT_VOLSLIDE_TONEPORTA: + case IT_SET_SAMPLE_OFFSET: + case IT_GLOBAL_VOLUME_SLIDE: + if (entry->effectvalue != 0) + return 0; + break; - // genius also uses this instead of jump to order by mistake, meh, and it's bloody BCD - case IT_BREAK_TO_ROW: - if ( ( ( entry->effectvalue >> 4 ) * 10 + ( entry->effectvalue & 15 ) ) != order ) return 0; - break; + // genius also uses this instead of jump to order by mistake, + // meh, and it's bloody BCD + case IT_BREAK_TO_ROW: + if (((entry->effectvalue >> 4) * 10 + + (entry->effectvalue & 15)) != order) + return 0; + break; - default: - return 0; - } - } - } - entry++; - } + default: + return 0; + } + } + } + entry++; + } - return ret; + return ret; } -int dumb_it_trim_silent_patterns(DUH * duh) { - int n; - DUMB_IT_SIGDATA *sigdata; +int dumb_it_trim_silent_patterns(DUH *duh) { + int n; + DUMB_IT_SIGDATA *sigdata; - if (!duh) return -1; + if (!duh) + return -1; - sigdata = duh_get_it_sigdata(duh); + sigdata = duh_get_it_sigdata(duh); - if (!sigdata || !sigdata->order || !sigdata->pattern) return -1; + if (!sigdata || !sigdata->order || !sigdata->pattern) + return -1; - for (n = 0; n < sigdata->n_orders; n++) { - int p = sigdata->order[n]; - if (p < sigdata->n_patterns) { - IT_PATTERN * pattern = &sigdata->pattern[p]; - if (is_pattern_silent(pattern, n) > 1) { - pattern->n_rows = 1; - pattern->n_entries = 0; - if (pattern->entry) - { - free(pattern->entry); - pattern->entry = NULL; - } - } else - break; - } - } + for (n = 0; n < sigdata->n_orders; n++) { + int p = sigdata->order[n]; + if (p < sigdata->n_patterns) { + IT_PATTERN *pattern = &sigdata->pattern[p]; + if (is_pattern_silent(pattern, n) > 1) { + pattern->n_rows = 1; + pattern->n_entries = 0; + if (pattern->entry) { + free(pattern->entry); + pattern->entry = NULL; + } + } else + break; + } + } - if (n == sigdata->n_orders) return -1; + if (n == sigdata->n_orders) + return -1; - for (n = sigdata->n_orders - 1; n >= 0; n--) { - int p = sigdata->order[n]; - if (p < sigdata->n_patterns) { - IT_PATTERN * pattern = &sigdata->pattern[p]; - if (is_pattern_silent(pattern, n) > 1) { - pattern->n_rows = 1; - pattern->n_entries = 0; - if (pattern->entry) - { - free(pattern->entry); - pattern->entry = NULL; - } - } else - break; - } - } + for (n = sigdata->n_orders - 1; n >= 0; n--) { + int p = sigdata->order[n]; + if (p < sigdata->n_patterns) { + IT_PATTERN *pattern = &sigdata->pattern[p]; + if (is_pattern_silent(pattern, n) > 1) { + pattern->n_rows = 1; + pattern->n_entries = 0; + if (pattern->entry) { + free(pattern->entry); + pattern->entry = NULL; + } + } else + break; + } + } - if (n < 0) return -1; + if (n < 0) + return -1; - /*duh->length = dumb_it_build_checkpoints(sigdata, 0);*/ + /*duh->length = dumb_it_build_checkpoints(sigdata, 0);*/ - return 0; + return 0; } -int dumb_it_scan_for_playable_orders(DUMB_IT_SIGDATA *sigdata, dumb_scan_callback callback, void * callback_data) -{ - int n; - long length; - void * ba_played; - DUMB_IT_SIGRENDERER * sigrenderer; - - if (!sigdata->n_orders || !sigdata->order) return -1; +int dumb_it_scan_for_playable_orders(DUMB_IT_SIGDATA *sigdata, + dumb_scan_callback callback, + void *callback_data) { + int n; + long length; + void *ba_played; + DUMB_IT_SIGRENDERER *sigrenderer; - ba_played = bit_array_create(sigdata->n_orders * 256); - if (!ba_played) return -1; + if (!sigdata->n_orders || !sigdata->order) + return -1; - /* Skip the first order, it should always be played */ - for (n = 1; n < sigdata->n_orders; n++) { - if ((sigdata->order[n] >= sigdata->n_patterns) || - (is_pattern_silent(&sigdata->pattern[sigdata->order[n]], n) > 1)) - bit_array_set(ba_played, n * 256); - } + ba_played = bit_array_create(sigdata->n_orders * 256); + if (!ba_played) + return -1; - for (;;) { - for (n = 0; n < sigdata->n_orders; n++) { - if (!bit_array_test_range(ba_played, n * 256, 256)) break; - } + /* Skip the first order, it should always be played */ + for (n = 1; n < sigdata->n_orders; n++) { + if ((sigdata->order[n] >= sigdata->n_patterns) || + (is_pattern_silent(&sigdata->pattern[sigdata->order[n]], n) > 1)) + bit_array_set(ba_played, n * 256); + } - if (n == sigdata->n_orders) break; + for (;;) { + for (n = 0; n < sigdata->n_orders; n++) { + if (!bit_array_test_range(ba_played, n * 256, 256)) + break; + } - sigrenderer = dumb_it_init_sigrenderer(sigdata, 0, n); - if (!sigrenderer) { - bit_array_destroy(ba_played); - return -1; - } - sigrenderer->callbacks->loop = &dumb_it_callback_terminate; - sigrenderer->callbacks->xm_speed_zero = &dumb_it_callback_terminate; - sigrenderer->callbacks->global_volume_zero = &dumb_it_callback_terminate; + if (n == sigdata->n_orders) + break; - length = 0; + sigrenderer = dumb_it_init_sigrenderer(sigdata, 0, n); + if (!sigrenderer) { + bit_array_destroy(ba_played); + return -1; + } + sigrenderer->callbacks->loop = &dumb_it_callback_terminate; + sigrenderer->callbacks->xm_speed_zero = &dumb_it_callback_terminate; + sigrenderer->callbacks->global_volume_zero = + &dumb_it_callback_terminate; - for (;;) { - long l; + length = 0; - l = it_sigrenderer_get_samples(sigrenderer, 0, 1.0f, IT_CHECKPOINT_INTERVAL, NULL); - length += l; - if (l < IT_CHECKPOINT_INTERVAL || length >= FUCKIT_THRESHOLD) { - /* SONG OVA! */ - break; - } - } + for (;;) { + long l; - if ((*callback)(callback_data, n, length) < 0) return -1; + l = it_sigrenderer_get_samples(sigrenderer, 0, 1.0f, + IT_CHECKPOINT_INTERVAL, NULL); + length += l; + if (l < IT_CHECKPOINT_INTERVAL || length >= FUCKIT_THRESHOLD) { + /* SONG OVA! */ + break; + } + } - bit_array_merge(ba_played, sigrenderer->played, 0); + if ((*callback)(callback_data, n, length) < 0) + return -1; - _dumb_it_end_sigrenderer(sigrenderer); - } + bit_array_merge(ba_played, sigrenderer->played, 0); - bit_array_destroy(ba_played); + _dumb_it_end_sigrenderer(sigrenderer); + } - return 0; + bit_array_destroy(ba_played); + + return 0; } diff --git a/Frameworks/Dumb/dumb/src/it/itunload.c b/Frameworks/Dumb/dumb/src/it/itunload.c index 136fd5c5a..1119bef08 100644 --- a/Frameworks/Dumb/dumb/src/it/itunload.c +++ b/Frameworks/Dumb/dumb/src/it/itunload.c @@ -22,51 +22,48 @@ #include "dumb.h" #include "internal/it.h" +void _dumb_it_unload_sigdata(sigdata_t *vsigdata) { + if (vsigdata) { + DUMB_IT_SIGDATA *sigdata = vsigdata; + int n; + if (sigdata->song_message) + free(sigdata->song_message); -void _dumb_it_unload_sigdata(sigdata_t *vsigdata) -{ - if (vsigdata) { - DUMB_IT_SIGDATA *sigdata = vsigdata; - int n; + if (sigdata->order) + free(sigdata->order); - if (sigdata->song_message) - free(sigdata->song_message); + if (sigdata->instrument) + free(sigdata->instrument); - if (sigdata->order) - free(sigdata->order); + if (sigdata->sample) { + for (n = 0; n < sigdata->n_samples; n++) + if (sigdata->sample[n].data) + free(sigdata->sample[n].data); - if (sigdata->instrument) - free(sigdata->instrument); + free(sigdata->sample); + } - if (sigdata->sample) { - for (n = 0; n < sigdata->n_samples; n++) - if (sigdata->sample[n].data) - free(sigdata->sample[n].data); + if (sigdata->pattern) { + for (n = 0; n < sigdata->n_patterns; n++) + if (sigdata->pattern[n].entry) + free(sigdata->pattern[n].entry); + free(sigdata->pattern); + } - free(sigdata->sample); - } + if (sigdata->midi) + free(sigdata->midi); - if (sigdata->pattern) { - for (n = 0; n < sigdata->n_patterns; n++) - if (sigdata->pattern[n].entry) - free(sigdata->pattern[n].entry); - free(sigdata->pattern); - } + { + IT_CHECKPOINT *checkpoint = sigdata->checkpoint; + while (checkpoint) { + IT_CHECKPOINT *next = checkpoint->next; + _dumb_it_end_sigrenderer(checkpoint->sigrenderer); + free(checkpoint); + checkpoint = next; + } + } - if (sigdata->midi) - free(sigdata->midi); - - { - IT_CHECKPOINT *checkpoint = sigdata->checkpoint; - while (checkpoint) { - IT_CHECKPOINT *next = checkpoint->next; - _dumb_it_end_sigrenderer(checkpoint->sigrenderer); - free(checkpoint); - checkpoint = next; - } - } - - free(vsigdata); - } + free(vsigdata); + } } diff --git a/Frameworks/Dumb/dumb/src/it/load669.c b/Frameworks/Dumb/dumb/src/it/load669.c index e5a3fc3f4..eeaf25f3f 100644 --- a/Frameworks/Dumb/dumb/src/it/load669.c +++ b/Frameworks/Dumb/dumb/src/it/load669.c @@ -20,23 +20,20 @@ #include "dumb.h" #include "internal/it.h" - - /* dumb_load_669_quick(): loads a 669 file into a DUH struct, returning a * pointer to the DUH struct. When you have finished with it, you must * pass the pointer to unload_duh() so that the memory can be freed. */ -DUH *dumb_load_669_quick(const char *filename) -{ - DUH *duh; - DUMBFILE *f = dumbfile_open(filename); +DUH *dumb_load_669_quick(const char *filename) { + DUH *duh; + DUMBFILE *f = dumbfile_open(filename); - if (!f) - return NULL; + if (!f) + return NULL; - duh = dumb_read_669_quick(f); + duh = dumb_read_669_quick(f); - dumbfile_close(f); + dumbfile_close(f); - return duh; + return duh; } diff --git a/Frameworks/Dumb/dumb/src/it/load6692.c b/Frameworks/Dumb/dumb/src/it/load6692.c index 2358838f4..e191eba91 100644 --- a/Frameworks/Dumb/dumb/src/it/load6692.c +++ b/Frameworks/Dumb/dumb/src/it/load6692.c @@ -20,15 +20,12 @@ #include "dumb.h" #include "internal/it.h" - - /* dumb_load_669(): loads a 669 file into a DUH struct, returning a pointer * to the DUH struct. When you have finished with it, you must pass the * pointer to unload_duh() so that the memory can be freed. */ -DUH *dumb_load_669(const char *filename) -{ - DUH *duh = dumb_load_669_quick(filename); - dumb_it_do_initial_runthrough(duh); - return duh; +DUH *dumb_load_669(const char *filename) { + DUH *duh = dumb_load_669_quick(filename); + dumb_it_do_initial_runthrough(duh); + return duh; } diff --git a/Frameworks/Dumb/dumb/src/it/loadamf.c b/Frameworks/Dumb/dumb/src/it/loadamf.c index 2695125f1..38a8bf16c 100644 --- a/Frameworks/Dumb/dumb/src/it/loadamf.c +++ b/Frameworks/Dumb/dumb/src/it/loadamf.c @@ -20,23 +20,20 @@ #include "dumb.h" #include "internal/it.h" - - /* dumb_load_amf_quick(): loads a AMF file into a DUH struct, returning a * pointer to the DUH struct. When you have finished with it, you must * pass the pointer to unload_duh() so that the memory can be freed. */ -DUH *dumb_load_amf_quick(const char *filename) -{ - DUH *duh; - DUMBFILE *f = dumbfile_open(filename); +DUH *dumb_load_amf_quick(const char *filename) { + DUH *duh; + DUMBFILE *f = dumbfile_open(filename); - if (!f) - return NULL; + if (!f) + return NULL; - duh = dumb_read_amf_quick(f); + duh = dumb_read_amf_quick(f); - dumbfile_close(f); + dumbfile_close(f); - return duh; + return duh; } diff --git a/Frameworks/Dumb/dumb/src/it/loadamf2.c b/Frameworks/Dumb/dumb/src/it/loadamf2.c index 91f171de7..34619889d 100644 --- a/Frameworks/Dumb/dumb/src/it/loadamf2.c +++ b/Frameworks/Dumb/dumb/src/it/loadamf2.c @@ -20,15 +20,12 @@ #include "dumb.h" #include "internal/it.h" - - /* dumb_load_amf(): loads a AMF file into a DUH struct, returning a pointer * to the DUH struct. When you have finished with it, you must pass the * pointer to unload_duh() so that the memory can be freed. */ -DUH *dumb_load_amf(const char *filename) -{ - DUH *duh = dumb_load_amf_quick(filename); - dumb_it_do_initial_runthrough(duh); - return duh; +DUH *dumb_load_amf(const char *filename) { + DUH *duh = dumb_load_amf_quick(filename); + dumb_it_do_initial_runthrough(duh); + return duh; } diff --git a/Frameworks/Dumb/dumb/src/it/loadany.c b/Frameworks/Dumb/dumb/src/it/loadany.c index 5d268eafa..3e17851c5 100644 --- a/Frameworks/Dumb/dumb/src/it/loadany.c +++ b/Frameworks/Dumb/dumb/src/it/loadany.c @@ -20,19 +20,16 @@ #include "dumb.h" #include "internal/it.h" +DUH *dumb_load_any_quick(const char *filename, int restrict_, int subsong) { + DUH *duh; + DUMBFILE *f = dumbfile_open(filename); - -DUH *dumb_load_any_quick(const char *filename, int restrict_, int subsong) -{ - DUH *duh; - DUMBFILE *f = dumbfile_open(filename); - - if (!f) - return NULL; + if (!f) + return NULL; duh = dumb_read_any_quick(f, restrict_, subsong); - dumbfile_close(f); + dumbfile_close(f); - return duh; + return duh; } diff --git a/Frameworks/Dumb/dumb/src/it/loadany2.c b/Frameworks/Dumb/dumb/src/it/loadany2.c index fb9439f66..fa8f4b4f1 100644 --- a/Frameworks/Dumb/dumb/src/it/loadany2.c +++ b/Frameworks/Dumb/dumb/src/it/loadany2.c @@ -19,11 +19,8 @@ #include "dumb.h" - - -DUH *dumb_load_any(const char *filename, int restrict_, int subsong) -{ +DUH *dumb_load_any(const char *filename, int restrict_, int subsong) { DUH *duh = dumb_load_any_quick(filename, restrict_, subsong); - dumb_it_do_initial_runthrough(duh); - return duh; + dumb_it_do_initial_runthrough(duh); + return duh; } diff --git a/Frameworks/Dumb/dumb/src/it/loadasy.c b/Frameworks/Dumb/dumb/src/it/loadasy.c index 86c6ad8ce..ef2492ec0 100644 --- a/Frameworks/Dumb/dumb/src/it/loadasy.c +++ b/Frameworks/Dumb/dumb/src/it/loadasy.c @@ -20,23 +20,20 @@ #include "dumb.h" #include "internal/it.h" - - /* dumb_load_asy_quick(): loads a AMF file into a DUH struct, returning a * pointer to the DUH struct. When you have finished with it, you must * pass the pointer to unload_duh() so that the memory can be freed. */ -DUH *dumb_load_asy_quick(const char *filename) -{ - DUH *duh; - DUMBFILE *f = dumbfile_open(filename); +DUH *dumb_load_asy_quick(const char *filename) { + DUH *duh; + DUMBFILE *f = dumbfile_open(filename); - if (!f) - return NULL; + if (!f) + return NULL; - duh = dumb_read_asy_quick(f); + duh = dumb_read_asy_quick(f); - dumbfile_close(f); + dumbfile_close(f); - return duh; + return duh; } diff --git a/Frameworks/Dumb/dumb/src/it/loadasy2.c b/Frameworks/Dumb/dumb/src/it/loadasy2.c index 7b253320e..abea5878b 100644 --- a/Frameworks/Dumb/dumb/src/it/loadasy2.c +++ b/Frameworks/Dumb/dumb/src/it/loadasy2.c @@ -20,15 +20,12 @@ #include "dumb.h" #include "internal/it.h" - - /* dumb_load_asy(): loads a AMF file into a DUH struct, returning a pointer * to the DUH struct. When you have finished with it, you must pass the * pointer to unload_duh() so that the memory can be freed. */ -DUH *dumb_load_asy(const char *filename) -{ - DUH *duh = dumb_load_asy_quick(filename); - dumb_it_do_initial_runthrough(duh); - return duh; +DUH *dumb_load_asy(const char *filename) { + DUH *duh = dumb_load_asy_quick(filename); + dumb_it_do_initial_runthrough(duh); + return duh; } diff --git a/Frameworks/Dumb/dumb/src/it/loadmod.c b/Frameworks/Dumb/dumb/src/it/loadmod.c index 4e3e03706..5132a7d0e 100644 --- a/Frameworks/Dumb/dumb/src/it/loadmod.c +++ b/Frameworks/Dumb/dumb/src/it/loadmod.c @@ -20,23 +20,20 @@ #include "dumb.h" #include "internal/it.h" - - /* dumb_load_mod_quick(): loads a MOD file into a DUH struct, returning a * pointer to the DUH struct. When you have finished with it, you must * pass the pointer to unload_duh() so that the memory can be freed. */ -DUH *dumb_load_mod_quick(const char *filename, int restrict_) -{ - DUH *duh; - DUMBFILE *f = dumbfile_open(filename); +DUH *dumb_load_mod_quick(const char *filename, int restrict_) { + DUH *duh; + DUMBFILE *f = dumbfile_open(filename); - if (!f) - return NULL; + if (!f) + return NULL; - duh = dumb_read_mod_quick(f, restrict_); + duh = dumb_read_mod_quick(f, restrict_); - dumbfile_close(f); + dumbfile_close(f); - return duh; + return duh; } diff --git a/Frameworks/Dumb/dumb/src/it/loadmod2.c b/Frameworks/Dumb/dumb/src/it/loadmod2.c index 617897e78..5e930bc6c 100644 --- a/Frameworks/Dumb/dumb/src/it/loadmod2.c +++ b/Frameworks/Dumb/dumb/src/it/loadmod2.c @@ -19,11 +19,8 @@ #include "dumb.h" - - -DUH *dumb_load_mod(const char *filename, int restrict_) -{ - DUH *duh = dumb_load_mod_quick(filename, restrict_); - dumb_it_do_initial_runthrough(duh); - return duh; +DUH *dumb_load_mod(const char *filename, int restrict_) { + DUH *duh = dumb_load_mod_quick(filename, restrict_); + dumb_it_do_initial_runthrough(duh); + return duh; } diff --git a/Frameworks/Dumb/dumb/src/it/loadmtm.c b/Frameworks/Dumb/dumb/src/it/loadmtm.c index 3c974880f..ef1db1e7d 100644 --- a/Frameworks/Dumb/dumb/src/it/loadmtm.c +++ b/Frameworks/Dumb/dumb/src/it/loadmtm.c @@ -20,23 +20,20 @@ #include "dumb.h" #include "internal/it.h" - - /* dumb_load_mtm_quick(): loads a MTM file into a DUH struct, returning a * pointer to the DUH struct. When you have finished with it, you must * pass the pointer to unload_duh() so that the memory can be freed. */ -DUH *dumb_load_mtm_quick(const char *filename) -{ - DUH *duh; - DUMBFILE *f = dumbfile_open(filename); +DUH *dumb_load_mtm_quick(const char *filename) { + DUH *duh; + DUMBFILE *f = dumbfile_open(filename); - if (!f) - return NULL; + if (!f) + return NULL; - duh = dumb_read_mtm_quick(f); + duh = dumb_read_mtm_quick(f); - dumbfile_close(f); + dumbfile_close(f); - return duh; + return duh; } diff --git a/Frameworks/Dumb/dumb/src/it/loadmtm2.c b/Frameworks/Dumb/dumb/src/it/loadmtm2.c index 9fc238908..a3d2c9ff3 100644 --- a/Frameworks/Dumb/dumb/src/it/loadmtm2.c +++ b/Frameworks/Dumb/dumb/src/it/loadmtm2.c @@ -20,15 +20,12 @@ #include "dumb.h" #include "internal/it.h" - - /* dumb_load_mtm(): loads a MTM file into a DUH struct, returning a pointer * to the DUH struct. When you have finished with it, you must pass the * pointer to unload_duh() so that the memory can be freed. */ -DUH *dumb_load_mtm(const char *filename) -{ - DUH *duh = dumb_load_mtm_quick(filename); - dumb_it_do_initial_runthrough(duh); - return duh; +DUH *dumb_load_mtm(const char *filename) { + DUH *duh = dumb_load_mtm_quick(filename); + dumb_it_do_initial_runthrough(duh); + return duh; } diff --git a/Frameworks/Dumb/dumb/src/it/loadokt.c b/Frameworks/Dumb/dumb/src/it/loadokt.c index 2139d49e8..3ed60a6f6 100644 --- a/Frameworks/Dumb/dumb/src/it/loadokt.c +++ b/Frameworks/Dumb/dumb/src/it/loadokt.c @@ -20,23 +20,20 @@ #include "dumb.h" #include "internal/it.h" - - /* dumb_load_okt_quick(): loads an OKT file into a DUH struct, returning a * pointer to the DUH struct. When you have finished with it, you must * pass the pointer to unload_duh() so that the memory can be freed. */ -DUH *dumb_load_okt_quick(const char *filename) -{ - DUH *duh; - DUMBFILE *f = dumbfile_open(filename); +DUH *dumb_load_okt_quick(const char *filename) { + DUH *duh; + DUMBFILE *f = dumbfile_open(filename); - if (!f) - return NULL; + if (!f) + return NULL; - duh = dumb_read_okt_quick(f); + duh = dumb_read_okt_quick(f); - dumbfile_close(f); + dumbfile_close(f); - return duh; + return duh; } diff --git a/Frameworks/Dumb/dumb/src/it/loadokt2.c b/Frameworks/Dumb/dumb/src/it/loadokt2.c index aa752c582..73f67efd1 100644 --- a/Frameworks/Dumb/dumb/src/it/loadokt2.c +++ b/Frameworks/Dumb/dumb/src/it/loadokt2.c @@ -19,11 +19,8 @@ #include "dumb.h" - - -DUH *dumb_load_okt(const char *filename) -{ - DUH *duh = dumb_load_okt_quick(filename); - dumb_it_do_initial_runthrough(duh); - return duh; +DUH *dumb_load_okt(const char *filename) { + DUH *duh = dumb_load_okt_quick(filename); + dumb_it_do_initial_runthrough(duh); + return duh; } diff --git a/Frameworks/Dumb/dumb/src/it/loadoldpsm.c b/Frameworks/Dumb/dumb/src/it/loadoldpsm.c index 547294b36..a3b23fda7 100644 --- a/Frameworks/Dumb/dumb/src/it/loadoldpsm.c +++ b/Frameworks/Dumb/dumb/src/it/loadoldpsm.c @@ -20,24 +20,21 @@ #include "dumb.h" #include "internal/it.h" - - /* dumb_load_old_psm_quick(): loads an old PSM file into a DUH struct, * returning a pointer to the DUH struct. When you have finished with it, * you must pass the pointer to unload_duh() so that the memory can be * freed. */ -DUH *dumb_load_old_psm_quick(const char *filename) -{ - DUH *duh; - DUMBFILE *f = dumbfile_open(filename); +DUH *dumb_load_old_psm_quick(const char *filename) { + DUH *duh; + DUMBFILE *f = dumbfile_open(filename); - if (!f) - return NULL; + if (!f) + return NULL; - duh = dumb_read_old_psm_quick(f); + duh = dumb_read_old_psm_quick(f); - dumbfile_close(f); + dumbfile_close(f); - return duh; + return duh; } diff --git a/Frameworks/Dumb/dumb/src/it/loadoldpsm2.c b/Frameworks/Dumb/dumb/src/it/loadoldpsm2.c index ff2e427c4..b1bdf0523 100644 --- a/Frameworks/Dumb/dumb/src/it/loadoldpsm2.c +++ b/Frameworks/Dumb/dumb/src/it/loadoldpsm2.c @@ -20,15 +20,12 @@ #include "dumb.h" #include "internal/it.h" - - /* dumb_load_old_psm(): loads an old PSM file into a DUH struct, returning * a pointer to the DUH struct. When you have finished with it, you must * pass the pointer to unload_duh() so that the memory can be freed. */ -DUH *dumb_load_old_psm(const char *filename) -{ - DUH *duh = dumb_load_old_psm_quick(filename); - dumb_it_do_initial_runthrough(duh); - return duh; +DUH *dumb_load_old_psm(const char *filename) { + DUH *duh = dumb_load_old_psm_quick(filename); + dumb_it_do_initial_runthrough(duh); + return duh; } diff --git a/Frameworks/Dumb/dumb/src/it/loadpsm.c b/Frameworks/Dumb/dumb/src/it/loadpsm.c index a6851d5b6..7fcd06972 100644 --- a/Frameworks/Dumb/dumb/src/it/loadpsm.c +++ b/Frameworks/Dumb/dumb/src/it/loadpsm.c @@ -20,23 +20,20 @@ #include "dumb.h" #include "internal/it.h" - - /* dumb_load_psm_quick(): loads a PSM file into a DUH struct, returning a * pointer to the DUH struct. When you have finished with it, you must * pass the pointer to unload_duh() so that the memory can be freed. */ -DUH *dumb_load_psm_quick(const char *filename, int subsong) -{ - DUH *duh; - DUMBFILE *f = dumbfile_open(filename); +DUH *dumb_load_psm_quick(const char *filename, int subsong) { + DUH *duh; + DUMBFILE *f = dumbfile_open(filename); - if (!f) - return NULL; + if (!f) + return NULL; - duh = dumb_read_psm_quick(f, subsong); + duh = dumb_read_psm_quick(f, subsong); - dumbfile_close(f); + dumbfile_close(f); - return duh; + return duh; } diff --git a/Frameworks/Dumb/dumb/src/it/loadpsm2.c b/Frameworks/Dumb/dumb/src/it/loadpsm2.c index 7a12257a1..e8a46e771 100644 --- a/Frameworks/Dumb/dumb/src/it/loadpsm2.c +++ b/Frameworks/Dumb/dumb/src/it/loadpsm2.c @@ -20,15 +20,12 @@ #include "dumb.h" #include "internal/it.h" - - /* dumb_load_psm(): loads a PSM file into a DUH struct, returning a pointer * to the DUH struct. When you have finished with it, you must pass the * pointer to unload_duh() so that the memory can be freed. */ -DUH *dumb_load_psm(const char *filename, int subsong) -{ - DUH *duh = dumb_load_psm_quick(filename, subsong); - dumb_it_do_initial_runthrough(duh); - return duh; +DUH *dumb_load_psm(const char *filename, int subsong) { + DUH *duh = dumb_load_psm_quick(filename, subsong); + dumb_it_do_initial_runthrough(duh); + return duh; } diff --git a/Frameworks/Dumb/dumb/src/it/loadptm.c b/Frameworks/Dumb/dumb/src/it/loadptm.c index ddcaaec95..1c530405f 100644 --- a/Frameworks/Dumb/dumb/src/it/loadptm.c +++ b/Frameworks/Dumb/dumb/src/it/loadptm.c @@ -20,23 +20,20 @@ #include "dumb.h" #include "internal/it.h" - - /* dumb_load_ptm_quick(): loads a PTM file into a DUH struct, returning a * pointer to the DUH struct. When you have finished with it, you must * pass the pointer to unload_duh() so that the memory can be freed. */ -DUH *dumb_load_ptm_quick(const char *filename) -{ - DUH *duh; - DUMBFILE *f = dumbfile_open(filename); +DUH *dumb_load_ptm_quick(const char *filename) { + DUH *duh; + DUMBFILE *f = dumbfile_open(filename); - if (!f) - return NULL; + if (!f) + return NULL; - duh = dumb_read_ptm_quick(f); + duh = dumb_read_ptm_quick(f); - dumbfile_close(f); + dumbfile_close(f); - return duh; + return duh; } diff --git a/Frameworks/Dumb/dumb/src/it/loadptm2.c b/Frameworks/Dumb/dumb/src/it/loadptm2.c index ea8982f2b..a989e85a6 100644 --- a/Frameworks/Dumb/dumb/src/it/loadptm2.c +++ b/Frameworks/Dumb/dumb/src/it/loadptm2.c @@ -20,15 +20,12 @@ #include "dumb.h" #include "internal/it.h" - - /* dumb_load_ptm(): loads a PTM file into a DUH struct, returning a pointer * to the DUH struct. When you have finished with it, you must pass the * pointer to unload_duh() so that the memory can be freed. */ -DUH *dumb_load_ptm(const char *filename) -{ - DUH *duh = dumb_load_ptm_quick(filename); - dumb_it_do_initial_runthrough(duh); - return duh; +DUH *dumb_load_ptm(const char *filename) { + DUH *duh = dumb_load_ptm_quick(filename); + dumb_it_do_initial_runthrough(duh); + return duh; } diff --git a/Frameworks/Dumb/dumb/src/it/loadriff.c b/Frameworks/Dumb/dumb/src/it/loadriff.c index 07994b0fc..8a9fa2b1d 100644 --- a/Frameworks/Dumb/dumb/src/it/loadriff.c +++ b/Frameworks/Dumb/dumb/src/it/loadriff.c @@ -20,23 +20,20 @@ #include "dumb.h" #include "internal/it.h" - - /* dumb_load_riff_quick(): loads a RIFF file into a DUH struct, returning * a pointer to the DUH struct. When you have finished with it, you must * pass the pointer to unload_duh() so that the memory can be freed. */ -DUH * dumb_load_riff_quick( const char *filename ) -{ - DUH * duh; - DUMBFILE * f = dumbfile_open( filename ); +DUH *dumb_load_riff_quick(const char *filename) { + DUH *duh; + DUMBFILE *f = dumbfile_open(filename); - if ( ! f ) - return NULL; + if (!f) + return NULL; - duh = dumb_read_riff_quick( f ); + duh = dumb_read_riff_quick(f); - dumbfile_close( f ); + dumbfile_close(f); - return duh; + return duh; } diff --git a/Frameworks/Dumb/dumb/src/it/loadriff2.c b/Frameworks/Dumb/dumb/src/it/loadriff2.c index 11c5d4974..5b818c5ef 100644 --- a/Frameworks/Dumb/dumb/src/it/loadriff2.c +++ b/Frameworks/Dumb/dumb/src/it/loadriff2.c @@ -19,11 +19,8 @@ #include "dumb.h" - - -DUH *dumb_load_riff(const char *filename) -{ - DUH *duh = dumb_load_riff_quick(filename); - dumb_it_do_initial_runthrough(duh); - return duh; +DUH *dumb_load_riff(const char *filename) { + DUH *duh = dumb_load_riff_quick(filename); + dumb_it_do_initial_runthrough(duh); + return duh; } diff --git a/Frameworks/Dumb/dumb/src/it/loads3m.c b/Frameworks/Dumb/dumb/src/it/loads3m.c index 41af114ea..69c8a3348 100644 --- a/Frameworks/Dumb/dumb/src/it/loads3m.c +++ b/Frameworks/Dumb/dumb/src/it/loads3m.c @@ -20,23 +20,20 @@ #include "dumb.h" #include "internal/it.h" - - /* dumb_load_s3m_quick(): loads an S3M file into a DUH struct, returning * a pointer to the DUH struct. When you have finished with it, you must * pass the pointer to unload_duh() so that the memory can be freed. */ -DUH *dumb_load_s3m_quick(const char *filename) -{ - DUH *duh; - DUMBFILE *f = dumbfile_open(filename); +DUH *dumb_load_s3m_quick(const char *filename) { + DUH *duh; + DUMBFILE *f = dumbfile_open(filename); - if (!f) - return NULL; + if (!f) + return NULL; - duh = dumb_read_s3m_quick(f); + duh = dumb_read_s3m_quick(f); - dumbfile_close(f); + dumbfile_close(f); - return duh; + return duh; } diff --git a/Frameworks/Dumb/dumb/src/it/loads3m2.c b/Frameworks/Dumb/dumb/src/it/loads3m2.c index de81e09a2..82eaf0546 100644 --- a/Frameworks/Dumb/dumb/src/it/loads3m2.c +++ b/Frameworks/Dumb/dumb/src/it/loads3m2.c @@ -19,11 +19,8 @@ #include "dumb.h" - - -DUH *dumb_load_s3m(const char *filename) -{ - DUH *duh = dumb_load_s3m_quick(filename); - dumb_it_do_initial_runthrough(duh); - return duh; +DUH *dumb_load_s3m(const char *filename) { + DUH *duh = dumb_load_s3m_quick(filename); + dumb_it_do_initial_runthrough(duh); + return duh; } diff --git a/Frameworks/Dumb/dumb/src/it/loadstm.c b/Frameworks/Dumb/dumb/src/it/loadstm.c index 847852082..d5e6b0323 100644 --- a/Frameworks/Dumb/dumb/src/it/loadstm.c +++ b/Frameworks/Dumb/dumb/src/it/loadstm.c @@ -20,23 +20,20 @@ #include "dumb.h" #include "internal/it.h" - - /* dumb_load_stm_quick(): loads an STM file into a DUH struct, returning a * pointer to the DUH struct. When you have finished with it, you must * pass the pointer to unload_duh() so that the memory can be freed. */ -DUH *dumb_load_stm_quick(const char *filename) -{ - DUH *duh; - DUMBFILE *f = dumbfile_open(filename); +DUH *dumb_load_stm_quick(const char *filename) { + DUH *duh; + DUMBFILE *f = dumbfile_open(filename); - if (!f) - return NULL; + if (!f) + return NULL; - duh = dumb_read_stm_quick(f); + duh = dumb_read_stm_quick(f); - dumbfile_close(f); + dumbfile_close(f); - return duh; + return duh; } diff --git a/Frameworks/Dumb/dumb/src/it/loadstm2.c b/Frameworks/Dumb/dumb/src/it/loadstm2.c index 4655b52d0..22203890c 100644 --- a/Frameworks/Dumb/dumb/src/it/loadstm2.c +++ b/Frameworks/Dumb/dumb/src/it/loadstm2.c @@ -19,11 +19,8 @@ #include "dumb.h" - - -DUH *dumb_load_stm(const char *filename) -{ - DUH *duh = dumb_load_stm_quick(filename); - dumb_it_do_initial_runthrough(duh); - return duh; +DUH *dumb_load_stm(const char *filename) { + DUH *duh = dumb_load_stm_quick(filename); + dumb_it_do_initial_runthrough(duh); + return duh; } diff --git a/Frameworks/Dumb/dumb/src/it/loadxm.c b/Frameworks/Dumb/dumb/src/it/loadxm.c index a0eba6162..26bb76c4d 100644 --- a/Frameworks/Dumb/dumb/src/it/loadxm.c +++ b/Frameworks/Dumb/dumb/src/it/loadxm.c @@ -20,23 +20,20 @@ #include "dumb.h" #include "internal/it.h" - - /* dumb_load_xm_quick(): loads an XM file into a DUH struct, returning a * pointer to the DUH struct. When you have finished with it, you must * pass the pointer to unload_duh() so that the memory can be freed. */ -DUH *dumb_load_xm_quick(const char *filename) -{ - DUH *duh; - DUMBFILE *f = dumbfile_open(filename); +DUH *dumb_load_xm_quick(const char *filename) { + DUH *duh; + DUMBFILE *f = dumbfile_open(filename); - if (!f) - return NULL; + if (!f) + return NULL; - duh = dumb_read_xm_quick(f); + duh = dumb_read_xm_quick(f); - dumbfile_close(f); + dumbfile_close(f); - return duh; + return duh; } diff --git a/Frameworks/Dumb/dumb/src/it/loadxm2.c b/Frameworks/Dumb/dumb/src/it/loadxm2.c index 242a586d4..a1f08935e 100644 --- a/Frameworks/Dumb/dumb/src/it/loadxm2.c +++ b/Frameworks/Dumb/dumb/src/it/loadxm2.c @@ -19,11 +19,8 @@ #include "dumb.h" - - -DUH *dumb_load_xm(const char *filename) -{ - DUH *duh = dumb_load_xm_quick(filename); - dumb_it_do_initial_runthrough(duh); - return duh; +DUH *dumb_load_xm(const char *filename) { + DUH *duh = dumb_load_xm_quick(filename); + dumb_it_do_initial_runthrough(duh); + return duh; } diff --git a/Frameworks/Dumb/dumb/src/it/ptmeffect.c b/Frameworks/Dumb/dumb/src/it/ptmeffect.c index b05a5d744..281ef7811 100644 --- a/Frameworks/Dumb/dumb/src/it/ptmeffect.c +++ b/Frameworks/Dumb/dumb/src/it/ptmeffect.c @@ -17,109 +17,158 @@ * \__/ */ - - #include #include #include "dumb.h" #include "internal/it.h" -void _dumb_it_ptm_convert_effect(int effect, int value, IT_ENTRY *entry) -{ - if (effect >= PTM_N_EFFECTS) - return; +void _dumb_it_ptm_convert_effect(int effect, int value, IT_ENTRY *entry) { + if (effect >= PTM_N_EFFECTS) + return; - /* Linearisation of the effect number... */ - if (effect == PTM_E) { - effect = PTM_EBASE + HIGH(value); - value = LOW(value); - } + /* Linearisation of the effect number... */ + if (effect == PTM_E) { + effect = PTM_EBASE + HIGH(value); + value = LOW(value); + } - /* convert effect */ - entry->mask |= IT_ENTRY_EFFECT; - switch (effect) { + /* convert effect */ + entry->mask |= IT_ENTRY_EFFECT; + switch (effect) { - case PTM_APPREGIO: effect = IT_ARPEGGIO; break; - case PTM_PORTAMENTO_UP: effect = IT_PORTAMENTO_UP; break; - case PTM_PORTAMENTO_DOWN: effect = IT_PORTAMENTO_DOWN; break; - case PTM_TONE_PORTAMENTO: effect = IT_TONE_PORTAMENTO; break; - case PTM_VIBRATO: effect = IT_VIBRATO; break; - case PTM_VOLSLIDE_TONEPORTA: effect = IT_VOLSLIDE_TONEPORTA; break; - case PTM_VOLSLIDE_VIBRATO: effect = IT_VOLSLIDE_VIBRATO; break; - case PTM_TREMOLO: effect = IT_TREMOLO; break; - case PTM_SAMPLE_OFFSET: effect = IT_SET_SAMPLE_OFFSET; break; - case PTM_VOLUME_SLIDE: effect = IT_VOLUME_SLIDE; break; - case PTM_POSITION_JUMP: effect = IT_JUMP_TO_ORDER; break; - case PTM_SET_CHANNEL_VOLUME: effect = IT_SET_CHANNEL_VOLUME; break; - case PTM_PATTERN_BREAK: effect = IT_BREAK_TO_ROW; break; - case PTM_SET_GLOBAL_VOLUME: effect = IT_SET_GLOBAL_VOLUME; break; - case PTM_RETRIGGER: effect = IT_RETRIGGER_NOTE; break; - case PTM_FINE_VIBRATO: effect = IT_FINE_VIBRATO; break; + case PTM_APPREGIO: + effect = IT_ARPEGGIO; + break; + case PTM_PORTAMENTO_UP: + effect = IT_PORTAMENTO_UP; + break; + case PTM_PORTAMENTO_DOWN: + effect = IT_PORTAMENTO_DOWN; + break; + case PTM_TONE_PORTAMENTO: + effect = IT_TONE_PORTAMENTO; + break; + case PTM_VIBRATO: + effect = IT_VIBRATO; + break; + case PTM_VOLSLIDE_TONEPORTA: + effect = IT_VOLSLIDE_TONEPORTA; + break; + case PTM_VOLSLIDE_VIBRATO: + effect = IT_VOLSLIDE_VIBRATO; + break; + case PTM_TREMOLO: + effect = IT_TREMOLO; + break; + case PTM_SAMPLE_OFFSET: + effect = IT_SET_SAMPLE_OFFSET; + break; + case PTM_VOLUME_SLIDE: + effect = IT_VOLUME_SLIDE; + break; + case PTM_POSITION_JUMP: + effect = IT_JUMP_TO_ORDER; + break; + case PTM_SET_CHANNEL_VOLUME: + effect = IT_SET_CHANNEL_VOLUME; + break; + case PTM_PATTERN_BREAK: + effect = IT_BREAK_TO_ROW; + break; + case PTM_SET_GLOBAL_VOLUME: + effect = IT_SET_GLOBAL_VOLUME; + break; + case PTM_RETRIGGER: + effect = IT_RETRIGGER_NOTE; + break; + case PTM_FINE_VIBRATO: + effect = IT_FINE_VIBRATO; + break; - /* TODO properly */ - case PTM_NOTE_SLIDE_UP: effect = IT_PTM_NOTE_SLIDE_UP; break; - case PTM_NOTE_SLIDE_DOWN: effect = IT_PTM_NOTE_SLIDE_DOWN; break; - case PTM_NOTE_SLIDE_UP_RETRIG: effect = IT_PTM_NOTE_SLIDE_UP_RETRIG; break; - case PTM_NOTE_SLIDE_DOWN_RETRIG: effect = IT_PTM_NOTE_SLIDE_DOWN_RETRIG; break; + /* TODO properly */ + case PTM_NOTE_SLIDE_UP: + effect = IT_PTM_NOTE_SLIDE_UP; + break; + case PTM_NOTE_SLIDE_DOWN: + effect = IT_PTM_NOTE_SLIDE_DOWN; + break; + case PTM_NOTE_SLIDE_UP_RETRIG: + effect = IT_PTM_NOTE_SLIDE_UP_RETRIG; + break; + case PTM_NOTE_SLIDE_DOWN_RETRIG: + effect = IT_PTM_NOTE_SLIDE_DOWN_RETRIG; + break; - case PTM_SET_TEMPO_BPM: - effect = (value < 0x20) ? (IT_SET_SPEED) : (IT_SET_SONG_TEMPO); - break; + case PTM_SET_TEMPO_BPM: + effect = (value < 0x20) ? (IT_SET_SPEED) : (IT_SET_SONG_TEMPO); + break; - case PTM_EBASE+PTM_E_SET_FINETUNE: effect = SBASE+IT_S_FINETUNE; break; /** TODO */ - case PTM_EBASE+PTM_E_SET_LOOP: effect = SBASE+IT_S_PATTERN_LOOP; break; - case PTM_EBASE+PTM_E_NOTE_CUT: effect = SBASE+IT_S_DELAYED_NOTE_CUT; break; - case PTM_EBASE+PTM_E_NOTE_DELAY: effect = SBASE+IT_S_NOTE_DELAY; break; - case PTM_EBASE+PTM_E_PATTERN_DELAY: effect = SBASE+IT_S_PATTERN_DELAY; break; - case PTM_EBASE+PTM_E_SET_PANNING: effect = SBASE+IT_S_SET_PAN; break; + case PTM_EBASE + PTM_E_SET_FINETUNE: + effect = SBASE + IT_S_FINETUNE; + break; /** TODO */ + case PTM_EBASE + PTM_E_SET_LOOP: + effect = SBASE + IT_S_PATTERN_LOOP; + break; + case PTM_EBASE + PTM_E_NOTE_CUT: + effect = SBASE + IT_S_DELAYED_NOTE_CUT; + break; + case PTM_EBASE + PTM_E_NOTE_DELAY: + effect = SBASE + IT_S_NOTE_DELAY; + break; + case PTM_EBASE + PTM_E_PATTERN_DELAY: + effect = SBASE + IT_S_PATTERN_DELAY; + break; + case PTM_EBASE + PTM_E_SET_PANNING: + effect = SBASE + IT_S_SET_PAN; + break; - case PTM_EBASE+PTM_E_FINE_VOLSLIDE_UP: - effect = IT_VOLUME_SLIDE; - value = EFFECT_VALUE(value, 0xF); - break; + case PTM_EBASE + PTM_E_FINE_VOLSLIDE_UP: + effect = IT_VOLUME_SLIDE; + value = EFFECT_VALUE(value, 0xF); + break; - case PTM_EBASE + PTM_E_FINE_VOLSLIDE_DOWN: - effect = IT_VOLUME_SLIDE; - value = EFFECT_VALUE(0xF, value); - break; + case PTM_EBASE + PTM_E_FINE_VOLSLIDE_DOWN: + effect = IT_VOLUME_SLIDE; + value = EFFECT_VALUE(0xF, value); + break; - case PTM_EBASE + PTM_E_FINE_PORTA_UP: - effect = IT_PORTAMENTO_UP; - value = EFFECT_VALUE(0xF, value); - break; + case PTM_EBASE + PTM_E_FINE_PORTA_UP: + effect = IT_PORTAMENTO_UP; + value = EFFECT_VALUE(0xF, value); + break; - case PTM_EBASE + PTM_E_FINE_PORTA_DOWN: - effect = IT_PORTAMENTO_DOWN; - value = EFFECT_VALUE(0xF, value); - break; + case PTM_EBASE + PTM_E_FINE_PORTA_DOWN: + effect = IT_PORTAMENTO_DOWN; + value = EFFECT_VALUE(0xF, value); + break; - case PTM_EBASE + PTM_E_RETRIG_NOTE: - effect = IT_XM_RETRIGGER_NOTE; - value = EFFECT_VALUE(0, value); - break; + case PTM_EBASE + PTM_E_RETRIG_NOTE: + effect = IT_XM_RETRIGGER_NOTE; + value = EFFECT_VALUE(0, value); + break; - case PTM_EBASE + PTM_E_SET_VIBRATO_CONTROL: - effect = SBASE+IT_S_SET_VIBRATO_WAVEFORM; - value &= ~4; /** TODO: value&4 -> don't retrig wave */ - break; + case PTM_EBASE + PTM_E_SET_VIBRATO_CONTROL: + effect = SBASE + IT_S_SET_VIBRATO_WAVEFORM; + value &= ~4; /** TODO: value&4 -> don't retrig wave */ + break; - case PTM_EBASE + PTM_E_SET_TREMOLO_CONTROL: - effect = SBASE+IT_S_SET_TREMOLO_WAVEFORM; - value &= ~4; /** TODO: value&4 -> don't retrig wave */ - break; + case PTM_EBASE + PTM_E_SET_TREMOLO_CONTROL: + effect = SBASE + IT_S_SET_TREMOLO_WAVEFORM; + value &= ~4; /** TODO: value&4 -> don't retrig wave */ + break; - default: - /* user effect (often used in demos for synchronisation) */ - entry->mask &= ~IT_ENTRY_EFFECT; - } + default: + /* user effect (often used in demos for synchronisation) */ + entry->mask &= ~IT_ENTRY_EFFECT; + } - /* Inverse linearisation... */ - if (effect >= SBASE && effect < SBASE+16) { - value = EFFECT_VALUE(effect-SBASE, value); - effect = IT_S; - } + /* Inverse linearisation... */ + if (effect >= SBASE && effect < SBASE + 16) { + value = EFFECT_VALUE(effect - SBASE, value); + effect = IT_S; + } - entry->effect = effect; - entry->effectvalue = value; + entry->effect = effect; + entry->effectvalue = value; } diff --git a/Frameworks/Dumb/dumb/src/it/read669.c b/Frameworks/Dumb/dumb/src/it/read669.c index 7660073aa..849f200a4 100644 --- a/Frameworks/Dumb/dumb/src/it/read669.c +++ b/Frameworks/Dumb/dumb/src/it/read669.c @@ -24,102 +24,108 @@ #include "dumb.h" #include "internal/it.h" +static int it_669_read_pattern(IT_PATTERN *pattern, DUMBFILE *f, int tempo, + int breakpoint, unsigned char *buffer, + int *used_channels) { + int pos; + int channel; + int row; + IT_ENTRY *entry; - -static int it_669_read_pattern(IT_PATTERN *pattern, DUMBFILE *f, int tempo, int breakpoint, unsigned char *buffer, int * used_channels) -{ - int pos; - int channel; - int row; - IT_ENTRY *entry; - - pattern->n_rows = 64; + pattern->n_rows = 64; if (dumbfile_getnc((char *)buffer, 64 * 3 * 8, f) < 64 * 3 * 8) - return -1; + return -1; - /* compute number of entries */ - pattern->n_entries = 64 + 1; /* Account for the row end markers, speed command */ - if (breakpoint < 63) pattern->n_entries++; /* and break to row 0 */ + /* compute number of entries */ + pattern->n_entries = + 64 + 1; /* Account for the row end markers, speed command */ + if (breakpoint < 63) + pattern->n_entries++; /* and break to row 0 */ - pos = 0; - for (row = 0; row < 64; row++) { - for (channel = 0; channel < 8; channel++) { - if (buffer[pos+0] != 0xFF || buffer[pos+2] != 0xFF) - pattern->n_entries++; - pos += 3; - } - } + pos = 0; + for (row = 0; row < 64; row++) { + for (channel = 0; channel < 8; channel++) { + if (buffer[pos + 0] != 0xFF || buffer[pos + 2] != 0xFF) + pattern->n_entries++; + pos += 3; + } + } - pattern->entry = malloc(pattern->n_entries * sizeof(*pattern->entry)); - if (!pattern->entry) - return -1; + pattern->entry = malloc(pattern->n_entries * sizeof(*pattern->entry)); + if (!pattern->entry) + return -1; - if (breakpoint == 63) breakpoint++; + if (breakpoint == 63) + breakpoint++; - entry = pattern->entry; + entry = pattern->entry; - entry->channel = 8; - entry->mask = IT_ENTRY_EFFECT; - entry->effect = IT_SET_SPEED; - entry->effectvalue = tempo; - entry++; + entry->channel = 8; + entry->mask = IT_ENTRY_EFFECT; + entry->effect = IT_SET_SPEED; + entry->effectvalue = tempo; + entry++; - pos = 0; - for (row = 0; row < 64; row++) { + pos = 0; + for (row = 0; row < 64; row++) { - if (row == breakpoint) { - entry->channel = 8; - entry->mask = IT_ENTRY_EFFECT; - entry->effect = IT_BREAK_TO_ROW; - entry->effectvalue = 0; - entry++; - } + if (row == breakpoint) { + entry->channel = 8; + entry->mask = IT_ENTRY_EFFECT; + entry->effect = IT_BREAK_TO_ROW; + entry->effectvalue = 0; + entry++; + } - for (channel = 0; channel < 8; channel++) { - if (buffer[pos+0] != 0xFF || buffer[pos+2] != 0xFF) { - entry->channel = channel; - entry->mask = 0; + for (channel = 0; channel < 8; channel++) { + if (buffer[pos + 0] != 0xFF || buffer[pos + 2] != 0xFF) { + entry->channel = channel; + entry->mask = 0; - if (buffer[pos+0] < 0xFE) { - entry->mask |= IT_ENTRY_NOTE | IT_ENTRY_INSTRUMENT; - entry->note = (buffer[pos+0] >> 2) + 36; - entry->instrument = (((buffer[pos+0] << 4) | (buffer[pos+1] >> 4)) & 0x3F) + 1; - } - if (buffer[pos+0] <= 0xFE) { - entry->mask |= IT_ENTRY_VOLPAN; - entry->volpan = ((buffer[pos+1] & 15) << 6) / 15; - if (*used_channels < channel + 1) *used_channels = channel + 1; - } - if (buffer[pos+2] != 0xFF) { - entry->mask |= IT_ENTRY_EFFECT; - entry->effectvalue = buffer[pos+2] & 15; - switch (buffer[pos+2] >> 4) { - case 0: - entry->effect = IT_PORTAMENTO_UP; - break; - case 1: - entry->effect = IT_PORTAMENTO_DOWN; - break; - case 2: - entry->effect = IT_TONE_PORTAMENTO; - break; - case 3: - entry->effect = IT_S; - entry->effectvalue += IT_S_FINETUNE * 16 + 8; - break; - case 4: - entry->effect = IT_VIBRATO; - // XXX speed unknown - entry->effectvalue |= 0x10; - break; - case 5: - if (entry->effectvalue) { - entry->effect = IT_SET_SPEED; - } else { - entry->mask &= ~IT_ENTRY_EFFECT; - } - break; + if (buffer[pos + 0] < 0xFE) { + entry->mask |= IT_ENTRY_NOTE | IT_ENTRY_INSTRUMENT; + entry->note = (buffer[pos + 0] >> 2) + 36; + entry->instrument = + (((buffer[pos + 0] << 4) | (buffer[pos + 1] >> 4)) & + 0x3F) + + 1; + } + if (buffer[pos + 0] <= 0xFE) { + entry->mask |= IT_ENTRY_VOLPAN; + entry->volpan = ((buffer[pos + 1] & 15) << 6) / 15; + if (*used_channels < channel + 1) + *used_channels = channel + 1; + } + if (buffer[pos + 2] != 0xFF) { + entry->mask |= IT_ENTRY_EFFECT; + entry->effectvalue = buffer[pos + 2] & 15; + switch (buffer[pos + 2] >> 4) { + case 0: + entry->effect = IT_PORTAMENTO_UP; + break; + case 1: + entry->effect = IT_PORTAMENTO_DOWN; + break; + case 2: + entry->effect = IT_TONE_PORTAMENTO; + break; + case 3: + entry->effect = IT_S; + entry->effectvalue += IT_S_FINETUNE * 16 + 8; + break; + case 4: + entry->effect = IT_VIBRATO; + // XXX speed unknown + entry->effectvalue |= 0x10; + break; + case 5: + if (entry->effectvalue) { + entry->effect = IT_SET_SPEED; + } else { + entry->mask &= ~IT_ENTRY_EFFECT; + } + break; #if 0 /* dunno about this, really... */ case 6: @@ -134,315 +140,312 @@ static int it_669_read_pattern(IT_PATTERN *pattern, DUMBFILE *f, int tempo, int } break; #endif - default: - entry->mask &= ~IT_ENTRY_EFFECT; - break; - } - if (*used_channels < channel + 1) *used_channels = channel + 1; - } + default: + entry->mask &= ~IT_ENTRY_EFFECT; + break; + } + if (*used_channels < channel + 1) + *used_channels = channel + 1; + } - entry++; - } - pos += 3; - } - IT_SET_END_ROW(entry); - entry++; - } + entry++; + } + pos += 3; + } + IT_SET_END_ROW(entry); + entry++; + } - return 0; + return 0; } - - -static int it_669_read_sample_header(IT_SAMPLE *sample, DUMBFILE *f) -{ +static int it_669_read_sample_header(IT_SAMPLE *sample, DUMBFILE *f) { dumbfile_getnc((char *)sample->name, 13, f); - sample->name[13] = 0; + sample->name[13] = 0; - sample->filename[0] = 0; + sample->filename[0] = 0; - sample->length = dumbfile_igetl(f); - sample->loop_start = dumbfile_igetl(f); - sample->loop_end = dumbfile_igetl(f); + sample->length = dumbfile_igetl(f); + sample->loop_start = dumbfile_igetl(f); + sample->loop_end = dumbfile_igetl(f); - if (dumbfile_error(f)) - return -1; + if (dumbfile_error(f)) + return -1; - if (sample->length <= 0) { - sample->flags = 0; - return 0; - } + if (sample->length <= 0) { + sample->flags = 0; + return 0; + } - sample->flags = IT_SAMPLE_EXISTS; + sample->flags = IT_SAMPLE_EXISTS; - sample->global_volume = 64; - sample->default_volume = 64; + sample->global_volume = 64; + sample->default_volume = 64; - sample->default_pan = 0; - sample->C5_speed = 8363; - // the above line might be wrong + sample->default_pan = 0; + sample->C5_speed = 8363; + // the above line might be wrong - if ((sample->loop_end > sample->length) && !(sample->loop_start)) - sample->loop_end = 0; + if ((sample->loop_end > sample->length) && !(sample->loop_start)) + sample->loop_end = 0; - if (sample->loop_end > sample->length) - sample->loop_end = sample->length; + if (sample->loop_end > sample->length) + sample->loop_end = sample->length; - if (sample->loop_end - sample->loop_start > 2) - sample->flags |= IT_SAMPLE_LOOP; + if (sample->loop_end - sample->loop_start > 2) + sample->flags |= IT_SAMPLE_LOOP; - sample->vibrato_speed = 0; - sample->vibrato_depth = 0; - sample->vibrato_rate = 0; - sample->vibrato_waveform = 0; // do we have to set _all_ these? - sample->finetune = 0; - sample->max_resampling_quality = -1; + sample->vibrato_speed = 0; + sample->vibrato_depth = 0; + sample->vibrato_rate = 0; + sample->vibrato_waveform = 0; // do we have to set _all_ these? + sample->finetune = 0; + sample->max_resampling_quality = -1; - return 0; + return 0; } +static int it_669_read_sample_data(IT_SAMPLE *sample, DUMBFILE *f) { + long i; + long truncated_size; + /* let's get rid of the sample data coming after the end of the loop */ + if ((sample->flags & IT_SAMPLE_LOOP) && sample->loop_end < sample->length) { + truncated_size = sample->length - sample->loop_end; + sample->length = sample->loop_end; + } else { + truncated_size = 0; + } -static int it_669_read_sample_data(IT_SAMPLE *sample, DUMBFILE *f) -{ - long i; - long truncated_size; + sample->data = malloc(sample->length); - /* let's get rid of the sample data coming after the end of the loop */ - if ((sample->flags & IT_SAMPLE_LOOP) && sample->loop_end < sample->length) { - truncated_size = sample->length - sample->loop_end; - sample->length = sample->loop_end; - } else { - truncated_size = 0; - } + if (!sample->data) + return -1; - sample->data = malloc(sample->length); + if (sample->length) { + i = dumbfile_getnc(sample->data, sample->length, f); - if (!sample->data) - return -1; + if (i < sample->length) { + // return -1; + // ficking truncated files + if (i <= 0) { + sample->flags = 0; + return 0; + } + sample->length = i; + if (sample->loop_end > i) + sample->loop_end = i; + } else { + /* skip truncated data */ + dumbfile_skip(f, truncated_size); + // Should we be truncating it? + if (dumbfile_error(f)) + return -1; + } - if (sample->length) - { - i = dumbfile_getnc(sample->data, sample->length, f); - - if (i < sample->length) { - //return -1; - // ficking truncated files - if (i <= 0) { - sample->flags = 0; - return 0; - } - sample->length = i; - if (sample->loop_end > i) sample->loop_end = i; - } else { - /* skip truncated data */ - dumbfile_skip(f, truncated_size); - // Should we be truncating it? - if (dumbfile_error(f)) - return -1; - } + for (i = 0; i < sample->length; i++) + ((signed char *)sample->data)[i] ^= 0x80; + } - for (i = 0; i < sample->length; i++) - ((signed char *)sample->data)[i] ^= 0x80; - } - - return 0; + return 0; } +static DUMB_IT_SIGDATA *it_669_load_sigdata(DUMBFILE *f, int *ext) { + DUMB_IT_SIGDATA *sigdata; + int n_channels; + int i; + unsigned char tempolist[128]; + unsigned char breaklist[128]; -static DUMB_IT_SIGDATA *it_669_load_sigdata(DUMBFILE *f, int * ext) -{ - DUMB_IT_SIGDATA *sigdata; - int n_channels; - int i; - unsigned char tempolist[128]; - unsigned char breaklist[128]; + i = dumbfile_igetw(f); + if (i != 0x6669 && i != 0x4E4A) + return NULL; - i = dumbfile_igetw(f); - if (i != 0x6669 && i != 0x4E4A) return NULL; + *ext = (i == 0x4E4A); - *ext = (i == 0x4E4A); - - sigdata = malloc(sizeof(*sigdata)); - if (!sigdata) { - return NULL; - } + sigdata = malloc(sizeof(*sigdata)); + if (!sigdata) { + return NULL; + } if (dumbfile_getnc((char *)sigdata->name, 36, f) < 36) { - free(sigdata); - return NULL; - } - sigdata->name[36] = 0; + free(sigdata); + return NULL; + } + sigdata->name[36] = 0; - sigdata->order = NULL; - sigdata->instrument = NULL; - sigdata->pattern = NULL; - sigdata->midi = NULL; - sigdata->checkpoint = NULL; - sigdata->sample = NULL; + sigdata->order = NULL; + sigdata->instrument = NULL; + sigdata->pattern = NULL; + sigdata->midi = NULL; + sigdata->checkpoint = NULL; + sigdata->sample = NULL; - sigdata->n_instruments = 0; + sigdata->n_instruments = 0; - sigdata->song_message = malloc(72 + 2 + 1); - if (!sigdata->song_message) { - free(sigdata); - return NULL; - } + sigdata->song_message = malloc(72 + 2 + 1); + if (!sigdata->song_message) { + free(sigdata); + return NULL; + } if (dumbfile_getnc((char *)sigdata->song_message, 36, f) < 36) { - _dumb_it_unload_sigdata(sigdata); - return NULL; - } - sigdata->song_message[36] = 13; - sigdata->song_message[36 + 1] = 10; + _dumb_it_unload_sigdata(sigdata); + return NULL; + } + sigdata->song_message[36] = 13; + sigdata->song_message[36 + 1] = 10; if (dumbfile_getnc((char *)sigdata->song_message + 38, 36, f) < 36) { - _dumb_it_unload_sigdata(sigdata); - return NULL; - } - sigdata->song_message[38 + 36] = 0; + _dumb_it_unload_sigdata(sigdata); + return NULL; + } + sigdata->song_message[38 + 36] = 0; - sigdata->n_samples = dumbfile_getc(f); - sigdata->n_patterns = dumbfile_getc(f); - sigdata->restart_position = dumbfile_getc(f); + sigdata->n_samples = dumbfile_getc(f); + sigdata->n_patterns = dumbfile_getc(f); + sigdata->restart_position = dumbfile_getc(f); - if ((sigdata->n_samples) > 64 || (sigdata->n_patterns > 128)) { - _dumb_it_unload_sigdata(sigdata); - return NULL; - } + if ((sigdata->n_samples) > 64 || (sigdata->n_patterns > 128)) { + _dumb_it_unload_sigdata(sigdata); + return NULL; + } - sigdata->order = malloc(128); /* We may need to scan the extra ones! */ - if (!sigdata->order) { - _dumb_it_unload_sigdata(sigdata); - return NULL; - } + sigdata->order = malloc(128); /* We may need to scan the extra ones! */ + if (!sigdata->order) { + _dumb_it_unload_sigdata(sigdata); + return NULL; + } if (dumbfile_getnc((char *)sigdata->order, 128, f) < 128) { - _dumb_it_unload_sigdata(sigdata); - return NULL; - } + _dumb_it_unload_sigdata(sigdata); + return NULL; + } - for (i = 0; i < 128; i++) { - if (sigdata->order[i] == 255) break; - if (sigdata->order[i] >= sigdata->n_patterns) { - _dumb_it_unload_sigdata(sigdata); - return NULL; - } - } - if (!i) { - _dumb_it_unload_sigdata(sigdata); - return NULL; - } - sigdata->n_orders = i; + for (i = 0; i < 128; i++) { + if (sigdata->order[i] == 255) + break; + if (sigdata->order[i] >= sigdata->n_patterns) { + _dumb_it_unload_sigdata(sigdata); + return NULL; + } + } + if (!i) { + _dumb_it_unload_sigdata(sigdata); + return NULL; + } + sigdata->n_orders = i; if (dumbfile_getnc((char *)tempolist, 128, f) < 128) { - _dumb_it_unload_sigdata(sigdata); - return NULL; - } + _dumb_it_unload_sigdata(sigdata); + return NULL; + } if (dumbfile_getnc((char *)breaklist, 128, f) < 128) { - _dumb_it_unload_sigdata(sigdata); - return NULL; - } + _dumb_it_unload_sigdata(sigdata); + return NULL; + } - sigdata->sample = malloc(sigdata->n_samples * sizeof(*sigdata->sample)); - if (!sigdata->sample) { - _dumb_it_unload_sigdata(sigdata); - return NULL; - } + sigdata->sample = malloc(sigdata->n_samples * sizeof(*sigdata->sample)); + if (!sigdata->sample) { + _dumb_it_unload_sigdata(sigdata); + return NULL; + } - for (i = 0; i < sigdata->n_samples; i++) - sigdata->sample[i].data = NULL; + for (i = 0; i < sigdata->n_samples; i++) + sigdata->sample[i].data = NULL; - for (i = 0; i < sigdata->n_samples; i++) { - if (it_669_read_sample_header(&sigdata->sample[i], f)) { - _dumb_it_unload_sigdata(sigdata); - return NULL; - } - } + for (i = 0; i < sigdata->n_samples; i++) { + if (it_669_read_sample_header(&sigdata->sample[i], f)) { + _dumb_it_unload_sigdata(sigdata); + return NULL; + } + } - /* May as well try to save a tiny bit of memory. */ - if (sigdata->n_orders < 128) { - unsigned char *order = realloc(sigdata->order, sigdata->n_orders); - if (order) sigdata->order = order; - } + /* May as well try to save a tiny bit of memory. */ + if (sigdata->n_orders < 128) { + unsigned char *order = realloc(sigdata->order, sigdata->n_orders); + if (order) + sigdata->order = order; + } - sigdata->pattern = malloc(sigdata->n_patterns * sizeof(*sigdata->pattern)); - if (!sigdata->pattern) { - _dumb_it_unload_sigdata(sigdata); - return NULL; - } - for (i = 0; i < sigdata->n_patterns; i++) - sigdata->pattern[i].entry = NULL; + sigdata->pattern = malloc(sigdata->n_patterns * sizeof(*sigdata->pattern)); + if (!sigdata->pattern) { + _dumb_it_unload_sigdata(sigdata); + return NULL; + } + for (i = 0; i < sigdata->n_patterns; i++) + sigdata->pattern[i].entry = NULL; - n_channels = 0; + n_channels = 0; - /* Read in the patterns */ - { - unsigned char *buffer = malloc(64 * 3 * 8); /* 64 rows * 3 bytes * 8 channels */ - if (!buffer) { - _dumb_it_unload_sigdata(sigdata); - return NULL; - } - for (i = 0; i < sigdata->n_patterns; i++) { - if (it_669_read_pattern(&sigdata->pattern[i], f, tempolist[i], breaklist[i], buffer, &n_channels) != 0) { - free(buffer); - _dumb_it_unload_sigdata(sigdata); - return NULL; - } - } - free(buffer); - } + /* Read in the patterns */ + { + unsigned char *buffer = + malloc(64 * 3 * 8); /* 64 rows * 3 bytes * 8 channels */ + if (!buffer) { + _dumb_it_unload_sigdata(sigdata); + return NULL; + } + for (i = 0; i < sigdata->n_patterns; i++) { + if (it_669_read_pattern(&sigdata->pattern[i], f, tempolist[i], + breaklist[i], buffer, &n_channels) != 0) { + free(buffer); + _dumb_it_unload_sigdata(sigdata); + return NULL; + } + } + free(buffer); + } - sigdata->n_pchannels = n_channels; + sigdata->n_pchannels = n_channels; - /* And finally, the sample data */ - for (i = 0; i < sigdata->n_samples; i++) { - if (it_669_read_sample_data(&sigdata->sample[i], f)) { - _dumb_it_unload_sigdata(sigdata); - return NULL; - } - } + /* And finally, the sample data */ + for (i = 0; i < sigdata->n_samples; i++) { + if (it_669_read_sample_data(&sigdata->sample[i], f)) { + _dumb_it_unload_sigdata(sigdata); + return NULL; + } + } - /* Now let's initialise the remaining variables, and we're done! */ - sigdata->flags = IT_OLD_EFFECTS | IT_LINEAR_SLIDES | IT_STEREO | IT_WAS_A_669; + /* Now let's initialise the remaining variables, and we're done! */ + sigdata->flags = + IT_OLD_EFFECTS | IT_LINEAR_SLIDES | IT_STEREO | IT_WAS_A_669; - sigdata->global_volume = 128; - sigdata->mixing_volume = 48; - sigdata->speed = 4; - sigdata->tempo = 78; - sigdata->pan_separation = 128; + sigdata->global_volume = 128; + sigdata->mixing_volume = 48; + sigdata->speed = 4; + sigdata->tempo = 78; + sigdata->pan_separation = 128; - memset(sigdata->channel_volume, 64, DUMB_IT_N_CHANNELS); + memset(sigdata->channel_volume, 64, DUMB_IT_N_CHANNELS); - for (i = 0; i < DUMB_IT_N_CHANNELS; i += 2) { - int sep = 32 * dumb_it_default_panning_separation / 100; - sigdata->channel_pan[i+0] = 32 + sep; - sigdata->channel_pan[i+1] = 32 - sep; - } + for (i = 0; i < DUMB_IT_N_CHANNELS; i += 2) { + int sep = 32 * dumb_it_default_panning_separation / 100; + sigdata->channel_pan[i + 0] = 32 + sep; + sigdata->channel_pan[i + 1] = 32 - sep; + } - _dumb_it_fix_invalid_orders(sigdata); + _dumb_it_fix_invalid_orders(sigdata); - return sigdata; + return sigdata; } +DUH *dumb_read_669_quick(DUMBFILE *f) { + sigdata_t *sigdata; + int ext; + DUH_SIGTYPE_DESC *descptr = &_dumb_sigtype_it; -DUH *dumb_read_669_quick(DUMBFILE *f) -{ - sigdata_t *sigdata; - int ext; + sigdata = it_669_load_sigdata(f, &ext); - DUH_SIGTYPE_DESC *descptr = &_dumb_sigtype_it; + if (!sigdata) + return NULL; - sigdata = it_669_load_sigdata(f, &ext); - - if (!sigdata) - return NULL; - - { - const char *tag[2][2]; - tag[0][0] = "TITLE"; + { + const char *tag[2][2]; + tag[0][0] = "TITLE"; tag[0][1] = (const char *)(((DUMB_IT_SIGDATA *)sigdata)->name); - tag[1][0] = "FORMAT"; - tag[1][1] = ext ? "669 Extended" : "669"; - return make_duh(-1, 2, (const char *const (*)[2])tag, 1, &descptr, &sigdata); - } + tag[1][0] = "FORMAT"; + tag[1][1] = ext ? "669 Extended" : "669"; + return make_duh(-1, 2, (const char *const(*)[2])tag, 1, &descptr, + &sigdata); + } } diff --git a/Frameworks/Dumb/dumb/src/it/read6692.c b/Frameworks/Dumb/dumb/src/it/read6692.c index b5f4f2044..8a2adabd7 100644 --- a/Frameworks/Dumb/dumb/src/it/read6692.c +++ b/Frameworks/Dumb/dumb/src/it/read6692.c @@ -1,29 +1,26 @@ -/* _______ ____ __ ___ ___ - * \ _ \ \ / \ / \ \ / / ' ' ' - * | | \ \ | | || | \/ | . . - * | | | | | | || ||\ /| | - * | | | | | | || || \/ | | ' ' ' - * | | | | | | || || | | . . - * | |_/ / \ \__// || | | - * /_______/ynamic \____/niversal /__\ /____\usic /| . . ibliotheque - * / \ - * / . \ - * read6692.c - Code to read a 669 Composer module / / \ \ - * from an open file, and do an initial | < / \_ - * run-through. | \/ /\ / - * By Chris Moeller. \_ / > / - * | \ / / - * | ' / - * \__/ - */ - -#include "dumb.h" - - - -DUH *dumb_read_669(DUMBFILE *f) -{ - DUH *duh = dumb_read_669_quick(f); - dumb_it_do_initial_runthrough(duh); - return duh; -} +/* _______ ____ __ ___ ___ + * \ _ \ \ / \ / \ \ / / ' ' ' + * | | \ \ | | || | \/ | . . + * | | | | | | || ||\ /| | + * | | | | | | || || \/ | | ' ' ' + * | | | | | | || || | | . . + * | |_/ / \ \__// || | | + * /_______/ynamic \____/niversal /__\ /____\usic /| . . ibliotheque + * / \ + * / . \ + * read6692.c - Code to read a 669 Composer module / / \ \ + * from an open file, and do an initial | < / \_ + * run-through. | \/ /\ / + * By Chris Moeller. \_ / > / + * | \ / / + * | ' / + * \__/ + */ + +#include "dumb.h" + +DUH *dumb_read_669(DUMBFILE *f) { + DUH *duh = dumb_read_669_quick(f); + dumb_it_do_initial_runthrough(duh); + return duh; +} diff --git a/Frameworks/Dumb/dumb/src/it/readam.c b/Frameworks/Dumb/dumb/src/it/readam.c index 37d62e928..5dcabc532 100644 --- a/Frameworks/Dumb/dumb/src/it/readam.c +++ b/Frameworks/Dumb/dumb/src/it/readam.c @@ -24,766 +24,779 @@ #include "internal/it.h" #include "internal/riff.h" -static int it_riff_am_process_sample( IT_SAMPLE * sample, DUMBFILE * f, int len, int ver ) -{ - int header_length; - int default_pan; - int default_volume; - int flags; - int length; - int length_bytes; - int loop_start; - int loop_end; - int sample_rate; +static int it_riff_am_process_sample(IT_SAMPLE *sample, DUMBFILE *f, size_t len, + int ver) { + size_t header_length; + int default_pan; + int default_volume; + int flags; + size_t length; + size_t length_bytes; + size_t loop_start; + size_t loop_end; + size_t sample_rate; - long start = dumbfile_pos( f ); + long start = dumbfile_pos(f); - if ( ver == 0 ) - { - if ( len < 0x38 ) - return -1; + if (ver == 0) { + if (len < 0x38) + return -1; - header_length = 0x38; + header_length = 0x38; - dumbfile_getnc( (char *) sample->name, 28, f ); - sample->name[ 28 ] = 0; + dumbfile_getnc((char *)sample->name, 28, f); + sample->name[28] = 0; - default_pan = dumbfile_getc( f ); - default_volume = dumbfile_getc( f ); - flags = dumbfile_igetw( f ); - length = dumbfile_igetl( f ); - loop_start = dumbfile_igetl( f ); - loop_end = dumbfile_igetl( f ); - sample_rate = dumbfile_igetl( f ); - } - else - { - if (len < 4) return -1; + default_pan = dumbfile_getc(f); + default_volume = dumbfile_getc(f); + flags = dumbfile_igetw(f); + length = dumbfile_igetl(f); + loop_start = dumbfile_igetl(f); + loop_end = dumbfile_igetl(f); + sample_rate = dumbfile_igetl(f); + } else { + if (len < 4) + return -1; - header_length = dumbfile_igetl( f ); - if ( header_length < 0x40 ) - return -1; - if ( header_length + 4 > len ) - return -1; + header_length = dumbfile_igetl(f); + if (header_length < 0x40) + return -1; + if (header_length + 4 > len) + return -1; start += 4; - len -= 4; + len -= 4; - dumbfile_getnc( (char *) sample->name, 32, f ); + dumbfile_getnc((char *)sample->name, 32, f); - default_pan = dumbfile_igetw( f ); - default_volume = dumbfile_igetw( f ); - flags = dumbfile_igetw( f ); - dumbfile_skip( f, 2 ); - length = dumbfile_igetl( f ); - loop_start = dumbfile_igetl( f ); - loop_end = dumbfile_igetl( f ); - sample_rate = dumbfile_igetl( f ); + default_pan = dumbfile_igetw(f); + default_volume = dumbfile_igetw(f); + flags = dumbfile_igetw(f); + dumbfile_skip(f, 2); + length = dumbfile_igetl(f); + loop_start = dumbfile_igetl(f); + loop_end = dumbfile_igetl(f); + sample_rate = dumbfile_igetl(f); - if ( default_pan > 0x7FFF || default_volume > 0x7FFF ) - return -1; + if (default_pan > 0x7FFF || default_volume > 0x7FFF) + return -1; - default_pan = default_pan * 64 / 32767; - default_volume = default_volume * 64 / 32767; - } + default_pan = default_pan * 64 / 32767; + default_volume = default_volume * 64 / 32767; + } - if ( ! length ) { - sample->flags &= ~IT_SAMPLE_EXISTS; - return 0; - } + if (!length) { + sample->flags &= ~IT_SAMPLE_EXISTS; + return 0; + } - if ( flags & ~( 0x8000 | 0x80 | 0x20 | 0x10 | 0x08 | 0x04 ) ) - return -1; - - length_bytes = length << ( ( flags & 0x04 ) >> 2 ); - - if ( length_bytes + header_length > len ) - return -1; - - sample->flags = 0; - - if ( flags & 0x80 ) sample->flags |= IT_SAMPLE_EXISTS; - if ( flags & 0x04 ) sample->flags |= IT_SAMPLE_16BIT; - - sample->length = length; - sample->loop_start = loop_start; - sample->loop_end = loop_end; - sample->C5_speed = sample_rate; - sample->default_volume = default_volume; - sample->default_pan = default_pan | ( ( flags & 0x20 ) << 2 ); - sample->filename[0] = 0; - sample->global_volume = 64; - sample->vibrato_speed = 0; - sample->vibrato_depth = 0; - sample->vibrato_rate = 0; - sample->vibrato_waveform = IT_VIBRATO_SINE; - sample->finetune = 0; - sample->max_resampling_quality = -1; - - if ( flags & 0x08 ) - { - if (((unsigned int)sample->loop_end <= (unsigned int)sample->length) && - ((unsigned int)sample->loop_start < (unsigned int)sample->loop_end)) - { - sample->length = sample->loop_end; - sample->flags |= IT_SAMPLE_LOOP; - if ( flags & 0x10 ) sample->flags |= IT_SAMPLE_PINGPONG_LOOP; - } - } - - length_bytes = sample->length << ( ( flags & 0x04 ) >> 2 ); - - sample->data = malloc( length_bytes ); - if ( ! sample->data ) - return -1; - - if ( dumbfile_seek( f, start + header_length, DFS_SEEK_SET ) ) + if (flags & ~(0x8000 | 0x80 | 0x20 | 0x10 | 0x08 | 0x04)) return -1; - dumbfile_getnc( sample->data, length_bytes, f ); + length_bytes = length << ((flags & 0x04) >> 2); - return 0; + if (length_bytes + header_length > len) + return -1; + + sample->flags = 0; + + if (flags & 0x80) + sample->flags |= IT_SAMPLE_EXISTS; + if (flags & 0x04) + sample->flags |= IT_SAMPLE_16BIT; + + sample->length = length; + sample->loop_start = loop_start; + sample->loop_end = loop_end; + sample->C5_speed = sample_rate; + sample->default_volume = default_volume; + sample->default_pan = default_pan | ((flags & 0x20) << 2); + sample->filename[0] = 0; + sample->global_volume = 64; + sample->vibrato_speed = 0; + sample->vibrato_depth = 0; + sample->vibrato_rate = 0; + sample->vibrato_waveform = IT_VIBRATO_SINE; + sample->finetune = 0; + sample->max_resampling_quality = -1; + + if (flags & 0x08) { + if (((unsigned int)sample->loop_end <= (unsigned int)sample->length) && + ((unsigned int)sample->loop_start < + (unsigned int)sample->loop_end)) { + sample->length = sample->loop_end; + sample->flags |= IT_SAMPLE_LOOP; + if (flags & 0x10) + sample->flags |= IT_SAMPLE_PINGPONG_LOOP; + } + } + + length_bytes = sample->length << ((flags & 0x04) >> 2); + + sample->data = malloc(length_bytes); + if (!sample->data) + return -1; + + if (dumbfile_seek(f, start + header_length, DFS_SEEK_SET)) + return -1; + + dumbfile_getnc(sample->data, length_bytes, f); + + return 0; } -static int it_riff_am_process_pattern( IT_PATTERN * pattern, DUMBFILE * f, int len, int ver ) -{ +static int it_riff_am_process_pattern(IT_PATTERN *pattern, DUMBFILE *f, + size_t len, int ver) { int nrows, row; long start, end; - unsigned flags; + unsigned flags; int p, q, r; - IT_ENTRY * entry; + IT_ENTRY *entry; - nrows = dumbfile_getc( f ) + 1; + nrows = dumbfile_getc(f) + 1; - pattern->n_rows = nrows; + pattern->n_rows = nrows; - len -= 1; + len -= 1; - pattern->n_entries = 0; + pattern->n_entries = 0; - row = 0; + row = 0; - start = dumbfile_pos( f ); + start = dumbfile_pos(f); end = start + len; - while ( (row < nrows) && !dumbfile_error( f ) && (dumbfile_pos( f ) < end) ) { - p = dumbfile_getc( f ); - if ( ! p ) { - ++ row; - continue; - } + while ((row < nrows) && !dumbfile_error(f) && (dumbfile_pos(f) < end)) { + p = dumbfile_getc(f); + if (!p) { + ++row; + continue; + } flags = p & 0xE0; if (flags) { - ++ pattern->n_entries; - if (flags & 0x80) dumbfile_skip( f, 2 ); - if (flags & 0x40) dumbfile_skip( f, 2 ); - if (flags & 0x20) dumbfile_skip( f, 1 ); - } - } + ++pattern->n_entries; + if (flags & 0x80) + dumbfile_skip(f, 2); + if (flags & 0x40) + dumbfile_skip(f, 2); + if (flags & 0x20) + dumbfile_skip(f, 1); + } + } - if ( ! pattern->n_entries ) return 0; + if (!pattern->n_entries) + return 0; - pattern->n_entries += nrows; + pattern->n_entries += nrows; - pattern->entry = malloc( pattern->n_entries * sizeof( * pattern->entry ) ); - if ( ! pattern->entry ) return -1; + pattern->entry = malloc(pattern->n_entries * sizeof(*pattern->entry)); + if (!pattern->entry) + return -1; - entry = pattern->entry; + entry = pattern->entry; - row = 0; + row = 0; - dumbfile_seek( f, start, DFS_SEEK_SET ); + dumbfile_seek(f, start, DFS_SEEK_SET); - while ( ( row < nrows ) && !dumbfile_error( f ) && ( dumbfile_pos( f ) < end ) ) - { - p = dumbfile_getc( f ); + while ((row < nrows) && !dumbfile_error(f) && (dumbfile_pos(f) < end)) { + p = dumbfile_getc(f); - if ( ! p ) - { - IT_SET_END_ROW( entry ); - ++ entry; - ++ row; - continue; - } + if (!p) { + IT_SET_END_ROW(entry); + ++entry; + ++row; + continue; + } flags = p; - entry->channel = flags & 0x1F; - entry->mask = 0; + entry->channel = flags & 0x1F; + entry->mask = 0; - if (flags & 0xE0) - { - if ( flags & 0x80 ) - { - q = dumbfile_getc( f ); - r = dumbfile_getc( f ); - _dumb_it_xm_convert_effect( r, q, entry, 0 ); - } - - if ( flags & 0x40 ) - { - q = dumbfile_getc( f ); - r = dumbfile_getc( f ); - if ( q ) - { - entry->mask |= IT_ENTRY_INSTRUMENT; - entry->instrument = q; - } - if ( r ) - { - entry->mask |= IT_ENTRY_NOTE; - entry->note = r - 1; - } - } - - if ( flags & 0x20 ) - { - q = dumbfile_getc( f ); - entry->mask |= IT_ENTRY_VOLPAN; - if ( ver == 0 ) entry->volpan = q; - else entry->volpan = q * 64 / 127; - } - - if (entry->mask) entry++; - } - } - - while ( row < nrows ) - { - IT_SET_END_ROW( entry ); - ++ entry; - ++ row; - } - - pattern->n_entries = entry - pattern->entry; - if ( ! pattern->n_entries ) return -1; - - return 0; -} - -static DUMB_IT_SIGDATA *it_riff_amff_load_sigdata( DUMBFILE * f, struct riff * stream ) -{ - DUMB_IT_SIGDATA *sigdata; - - int n, o, p, found; - - if ( ! stream ) goto error; - - if ( stream->type != DUMB_ID( 'A', 'M', 'F', 'F' ) ) goto error; - - sigdata = malloc( sizeof( *sigdata ) ); - if ( ! sigdata ) goto error; - - sigdata->n_patterns = 0; - sigdata->n_samples = 0; - sigdata->name[0] = 0; - - found = 0; - - for ( n = 0; (unsigned)n < stream->chunk_count; ++n ) - { - struct riff_chunk * c = stream->chunks + n; - switch( c->type ) - { - case DUMB_ID( 'M', 'A', 'I', 'N' ): - /* initialization data */ - if ( ( found & 1 ) || ( c->size < 0x48 ) ) goto error_sd; - found |= 1; - break; - - case DUMB_ID( 'O', 'R', 'D', 'R' ): - if ( ( found & 2 ) || ( c->size < 1 ) ) goto error_sd; - found |= 2; - break; - - case DUMB_ID( 'P', 'A', 'T', 'T' ): - if ( dumbfile_seek( f, c->offset, DFS_SEEK_SET ) ) goto error_sd; - o = dumbfile_getc( f ); - if ( o >= sigdata->n_patterns ) sigdata->n_patterns = o + 1; - o = dumbfile_igetl( f ); - if ( (unsigned)o + 5 > c->size ) goto error_sd; - break; - - case DUMB_ID( 'I', 'N', 'S', 'T' ): - { - if ( c->size < 0xE1 ) goto error_sd; - if ( dumbfile_seek( f, c->offset + 1, DFS_SEEK_SET ) ) goto error_sd; - o = dumbfile_getc( f ); - if ( o >= sigdata->n_samples ) sigdata->n_samples = o + 1; - if ( c->size >= 0x121 ) - { - if ( dumbfile_seek( f, c->offset + 0xE1, DFS_SEEK_SET ) ) goto error_sd; - if ( dumbfile_mgetl( f ) == DUMB_ID('S','A','M','P') ) - { - unsigned size = dumbfile_igetl( f ); - if ( size + 0xE1 + 8 > c->size ) goto error_sd; - } - } - } - break; - } - } - - if ( found != 3 || !sigdata->n_samples || !sigdata->n_patterns ) goto error_sd; - - if ( sigdata->n_samples > 255 || sigdata->n_patterns > 255 ) goto error_sd; - - sigdata->song_message = NULL; - sigdata->order = NULL; - sigdata->instrument = NULL; - sigdata->sample = NULL; - sigdata->pattern = NULL; - sigdata->midi = NULL; - sigdata->checkpoint = NULL; - - sigdata->mixing_volume = 48; - sigdata->pan_separation = 128; - - sigdata->n_instruments = 0; - sigdata->n_orders = 0; - sigdata->restart_position = 0; - - memset(sigdata->channel_volume, 64, DUMB_IT_N_CHANNELS); - - for (n = 0; n < DUMB_IT_N_CHANNELS; n += 4) { - int sep = 32 * dumb_it_default_panning_separation / 100; - sigdata->channel_pan[n ] = 32 - sep; - sigdata->channel_pan[n+1] = 32 + sep; - sigdata->channel_pan[n+2] = 32 + sep; - sigdata->channel_pan[n+3] = 32 - sep; - } - - for ( n = 0; (unsigned)n < stream->chunk_count; ++n ) - { - struct riff_chunk * c = stream->chunks + n; - switch ( c->type ) - { - case DUMB_ID( 'M', 'A', 'I', 'N' ): - if ( dumbfile_seek( f, c->offset, DFS_SEEK_SET ) ) goto error_usd; - dumbfile_getnc( (char *) sigdata->name, 64, f ); - sigdata->name[ 64 ] = 0; - sigdata->flags = IT_STEREO | IT_OLD_EFFECTS | IT_COMPATIBLE_GXX | IT_WAS_AN_S3M; - o = dumbfile_getc( f ); - if ( ! ( o & 1 ) ) sigdata->flags |= IT_LINEAR_SLIDES; - if ( ( o & ~3 ) || ! ( o & 2 ) ) goto error_usd; // unknown flags - sigdata->n_pchannels = dumbfile_getc( f ); - sigdata->speed = dumbfile_getc( f ); - sigdata->tempo = dumbfile_getc( f ); - - dumbfile_skip( f, 4 ); - - sigdata->global_volume = dumbfile_getc( f ); - - if ( c->size < 0x48 + (unsigned)sigdata->n_pchannels ) goto error_usd; - - for ( o = 0; o < sigdata->n_pchannels; ++o ) - { - p = dumbfile_getc( f ); - sigdata->channel_pan[ o ] = p; - if ( p >= 128 ) - { - sigdata->channel_volume[ o ] = 0; - } - } - break; - } - } - - sigdata->pattern = malloc( sigdata->n_patterns * sizeof( *sigdata->pattern ) ); - if ( ! sigdata->pattern ) goto error_usd; - for ( n = 0; n < sigdata->n_patterns; ++n ) - sigdata->pattern[ n ].entry = NULL; - - sigdata->sample = malloc( sigdata->n_samples * sizeof( *sigdata->sample ) ); - if ( ! sigdata->sample ) goto error_usd; - for ( n = 0; n < sigdata->n_samples; ++n ) - { - IT_SAMPLE * sample = sigdata->sample + n; - sample->data = NULL; - sample->flags = 0; - sample->name[ 0 ] = 0; - } - - for ( n = 0; (unsigned)n < stream->chunk_count; ++n ) - { - struct riff_chunk * c = stream->chunks + n; - switch ( c->type ) - { - case DUMB_ID( 'O', 'R', 'D', 'R' ): - if ( dumbfile_seek( f, c->offset, DFS_SEEK_SET ) ) goto error_usd; - sigdata->n_orders = dumbfile_getc( f ) + 1; - if ( (unsigned)sigdata->n_orders + 1 > c->size ) goto error_usd; - sigdata->order = malloc( sigdata->n_orders ); - if ( ! sigdata->order ) goto error_usd; - dumbfile_getnc( (char *) sigdata->order, sigdata->n_orders, f ); - break; - - case DUMB_ID( 'P', 'A', 'T', 'T' ): - if ( dumbfile_seek( f, c->offset, DFS_SEEK_SET ) ) goto error_usd; - o = dumbfile_getc( f ); - p = dumbfile_igetl( f ); - if ( it_riff_am_process_pattern( sigdata->pattern + o, f, p, 0 ) ) goto error_usd; - break; - - case DUMB_ID( 'I', 'N', 'S', 'T' ): - { - IT_SAMPLE * sample; - if ( dumbfile_seek( f, c->offset + 1, DFS_SEEK_SET ) ) goto error_usd; - sample = sigdata->sample + dumbfile_getc( f ); - if ( c->size >= 0x121 ) - { - if ( dumbfile_seek( f, c->offset + 0xE1, DFS_SEEK_SET ) ) goto error_usd; - if ( dumbfile_mgetl( f ) == DUMB_ID('S','A','M','P') ) - { - unsigned size = dumbfile_igetl( f ); - if ( it_riff_am_process_sample( sample, f, size, 0 ) ) goto error_usd; - break; - } - } - dumbfile_seek( f, c->offset + 2, DFS_SEEK_SET ); - dumbfile_getnc( (char *) sample->name, 28, f ); - sample->name[ 28 ] = 0; + if (flags & 0xE0) { + if (flags & 0x80) { + q = dumbfile_getc(f); + r = dumbfile_getc(f); + _dumb_it_xm_convert_effect(r, q, entry, 0); } - break; - } - } - _dumb_it_fix_invalid_orders( sigdata ); + if (flags & 0x40) { + q = dumbfile_getc(f); + r = dumbfile_getc(f); + if (q) { + entry->mask |= IT_ENTRY_INSTRUMENT; + entry->instrument = q; + } + if (r) { + entry->mask |= IT_ENTRY_NOTE; + entry->note = r - 1; + } + } - return sigdata; + if (flags & 0x20) { + q = dumbfile_getc(f); + entry->mask |= IT_ENTRY_VOLPAN; + if (ver == 0) + entry->volpan = q; + else + entry->volpan = q * 64 / 127; + } + + if (entry->mask) + entry++; + } + } + + while (row < nrows) { + IT_SET_END_ROW(entry); + ++entry; + ++row; + } + + pattern->n_entries = (int)((long)entry - (long)pattern->entry); + if (!pattern->n_entries) + return -1; + + return 0; +} + +static DUMB_IT_SIGDATA *it_riff_amff_load_sigdata(DUMBFILE *f, + struct riff *stream) { + DUMB_IT_SIGDATA *sigdata; + + int n, found; + int o, p; + + if (!stream) + goto error; + + if (stream->type != DUMB_ID('A', 'M', 'F', 'F')) + goto error; + + sigdata = malloc(sizeof(*sigdata)); + if (!sigdata) + goto error; + + sigdata->n_patterns = 0; + sigdata->n_samples = 0; + sigdata->name[0] = 0; + + found = 0; + + for (n = 0; (unsigned)n < stream->chunk_count; ++n) { + struct riff_chunk *c = stream->chunks + n; + switch (c->type) { + case DUMB_ID('M', 'A', 'I', 'N'): + /* initialization data */ + if ((found & 1) || (c->size < 0x48)) + goto error_sd; + found |= 1; + break; + + case DUMB_ID('O', 'R', 'D', 'R'): + if ((found & 2) || (c->size < 1)) + goto error_sd; + found |= 2; + break; + + case DUMB_ID('P', 'A', 'T', 'T'): + if (dumbfile_seek(f, c->offset, DFS_SEEK_SET)) + goto error_sd; + o = dumbfile_getc(f); + if (o >= sigdata->n_patterns) + sigdata->n_patterns = (o + 1); + o = (int)dumbfile_igetl(f); + if ((unsigned)o + 5 > c->size) + goto error_sd; + break; + + case DUMB_ID('I', 'N', 'S', 'T'): { + if (c->size < 0xE1) + goto error_sd; + if (dumbfile_seek(f, c->offset + 1, DFS_SEEK_SET)) + goto error_sd; + o = dumbfile_getc(f); + if (o >= sigdata->n_samples) + sigdata->n_samples = (int)(o + 1); + if (c->size >= 0x121) { + if (dumbfile_seek(f, c->offset + 0xE1, DFS_SEEK_SET)) + goto error_sd; + if (dumbfile_mgetl(f) == DUMB_ID('S', 'A', 'M', 'P')) { + size_t size = dumbfile_igetl(f); + if (size + 0xE1 + 8 > c->size) + goto error_sd; + } + } + } break; + } + } + + if (found != 3 || !sigdata->n_samples || !sigdata->n_patterns) + goto error_sd; + + if (sigdata->n_samples > 255 || sigdata->n_patterns > 255) + goto error_sd; + + sigdata->song_message = NULL; + sigdata->order = NULL; + sigdata->instrument = NULL; + sigdata->sample = NULL; + sigdata->pattern = NULL; + sigdata->midi = NULL; + sigdata->checkpoint = NULL; + + sigdata->mixing_volume = 48; + sigdata->pan_separation = 128; + + sigdata->n_instruments = 0; + sigdata->n_orders = 0; + sigdata->restart_position = 0; + + memset(sigdata->channel_volume, 64, DUMB_IT_N_CHANNELS); + + for (n = 0; n < DUMB_IT_N_CHANNELS; n += 4) { + int sep = 32 * dumb_it_default_panning_separation / 100; + sigdata->channel_pan[n] = 32 - sep; + sigdata->channel_pan[n + 1] = 32 + sep; + sigdata->channel_pan[n + 2] = 32 + sep; + sigdata->channel_pan[n + 3] = 32 - sep; + } + + for (n = 0; (unsigned)n < stream->chunk_count; ++n) { + struct riff_chunk *c = stream->chunks + n; + switch (c->type) { + case DUMB_ID('M', 'A', 'I', 'N'): + if (dumbfile_seek(f, c->offset, DFS_SEEK_SET)) + goto error_usd; + dumbfile_getnc((char *)sigdata->name, 64, f); + sigdata->name[64] = 0; + sigdata->flags = + IT_STEREO | IT_OLD_EFFECTS | IT_COMPATIBLE_GXX | IT_WAS_AN_S3M; + o = dumbfile_getc(f); + if (!(o & 1)) + sigdata->flags |= IT_LINEAR_SLIDES; + if ((o & ~3) || !(o & 2)) + goto error_usd; // unknown flags + sigdata->n_pchannels = dumbfile_getc(f); + sigdata->speed = dumbfile_getc(f); + sigdata->tempo = dumbfile_getc(f); + + dumbfile_skip(f, 4); + + sigdata->global_volume = dumbfile_getc(f); + + if (c->size < 0x48 + (unsigned)sigdata->n_pchannels) + goto error_usd; + + for (o = 0; o < sigdata->n_pchannels; ++o) { + p = dumbfile_getc(f); + sigdata->channel_pan[o] = p; + if (p >= 128) { + sigdata->channel_volume[o] = 0; + } + } + break; + } + } + + sigdata->pattern = malloc(sigdata->n_patterns * sizeof(*sigdata->pattern)); + if (!sigdata->pattern) + goto error_usd; + for (n = 0; n < sigdata->n_patterns; ++n) + sigdata->pattern[n].entry = NULL; + + sigdata->sample = malloc(sigdata->n_samples * sizeof(*sigdata->sample)); + if (!sigdata->sample) + goto error_usd; + for (n = 0; n < sigdata->n_samples; ++n) { + IT_SAMPLE *sample = sigdata->sample + n; + sample->data = NULL; + sample->flags = 0; + sample->name[0] = 0; + } + + for (n = 0; (unsigned)n < stream->chunk_count; ++n) { + struct riff_chunk *c = stream->chunks + n; + switch (c->type) { + case DUMB_ID('O', 'R', 'D', 'R'): + if (dumbfile_seek(f, c->offset, DFS_SEEK_SET)) + goto error_usd; + sigdata->n_orders = dumbfile_getc(f) + 1; + if ((unsigned)sigdata->n_orders + 1 > c->size) + goto error_usd; + sigdata->order = malloc(sigdata->n_orders); + if (!sigdata->order) + goto error_usd; + dumbfile_getnc((char *)sigdata->order, sigdata->n_orders, f); + break; + + case DUMB_ID('P', 'A', 'T', 'T'): + if (dumbfile_seek(f, c->offset, DFS_SEEK_SET)) + goto error_usd; + o = dumbfile_getc(f); + p = (int)dumbfile_igetl(f); + if (it_riff_am_process_pattern(sigdata->pattern + o, f, p, 0)) + goto error_usd; + break; + + case DUMB_ID('I', 'N', 'S', 'T'): { + IT_SAMPLE *sample; + if (dumbfile_seek(f, c->offset + 1, DFS_SEEK_SET)) + goto error_usd; + sample = sigdata->sample + dumbfile_getc(f); + if (c->size >= 0x121) { + if (dumbfile_seek(f, c->offset + 0xE1, DFS_SEEK_SET)) + goto error_usd; + if (dumbfile_mgetl(f) == DUMB_ID('S', 'A', 'M', 'P')) { + size_t size = dumbfile_igetl(f); + if (it_riff_am_process_sample(sample, f, size, 0)) + goto error_usd; + break; + } + } + dumbfile_seek(f, c->offset + 2, DFS_SEEK_SET); + dumbfile_getnc((char *)sample->name, 28, f); + sample->name[28] = 0; + } break; + } + } + + _dumb_it_fix_invalid_orders(sigdata); + + return sigdata; error_usd: - _dumb_it_unload_sigdata( sigdata ); - goto error; + _dumb_it_unload_sigdata(sigdata); + goto error; error_sd: - free( sigdata ); + free(sigdata); error: - return NULL; + return NULL; } -static DUMB_IT_SIGDATA *it_riff_am_load_sigdata( DUMBFILE * f, struct riff * stream ) -{ - DUMB_IT_SIGDATA *sigdata; +static DUMB_IT_SIGDATA *it_riff_am_load_sigdata(DUMBFILE *f, + struct riff *stream) { + DUMB_IT_SIGDATA *sigdata; - int n, o, p, found; + int n, found; + int o, p; - if ( ! f || ! stream ) goto error; + if (!f || !stream) + goto error; - if ( stream->type != DUMB_ID( 'A', 'M', ' ', ' ' ) ) goto error; + if (stream->type != DUMB_ID('A', 'M', ' ', ' ')) + goto error; - sigdata = malloc(sizeof(*sigdata)); - if ( ! sigdata ) goto error; + sigdata = malloc(sizeof(*sigdata)); + if (!sigdata) + goto error; - sigdata->n_patterns = 0; - sigdata->n_samples = 0; - sigdata->name[0] = 0; + sigdata->n_patterns = 0; + sigdata->n_samples = 0; + sigdata->name[0] = 0; - found = 0; + found = 0; - for ( n = 0; (unsigned)n < stream->chunk_count; ++n ) - { - struct riff_chunk * c = stream->chunks + n; - switch( c->type ) - { - case DUMB_ID( 'I' ,'N' ,'I' ,'T' ): - /* initialization data */ - if ( ( found & 1 ) || ( c->size < 0x48 ) ) goto error_sd; - found |= 1; - break; + for (n = 0; (unsigned)n < stream->chunk_count; ++n) { + struct riff_chunk *c = stream->chunks + n; + switch (c->type) { + case DUMB_ID('I', 'N', 'I', 'T'): + /* initialization data */ + if ((found & 1) || (c->size < 0x48)) + goto error_sd; + found |= 1; + break; - case DUMB_ID( 'O', 'R', 'D', 'R' ): - if ( ( found & 2 ) || ( c->size < 1 ) ) goto error_sd; - found |= 2; - break; + case DUMB_ID('O', 'R', 'D', 'R'): + if ((found & 2) || (c->size < 1)) + goto error_sd; + found |= 2; + break; - case DUMB_ID( 'P', 'A', 'T', 'T' ): - if ( dumbfile_seek( f, c->offset, DFS_SEEK_SET ) ) goto error_sd; - o = dumbfile_getc( f ); - if ( o >= sigdata->n_patterns ) sigdata->n_patterns = o + 1; - o = dumbfile_igetl( f ); - if ( (unsigned)o + 5 > c->size ) goto error_sd; - break; + case DUMB_ID('P', 'A', 'T', 'T'): + if (dumbfile_seek(f, c->offset, DFS_SEEK_SET)) + goto error_sd; + o = dumbfile_getc(f); + if (o >= sigdata->n_patterns) + sigdata->n_patterns = (int)(o + 1); + o = (int)dumbfile_igetl(f); + if ((unsigned)o + 5 > c->size) + goto error_sd; + break; - case DUMB_ID( 'R', 'I', 'F', 'F' ): - { - struct riff * str = c->nested; - switch ( str->type ) - { - case DUMB_ID( 'A', 'I', ' ', ' ' ): - for ( o = 0; (unsigned)o < str->chunk_count; ++o ) - { - struct riff_chunk * chk = str->chunks + o; - switch( chk->type ) - { - case DUMB_ID( 'I', 'N', 'S', 'T' ): - { - struct riff * temp; - unsigned size; - unsigned sample_found; - if ( dumbfile_seek( f, chk->offset, DFS_SEEK_SET ) ) goto error_sd; - size = dumbfile_igetl( f ); - if ( size < 0x142 ) goto error_sd; - sample_found = 0; - dumbfile_skip( f, 1 ); - p = dumbfile_getc( f ); - if ( p >= sigdata->n_samples ) sigdata->n_samples = p + 1; - temp = riff_parse( f, chk->offset + 4 + size, chk->size - size - 4, 1 ); - if ( temp ) - { - if ( temp->type == DUMB_ID( 'A', 'S', ' ', ' ' ) ) - { - for ( p = 0; (unsigned)p < temp->chunk_count; ++p ) - { - if ( temp->chunks[ p ].type == DUMB_ID( 'S', 'A', 'M', 'P' ) ) - { - if ( sample_found ) - { - riff_free( temp ); - goto error_sd; - } - sample_found = 1; - } - } - } - riff_free( temp ); - } - } - } - } - } - } - break; - } - } + case DUMB_ID('R', 'I', 'F', 'F'): { + struct riff *str = c->nested; + switch (str->type) { + case DUMB_ID('A', 'I', ' ', ' '): + for (o = 0; (unsigned)o < str->chunk_count; ++o) { + struct riff_chunk *chk = str->chunks + o; + switch (chk->type) { + case DUMB_ID('I', 'N', 'S', 'T'): { + struct riff *temp; + size_t size; + unsigned sample_found; + if (dumbfile_seek(f, chk->offset, DFS_SEEK_SET)) + goto error_sd; + size = dumbfile_igetl(f); + if (size < 0x142) + goto error_sd; + sample_found = 0; + dumbfile_skip(f, 1); + p = dumbfile_getc(f); + if (p >= sigdata->n_samples) + sigdata->n_samples = (int)(p + 1); + temp = riff_parse(f, chk->offset + 4 + size, + chk->size - size - 4, 1); + if (temp) { + if (temp->type == DUMB_ID('A', 'S', ' ', ' ')) { + for (p = 0; (unsigned)p < temp->chunk_count; + ++p) { + if (temp->chunks[p].type == + DUMB_ID('S', 'A', 'M', 'P')) { + if (sample_found) { + riff_free(temp); + goto error_sd; + } + sample_found = 1; + } + } + } + riff_free(temp); + } + } + } + } + } + } break; + } + } - if ( found != 3 || !sigdata->n_samples || !sigdata->n_patterns ) goto error_sd; + if (found != 3 || !sigdata->n_samples || !sigdata->n_patterns) + goto error_sd; - if ( sigdata->n_samples > 255 || sigdata->n_patterns > 255 ) goto error_sd; + if (sigdata->n_samples > 255 || sigdata->n_patterns > 255) + goto error_sd; - sigdata->song_message = NULL; - sigdata->order = NULL; - sigdata->instrument = NULL; - sigdata->sample = NULL; - sigdata->pattern = NULL; - sigdata->midi = NULL; - sigdata->checkpoint = NULL; + sigdata->song_message = NULL; + sigdata->order = NULL; + sigdata->instrument = NULL; + sigdata->sample = NULL; + sigdata->pattern = NULL; + sigdata->midi = NULL; + sigdata->checkpoint = NULL; - sigdata->mixing_volume = 48; - sigdata->pan_separation = 128; + sigdata->mixing_volume = 48; + sigdata->pan_separation = 128; - sigdata->n_instruments = 0; - sigdata->n_orders = 0; - sigdata->restart_position = 0; + sigdata->n_instruments = 0; + sigdata->n_orders = 0; + sigdata->restart_position = 0; - memset(sigdata->channel_volume, 64, DUMB_IT_N_CHANNELS); + memset(sigdata->channel_volume, 64, DUMB_IT_N_CHANNELS); - for (n = 0; n < DUMB_IT_N_CHANNELS; n += 4) { - int sep = 32 * dumb_it_default_panning_separation / 100; - sigdata->channel_pan[n ] = 32 - sep; - sigdata->channel_pan[n+1] = 32 + sep; - sigdata->channel_pan[n+2] = 32 + sep; - sigdata->channel_pan[n+3] = 32 - sep; - } + for (n = 0; n < DUMB_IT_N_CHANNELS; n += 4) { + int sep = 32 * dumb_it_default_panning_separation / 100; + sigdata->channel_pan[n] = 32 - sep; + sigdata->channel_pan[n + 1] = 32 + sep; + sigdata->channel_pan[n + 2] = 32 + sep; + sigdata->channel_pan[n + 3] = 32 - sep; + } - for ( n = 0; (unsigned)n < stream->chunk_count; ++n ) - { - struct riff_chunk * c = stream->chunks + n; - switch ( c->type ) - { - case DUMB_ID( 'I', 'N', 'I', 'T' ): - if ( dumbfile_seek( f, c->offset, DFS_SEEK_SET ) ) goto error_usd; - dumbfile_getnc( (char *) sigdata->name, 64, f ); - sigdata->name[ 64 ] = 0; - sigdata->flags = IT_STEREO | IT_OLD_EFFECTS | IT_COMPATIBLE_GXX | IT_WAS_AN_S3M; - o = dumbfile_getc( f ); - if ( ! ( o & 1 ) ) sigdata->flags |= IT_LINEAR_SLIDES; - if ( ( o & ~3 ) || ! ( o & 2 ) ) goto error_usd; // unknown flags - sigdata->n_pchannels = dumbfile_getc( f ); - sigdata->speed = dumbfile_getc( f ); - sigdata->tempo = dumbfile_getc( f ); + for (n = 0; (unsigned)n < stream->chunk_count; ++n) { + struct riff_chunk *c = stream->chunks + n; + switch (c->type) { + case DUMB_ID('I', 'N', 'I', 'T'): + if (dumbfile_seek(f, c->offset, DFS_SEEK_SET)) + goto error_usd; + dumbfile_getnc((char *)sigdata->name, 64, f); + sigdata->name[64] = 0; + sigdata->flags = + IT_STEREO | IT_OLD_EFFECTS | IT_COMPATIBLE_GXX | IT_WAS_AN_S3M; + o = dumbfile_getc(f); + if (!(o & 1)) + sigdata->flags |= IT_LINEAR_SLIDES; + if ((o & ~3) || !(o & 2)) + goto error_usd; // unknown flags + sigdata->n_pchannels = dumbfile_getc(f); + sigdata->speed = dumbfile_getc(f); + sigdata->tempo = dumbfile_getc(f); - dumbfile_skip( f, 4 ); + dumbfile_skip(f, 4); - sigdata->global_volume = dumbfile_getc( f ); + sigdata->global_volume = dumbfile_getc(f); - if ( c->size < 0x48 + (unsigned)sigdata->n_pchannels ) goto error_usd; + if (c->size < 0x48 + (unsigned)sigdata->n_pchannels) + goto error_usd; - for ( o = 0; o < sigdata->n_pchannels; ++o ) - { - p = dumbfile_getc( f ); - if ( p <= 128 ) - { - sigdata->channel_pan[ o ] = p / 2; - } - else - { - sigdata->channel_volume[ o ] = 0; - } - } - break; - } - } + for (o = 0; o < sigdata->n_pchannels; ++o) { + p = dumbfile_getc(f); + if (p <= 128) { + sigdata->channel_pan[o] = p / 2; + } else { + sigdata->channel_volume[o] = 0; + } + } + break; + } + } - sigdata->pattern = malloc( sigdata->n_patterns * sizeof( *sigdata->pattern ) ); - if ( ! sigdata->pattern ) goto error_usd; - for ( n = 0; n < sigdata->n_patterns; ++n ) - sigdata->pattern[ n ].entry = NULL; + sigdata->pattern = malloc(sigdata->n_patterns * sizeof(*sigdata->pattern)); + if (!sigdata->pattern) + goto error_usd; + for (n = 0; n < sigdata->n_patterns; ++n) + sigdata->pattern[n].entry = NULL; - sigdata->sample = malloc( sigdata->n_samples * sizeof( *sigdata->sample ) ); - if ( ! sigdata->sample ) goto error_usd; - for ( n = 0; n < sigdata->n_samples; ++n ) - { - IT_SAMPLE * sample = sigdata->sample + n; - sample->data = NULL; - sample->flags = 0; - sample->name[ 0 ] = 0; - } + sigdata->sample = malloc(sigdata->n_samples * sizeof(*sigdata->sample)); + if (!sigdata->sample) + goto error_usd; + for (n = 0; n < sigdata->n_samples; ++n) { + IT_SAMPLE *sample = sigdata->sample + n; + sample->data = NULL; + sample->flags = 0; + sample->name[0] = 0; + } - for ( n = 0; (unsigned)n < stream->chunk_count; ++n ) - { - struct riff_chunk * c = stream->chunks + n; - switch ( c->type ) - { - case DUMB_ID( 'O', 'R', 'D', 'R' ): - if ( dumbfile_seek( f, c->offset, DFS_SEEK_SET ) ) goto error_usd; - sigdata->n_orders = dumbfile_getc( f ) + 1; - if ( (unsigned)sigdata->n_orders + 1 > c->size ) goto error_usd; - sigdata->order = malloc( sigdata->n_orders ); - if ( ! sigdata->order ) goto error_usd; - dumbfile_getnc( (char *) sigdata->order, sigdata->n_orders, f ); - break; + for (n = 0; (unsigned)n < stream->chunk_count; ++n) { + struct riff_chunk *c = stream->chunks + n; + switch (c->type) { + case DUMB_ID('O', 'R', 'D', 'R'): + if (dumbfile_seek(f, c->offset, DFS_SEEK_SET)) + goto error_usd; + sigdata->n_orders = dumbfile_getc(f) + 1; + if ((unsigned)sigdata->n_orders + 1 > c->size) + goto error_usd; + sigdata->order = malloc(sigdata->n_orders); + if (!sigdata->order) + goto error_usd; + dumbfile_getnc((char *)sigdata->order, sigdata->n_orders, f); + break; - case DUMB_ID( 'P', 'A', 'T', 'T' ): - if ( dumbfile_seek( f, c->offset, DFS_SEEK_SET ) ) goto error_usd; - o = dumbfile_getc( f ); - p = dumbfile_igetl( f ); - if ( it_riff_am_process_pattern( sigdata->pattern + o, f, p, 1 ) ) goto error_usd; - break; + case DUMB_ID('P', 'A', 'T', 'T'): + if (dumbfile_seek(f, c->offset, DFS_SEEK_SET)) + goto error_usd; + o = dumbfile_getc(f); + p = (int)dumbfile_igetl(f); + if (it_riff_am_process_pattern(sigdata->pattern + o, f, p, 1)) + goto error_usd; + break; - case DUMB_ID( 'R', 'I', 'F', 'F' ): - { - struct riff * str = c->nested; - switch ( str->type ) - { - case DUMB_ID('A', 'I', ' ', ' '): - for ( o = 0; (unsigned)o < str->chunk_count; ++o ) - { - struct riff_chunk * chk = str->chunks + o; - switch( chk->type ) - { - case DUMB_ID( 'I', 'N', 'S', 'T' ): - { - struct riff * temp; - unsigned size; - unsigned sample_found; - IT_SAMPLE * sample; - if ( dumbfile_seek( f, chk->offset, DFS_SEEK_SET ) ) goto error_usd; - size = dumbfile_igetl( f ); - dumbfile_skip( f, 1 ); - p = dumbfile_getc( f ); - temp = riff_parse( f, chk->offset + 4 + size, chk->size - size - 4, 1 ); - sample_found = 0; - sample = sigdata->sample + p; - if ( temp ) - { - if ( temp->type == DUMB_ID( 'A', 'S', ' ', ' ' ) ) - { - for ( p = 0; (unsigned)p < temp->chunk_count; ++p ) - { - struct riff_chunk * c = temp->chunks + p; - if ( c->type == DUMB_ID( 'S', 'A', 'M', 'P' ) ) - { - if ( sample_found ) - { - riff_free( temp ); - goto error_usd; - } - if ( dumbfile_seek( f, c->offset, DFS_SEEK_SET ) ) - { - riff_free( temp ); - goto error_usd; - } - if ( it_riff_am_process_sample( sample, f, c->size, 1 ) ) - { - riff_free( temp ); - goto error_usd; - } - sample_found = 1; - } - } - } - riff_free( temp ); - } - if ( ! sample_found ) - { - dumbfile_seek( f, chk->offset + 6, DFS_SEEK_SET ); - dumbfile_getnc( (char *) sample->name, 32, f ); - sample->name[ 32 ] = 0; - } - } - } - } - } - } - break; - } - } + case DUMB_ID('R', 'I', 'F', 'F'): { + struct riff *str = c->nested; + switch (str->type) { + case DUMB_ID('A', 'I', ' ', ' '): + for (o = 0; (unsigned)o < str->chunk_count; ++o) { + struct riff_chunk *chk = str->chunks + o; + switch (chk->type) { + case DUMB_ID('I', 'N', 'S', 'T'): { + struct riff *temp; + size_t size; + unsigned sample_found; + IT_SAMPLE *sample; + if (dumbfile_seek(f, chk->offset, DFS_SEEK_SET)) + goto error_usd; + size = dumbfile_igetl(f); + dumbfile_skip(f, 1); + p = dumbfile_getc(f); + temp = riff_parse(f, chk->offset + 4 + size, + chk->size - size - 4, 1); + sample_found = 0; + sample = sigdata->sample + p; + if (temp) { + if (temp->type == DUMB_ID('A', 'S', ' ', ' ')) { + for (p = 0; (unsigned)p < temp->chunk_count; + ++p) { + struct riff_chunk *c = temp->chunks + p; + if (c->type == + DUMB_ID('S', 'A', 'M', 'P')) { + if (sample_found) { + riff_free(temp); + goto error_usd; + } + if (dumbfile_seek(f, c->offset, + DFS_SEEK_SET)) { + riff_free(temp); + goto error_usd; + } + if (it_riff_am_process_sample( + sample, f, c->size, 1)) { + riff_free(temp); + goto error_usd; + } + sample_found = 1; + } + } + } + riff_free(temp); + } + if (!sample_found) { + dumbfile_seek(f, chk->offset + 6, DFS_SEEK_SET); + dumbfile_getnc((char *)sample->name, 32, f); + sample->name[32] = 0; + } + } + } + } + } + } break; + } + } - _dumb_it_fix_invalid_orders( sigdata ); + _dumb_it_fix_invalid_orders(sigdata); - return sigdata; + return sigdata; error_usd: - _dumb_it_unload_sigdata( sigdata ); - goto error; + _dumb_it_unload_sigdata(sigdata); + goto error; error_sd: - free( sigdata ); + free(sigdata); error: - return NULL; + return NULL; } -DUH *dumb_read_riff_amff( DUMBFILE * f, struct riff * stream ) -{ - sigdata_t *sigdata; - long length; +DUH *dumb_read_riff_amff(DUMBFILE *f, struct riff *stream) { + sigdata_t *sigdata; + long length; - DUH_SIGTYPE_DESC *descptr = &_dumb_sigtype_it; + DUH_SIGTYPE_DESC *descptr = &_dumb_sigtype_it; - sigdata = it_riff_amff_load_sigdata( f, stream ); + sigdata = it_riff_amff_load_sigdata(f, stream); - if (!sigdata) - return NULL; + if (!sigdata) + return NULL; - length = 0;/*_dumb_it_build_checkpoints(sigdata, 0);*/ + length = 0; /*_dumb_it_build_checkpoints(sigdata, 0);*/ - { - const char *tag[2][2]; - tag[0][0] = "TITLE"; + { + const char *tag[2][2]; + tag[0][0] = "TITLE"; tag[0][1] = (const char *)(((DUMB_IT_SIGDATA *)sigdata)->name); - tag[1][0] = "FORMAT"; - tag[1][1] = "RIFF AMFF"; - return make_duh( length, 2, ( const char * const (*) [ 2 ] ) tag, 1, & descptr, & sigdata ); - } + tag[1][0] = "FORMAT"; + tag[1][1] = "RIFF AMFF"; + return make_duh(length, 2, (const char *const(*)[2])tag, 1, &descptr, + &sigdata); + } } -DUH *dumb_read_riff_am( DUMBFILE * f, struct riff * stream ) -{ - sigdata_t *sigdata; +DUH *dumb_read_riff_am(DUMBFILE *f, struct riff *stream) { + sigdata_t *sigdata; - DUH_SIGTYPE_DESC *descptr = &_dumb_sigtype_it; + DUH_SIGTYPE_DESC *descptr = &_dumb_sigtype_it; - sigdata = it_riff_am_load_sigdata( f, stream ); + sigdata = it_riff_am_load_sigdata(f, stream); - if (!sigdata) - return NULL; + if (!sigdata) + return NULL; - { - const char *tag[2][2]; - tag[0][0] = "TITLE"; + { + const char *tag[2][2]; + tag[0][0] = "TITLE"; tag[0][1] = (const char *)(((DUMB_IT_SIGDATA *)sigdata)->name); - tag[1][0] = "FORMAT"; - tag[1][1] = "RIFF AM"; - return make_duh( -1, 2, ( const char * const (*) [ 2 ] ) tag, 1, & descptr, & sigdata ); - } + tag[1][0] = "FORMAT"; + tag[1][1] = "RIFF AM"; + return make_duh(-1, 2, (const char *const(*)[2])tag, 1, &descptr, + &sigdata); + } } diff --git a/Frameworks/Dumb/dumb/src/it/readamf.c b/Frameworks/Dumb/dumb/src/it/readamf.c index 34dd2cb01..8ba9d0582 100644 --- a/Frameworks/Dumb/dumb/src/it/readamf.c +++ b/Frameworks/Dumb/dumb/src/it/readamf.c @@ -24,539 +24,571 @@ #include "dumb.h" #include "internal/it.h" +static void it_amf_process_track(IT_ENTRY *entry_table, unsigned char *track, + int rows, int channels) { + int last_instrument = 0; + int tracksize = track[0] + (track[1] << 8) + (track[2] << 16); + track += 3; + while (tracksize--) { + unsigned int row = track[0]; + unsigned int command = track[1]; + unsigned int argument = track[2]; + IT_ENTRY *entry = entry_table + row * channels; + if (row >= (unsigned int)rows) + break; + if (command < 0x7F) { + entry->mask |= + IT_ENTRY_NOTE | IT_ENTRY_INSTRUMENT | IT_ENTRY_VOLPAN; + entry->note = command; + if (!entry->instrument) + entry->instrument = last_instrument; + entry->volpan = argument; + } else if (command == 0x7F) { + signed char row_delta = (signed char)argument; + int row_source = (int)row + (int)row_delta; + if (row_source >= 0 && row_source < (int)rows) { + *entry = entry_table[row_source * channels]; + } + } else if (command == 0x80) { + entry->mask |= IT_ENTRY_INSTRUMENT; + last_instrument = argument + 1; + entry->instrument = last_instrument; + } else if (command == 0x83) { + entry->mask |= IT_ENTRY_VOLPAN; + entry->volpan = argument; + } else { + unsigned int effect = command & 0x7F; + unsigned int effectvalue = argument; + switch (effect) { + case 0x01: + effect = IT_SET_SPEED; + break; + case 0x02: + effect = IT_VOLUME_SLIDE; + case 0x0A: + if (effect == 0x0A) + effect = IT_VOLSLIDE_TONEPORTA; + case 0x0B: + if (effect == 0x0B) + effect = IT_VOLSLIDE_VIBRATO; + if (effectvalue & 0x80) + effectvalue = (-(signed char)effectvalue) & 0x0F; + else + effectvalue = (effectvalue & 0x0F) << 4; + break; -static void it_amf_process_track( IT_ENTRY *entry_table, unsigned char *track, int rows, int channels ) -{ - int last_instrument = 0; - int tracksize = track[ 0 ] + ( track[ 1 ] << 8 ) + ( track[ 2 ] << 16 ); - track += 3; - while ( tracksize-- ) { - unsigned int row = track[ 0 ]; - unsigned int command = track[ 1 ]; - unsigned int argument = track[ 2 ]; - IT_ENTRY * entry = entry_table + row * channels; - if ( row >= ( unsigned int ) rows ) break; - if ( command < 0x7F ) { - entry->mask |= IT_ENTRY_NOTE | IT_ENTRY_INSTRUMENT | IT_ENTRY_VOLPAN; - entry->note = command; - if ( ! entry->instrument ) entry->instrument = last_instrument; - entry->volpan = argument; - } - else if ( command == 0x7F ) { - signed char row_delta = ( signed char ) argument; - int row_source = ( int ) row + ( int ) row_delta; - if ( row_source >= 0 && row_source < ( int ) rows ) { - *entry = entry_table[ row_source * channels ]; - } - } - else if ( command == 0x80 ) { - entry->mask |= IT_ENTRY_INSTRUMENT; - last_instrument = argument + 1; - entry->instrument = last_instrument; - } - else if ( command == 0x83 ) { - entry->mask |= IT_ENTRY_VOLPAN; - entry->volpan = argument; - } - else { - unsigned int effect = command & 0x7F; - unsigned int effectvalue = argument; - switch (effect) { - case 0x01: effect = IT_SET_SPEED; break; + case 0x04: + if (effectvalue & 0x80) { + effect = IT_PORTAMENTO_UP; + effectvalue = (-(signed char)effectvalue) & 0x7F; + } else { + effect = IT_PORTAMENTO_DOWN; + } + break; - case 0x02: effect = IT_VOLUME_SLIDE; - case 0x0A: if ( effect == 0x0A ) effect = IT_VOLSLIDE_TONEPORTA; - case 0x0B: if ( effect == 0x0B ) effect = IT_VOLSLIDE_VIBRATO; - if ( effectvalue & 0x80 ) effectvalue = ( -( signed char ) effectvalue ) & 0x0F; - else effectvalue = ( effectvalue & 0x0F ) << 4; - break; + case 0x06: + effect = IT_TONE_PORTAMENTO; + break; - case 0x04: - if ( effectvalue & 0x80 ) { - effect = IT_PORTAMENTO_UP; - effectvalue = ( -( signed char ) effectvalue ) & 0x7F; - } - else { - effect = IT_PORTAMENTO_DOWN; - } - break; + case 0x07: + effect = IT_TREMOR; + break; - case 0x06: effect = IT_TONE_PORTAMENTO; break; + case 0x08: + effect = IT_ARPEGGIO; + break; - case 0x07: effect = IT_TREMOR; break; + case 0x09: + effect = IT_VIBRATO; + break; - case 0x08: effect = IT_ARPEGGIO; break; + case 0x0C: + effect = IT_BREAK_TO_ROW; + break; - case 0x09: effect = IT_VIBRATO; break; + case 0x0D: + effect = IT_JUMP_TO_ORDER; + break; - case 0x0C: effect = IT_BREAK_TO_ROW; break; + case 0x0F: + effect = IT_RETRIGGER_NOTE; + break; - case 0x0D: effect = IT_JUMP_TO_ORDER; break; + case 0x10: + effect = IT_SET_SAMPLE_OFFSET; + break; - case 0x0F: effect = IT_RETRIGGER_NOTE; break; + case 0x11: + if (effectvalue) { + effect = IT_VOLUME_SLIDE; + if (effectvalue & 0x80) + effectvalue = + 0xF0 | ((-(signed char)effectvalue) & 0x0F); + else + effectvalue = 0x0F | ((effectvalue & 0x0F) << 4); + } else + effect = 0; + break; - case 0x10: effect = IT_SET_SAMPLE_OFFSET; break; + case 0x12: + case 0x16: + if (effectvalue) { + int mask = (effect == 0x16) ? 0xE0 : 0xF0; + effect = (effectvalue & 0x80) ? IT_PORTAMENTO_UP + : IT_PORTAMENTO_DOWN; + if (effectvalue & 0x80) + effectvalue = + mask | ((-(signed char)effectvalue) & 0x0F); + else + effectvalue = mask | (effectvalue & 0x0F); + } else + effect = 0; + break; - case 0x11: - if ( effectvalue ) { - effect = IT_VOLUME_SLIDE; - if ( effectvalue & 0x80 ) - effectvalue = 0xF0 | ( ( -( signed char ) effectvalue ) & 0x0F ); - else - effectvalue = 0x0F | ( ( effectvalue & 0x0F ) << 4 ); - } - else - effect = 0; - break; + case 0x13: + effect = IT_S; + effectvalue = EFFECT_VALUE(IT_S_NOTE_DELAY, effectvalue & 0x0F); + break; - case 0x12: - case 0x16: - if ( effectvalue ) { - int mask = ( effect == 0x16 ) ? 0xE0 : 0xF0; - effect = ( effectvalue & 0x80 ) ? IT_PORTAMENTO_UP : IT_PORTAMENTO_DOWN; - if ( effectvalue & 0x80 ) - effectvalue = mask | ( ( -( signed char ) effectvalue ) & 0x0F ); - else - effectvalue = mask | ( effectvalue & 0x0F ); + case 0x14: + effect = IT_S; + effectvalue = + EFFECT_VALUE(IT_S_DELAYED_NOTE_CUT, effectvalue & 0x0F); + break; + + case 0x15: + effect = IT_SET_SONG_TEMPO; + break; + + case 0x17: + effectvalue = (effectvalue + 64) & 0x7F; + if (entry->mask & IT_ENTRY_EFFECT) { + if (!(entry->mask & IT_ENTRY_VOLPAN)) { + entry->mask |= IT_ENTRY_VOLPAN; + entry->volpan = (effectvalue / 2) + 128; } - else - effect = 0; - break; + effect = 0; + } else { + effect = IT_SET_PANNING; + } + break; - case 0x13: - effect = IT_S; - effectvalue = EFFECT_VALUE( IT_S_NOTE_DELAY, effectvalue & 0x0F ); - break; - - case 0x14: - effect = IT_S; - effectvalue = EFFECT_VALUE( IT_S_DELAYED_NOTE_CUT, effectvalue & 0x0F ); - break; - - case 0x15: effect = IT_SET_SONG_TEMPO; break; - - case 0x17: - effectvalue = ( effectvalue + 64 ) & 0x7F; - if ( entry->mask & IT_ENTRY_EFFECT ) { - if ( !( entry->mask & IT_ENTRY_VOLPAN ) ) { - entry->mask |= IT_ENTRY_VOLPAN; - entry->volpan = ( effectvalue / 2 ) + 128; - } - effect = 0; - } - else { - effect = IT_SET_PANNING; - } - break; - - default: effect = effectvalue = 0; - } - if ( effect ) { - entry->mask |= IT_ENTRY_EFFECT; - entry->effect = effect; - entry->effectvalue = effectvalue; - } - } - track += 3; - } + default: + effect = effectvalue = 0; + } + if (effect) { + entry->mask |= IT_ENTRY_EFFECT; + entry->effect = effect; + entry->effectvalue = effectvalue; + } + } + track += 3; + } } -static int it_amf_process_pattern( IT_PATTERN *pattern, IT_ENTRY *entry_table, int rows, int channels ) -{ - int i, j; - int n_entries = rows; - IT_ENTRY * entry; +static int it_amf_process_pattern(IT_PATTERN *pattern, IT_ENTRY *entry_table, + int rows, int channels) { + int i, j; + int n_entries = rows; + IT_ENTRY *entry; - pattern->n_rows = rows; + pattern->n_rows = rows; - for ( i = 0, j = channels * rows; i < j; i++ ) { - if ( entry_table[ i ].mask ) { - n_entries++; - } - } + for (i = 0, j = channels * rows; i < j; i++) { + if (entry_table[i].mask) { + n_entries++; + } + } - pattern->n_entries = n_entries; + pattern->n_entries = n_entries; - pattern->entry = entry = malloc( n_entries * sizeof( IT_ENTRY ) ); - if ( !entry ) { - return -1; - } + pattern->entry = entry = malloc(n_entries * sizeof(IT_ENTRY)); + if (!entry) { + return -1; + } - for ( i = 0; i < rows; i++ ) { - for ( j = 0; j < channels; j++ ) { - if ( entry_table[ i * channels + j ].mask ) { - *entry = entry_table[ i * channels + j ]; - entry->channel = j; - entry++; - } - } - IT_SET_END_ROW( entry ); - entry++; - } + for (i = 0; i < rows; i++) { + for (j = 0; j < channels; j++) { + if (entry_table[i * channels + j].mask) { + *entry = entry_table[i * channels + j]; + entry->channel = j; + entry++; + } + } + IT_SET_END_ROW(entry); + entry++; + } - return 0; + return 0; } -static int it_amf_read_sample_header( IT_SAMPLE *sample, DUMBFILE *f, int * offset, int ver ) -{ - int exists; +static int it_amf_read_sample_header(IT_SAMPLE *sample, DUMBFILE *f, + int *offset, int ver) { + int exists; - exists = dumbfile_getc( f ); + exists = dumbfile_getc(f); - dumbfile_getnc( (char *) sample->name, 32, f ); - sample->name[32] = 0; + dumbfile_getnc((char *)sample->name, 32, f); + sample->name[32] = 0; - dumbfile_getnc( (char *) sample->filename, 13, f ); - sample->filename[13] = 0; + dumbfile_getnc((char *)sample->filename, 13, f); + sample->filename[13] = 0; - *offset = (int)dumbfile_igetl( f ); - sample->length = dumbfile_igetl( f ); - sample->C5_speed = dumbfile_igetw( f ); - sample->default_volume = dumbfile_getc( f ); - sample->global_volume = 64; - if ( sample->default_volume > 64 ) sample->default_volume = 64; + *offset = (int)dumbfile_igetl(f); + sample->length = dumbfile_igetl(f); + sample->C5_speed = dumbfile_igetw(f); + sample->default_volume = dumbfile_getc(f); + sample->global_volume = 64; + if (sample->default_volume > 64) + sample->default_volume = 64; - if ( ver >= 11 ) { - sample->loop_start = dumbfile_igetl( f ); - sample->loop_end = dumbfile_igetl( f ); - } else { - sample->loop_start = dumbfile_igetw( f ); - sample->loop_end = sample->length; - } + if (ver >= 11) { + sample->loop_start = dumbfile_igetl(f); + sample->loop_end = dumbfile_igetl(f); + } else { + sample->loop_start = dumbfile_igetw(f); + sample->loop_end = sample->length; + } - if ( sample->length <= 0 ) { - sample->flags = 0; - return 0; - } + if (sample->length <= 0) { + sample->flags = 0; + return 0; + } - sample->flags = exists == 1 ? IT_SAMPLE_EXISTS : 0; + sample->flags = exists == 1 ? IT_SAMPLE_EXISTS : 0; - sample->default_pan = 0; - sample->finetune = 0; + sample->default_pan = 0; + sample->finetune = 0; - if ( sample->loop_end > sample->loop_start + 2 && sample->loop_end <= sample->length ) - sample->flags |= IT_SAMPLE_LOOP; + if (sample->loop_end > sample->loop_start + 2 && + sample->loop_end <= sample->length) + sample->flags |= IT_SAMPLE_LOOP; - sample->vibrato_speed = 0; - sample->vibrato_depth = 0; - sample->vibrato_rate = 0; - sample->vibrato_waveform = 0; // do we have to set _all_ these? - sample->max_resampling_quality = -1; + sample->vibrato_speed = 0; + sample->vibrato_depth = 0; + sample->vibrato_rate = 0; + sample->vibrato_waveform = 0; // do we have to set _all_ these? + sample->max_resampling_quality = -1; - return dumbfile_error(f); + return dumbfile_error(f); } +static int it_amf_read_sample_data(IT_SAMPLE *sample, DUMBFILE *f) { + int i, read_length = 0; + sample->data = malloc(sample->length); -static int it_amf_read_sample_data( IT_SAMPLE *sample, DUMBFILE *f ) -{ - int i, read_length = 0; + if (!sample->data) + return -1; - sample->data = malloc( sample->length ); + if (sample->length) + read_length = (int)dumbfile_getnc(sample->data, sample->length, f); - if ( !sample->data ) - return -1; + if (read_length < 0) + read_length = 0; - if ( sample->length ) - read_length = (int)dumbfile_getnc( sample->data, sample->length, f ); - - if ( read_length < 0 ) - read_length = 0; + for (i = 0; i < read_length; i++) { + ((signed char *)sample->data)[i] ^= 0x80; + } - for ( i = 0; i < read_length; i++ ) { - ( ( signed char * ) sample->data )[ i ] ^= 0x80; - } + for (i = read_length; i < sample->length; i++) { + ((signed char *)sample->data)[i] = 0; + } - for ( i = read_length; i < sample->length; i++ ) { - ( ( signed char * ) sample->data )[ i ] = 0; - } - - return 0; /* Sometimes the last sample is truncated :( */ + return 0; /* Sometimes the last sample is truncated :( */ } -static DUMB_IT_SIGDATA *it_amf_load_sigdata(DUMBFILE *f, int * version) -{ - DUMB_IT_SIGDATA *sigdata; - int i, j, ver, ntracks, realntracks, nchannels; +static DUMB_IT_SIGDATA *it_amf_load_sigdata(DUMBFILE *f, int *version) { + DUMB_IT_SIGDATA *sigdata; + int i, j, ver, ntracks, realntracks, nchannels; - int maxsampleseekpos = 0; - int sampleseekpos[256]; + int maxsampleseekpos = 0; + int sampleseekpos[256]; - unsigned short *orderstotracks; - unsigned short *trackmap; - unsigned int tracksize[256]; + unsigned short *orderstotracks; + unsigned short *trackmap; + unsigned int tracksize[256]; - unsigned char **track; + unsigned char **track; - static const char sig[] = "AMF"; + static const char sig[] = "AMF"; - char signature [3]; + char signature[3]; - if ( dumbfile_getnc( signature, 3, f ) != 3 || - memcmp( signature, sig, 3 ) ) { - return NULL; - } + if (dumbfile_getnc(signature, 3, f) != 3 || memcmp(signature, sig, 3)) { + return NULL; + } - *version = ver = dumbfile_getc( f ); - if ( ver < 10 || ver > 14) { - return NULL; - } + *version = ver = dumbfile_getc(f); + if (ver < 10 || ver > 14) { + return NULL; + } - sigdata = malloc(sizeof(*sigdata)); - if (!sigdata) { - return NULL; - } + sigdata = malloc(sizeof(*sigdata)); + if (!sigdata) { + return NULL; + } - dumbfile_getnc( (char *) sigdata->name, 32, f ); - sigdata->name[ 32 ] = 0; - sigdata->n_samples = dumbfile_getc( f ); - sigdata->n_orders = dumbfile_getc( f ); - ntracks = dumbfile_igetw( f ); - nchannels = dumbfile_getc( f ); + dumbfile_getnc((char *)sigdata->name, 32, f); + sigdata->name[32] = 0; + sigdata->n_samples = dumbfile_getc(f); + sigdata->n_orders = dumbfile_getc(f); + ntracks = dumbfile_igetw(f); + nchannels = dumbfile_getc(f); + + if (dumbfile_error(f) || sigdata->n_samples < 1 || + sigdata->n_samples > 255 || sigdata->n_orders < 1 || + sigdata->n_orders > 255 || !ntracks || nchannels < 1 || + nchannels > 32) { + free(sigdata); + return NULL; + } - if ( dumbfile_error( f ) || - sigdata->n_samples < 1 || sigdata->n_samples > 255 || - sigdata->n_orders < 1 || sigdata->n_orders > 255 || - ! ntracks || - nchannels < 1 || nchannels > 32 ) { - free( sigdata ); - return NULL; - } - sigdata->n_pchannels = nchannels; - memset( sigdata->channel_volume, 64, DUMB_IT_N_CHANNELS ); + memset(sigdata->channel_volume, 64, DUMB_IT_N_CHANNELS); - if ( ver >= 11 ) { - int nchannels = ( ver >= 13 ) ? 32 : 16; - for ( i = 0; i < nchannels; i++ ) { - signed char panpos = dumbfile_getc( f ); - int pan = ( panpos + 64 ) / 2; - if ( pan < 0 ) pan = 0; - else if ( pan > 64 ) pan = IT_SURROUND; - sigdata->channel_pan[ i ] = pan; - } - } - else { - int sep = 32 * dumb_it_default_panning_separation / 100; - for ( i = 0; i < 16; i++ ) { - sigdata->channel_pan[ i ] = ( dumbfile_getc( f ) & 1 ) ? 32 - sep : 32 + sep; - } - } + if (ver >= 11) { + int nchannels = (ver >= 13) ? 32 : 16; + for (i = 0; i < nchannels; i++) { + signed char panpos = dumbfile_getc(f); + int pan = (panpos + 64) / 2; + if (pan < 0) + pan = 0; + else if (pan > 64) + pan = IT_SURROUND; + sigdata->channel_pan[i] = pan; + } + } else { + int sep = 32 * dumb_it_default_panning_separation / 100; + for (i = 0; i < 16; i++) { + sigdata->channel_pan[i] = + (dumbfile_getc(f) & 1) ? 32 - sep : 32 + sep; + } + } - sigdata->tempo = 125; - sigdata->speed = 6; - if ( ver >= 13 ) { - i = dumbfile_getc( f ); - if ( i >= 32 ) sigdata->tempo = i; - i = dumbfile_getc( f ); - if ( i <= 32 ) sigdata->speed = i; - } + sigdata->tempo = 125; + sigdata->speed = 6; + if (ver >= 13) { + i = dumbfile_getc(f); + if (i >= 32) + sigdata->tempo = i; + i = dumbfile_getc(f); + if (i <= 32) + sigdata->speed = i; + } - sigdata->order = malloc( sigdata->n_orders ); - if ( !sigdata->order ) { - free( sigdata ); - return NULL; - } + sigdata->order = malloc(sigdata->n_orders); + if (!sigdata->order) { + free(sigdata); + return NULL; + } - orderstotracks = malloc( sigdata->n_orders * nchannels * sizeof( unsigned short ) ); - if ( !orderstotracks ) { - free( sigdata->order ); - free( sigdata ); - return NULL; - } + orderstotracks = + malloc(sigdata->n_orders * nchannels * sizeof(unsigned short)); + if (!orderstotracks) { + free(sigdata->order); + free(sigdata); + return NULL; + } - for ( i = 0; i < sigdata->n_orders; i++ ) { - sigdata->order[ i ] = i; - tracksize[ i ] = 64; - if ( ver >= 14 ) { - tracksize[ i ] = dumbfile_igetw( f ); - } - for ( j = 0; j < nchannels; j++ ) { - orderstotracks[ i * nchannels + j ] = dumbfile_igetw( f ); - } - } + for (i = 0; i < sigdata->n_orders; i++) { + sigdata->order[i] = i; + tracksize[i] = 64; + if (ver >= 14) { + tracksize[i] = dumbfile_igetw(f); + } + for (j = 0; j < nchannels; j++) { + orderstotracks[i * nchannels + j] = dumbfile_igetw(f); + } + } - if ( dumbfile_error( f ) ) { - free( orderstotracks ); - free( sigdata->order ); - free( sigdata ); - return NULL; - } + if (dumbfile_error(f)) { + free(orderstotracks); + free(sigdata->order); + free(sigdata); + return NULL; + } - sigdata->sample = malloc( sigdata->n_samples * sizeof( *sigdata->sample ) ); - if ( !sigdata->sample ) { - free( orderstotracks ); - free( sigdata->order ); - free( sigdata ); - return NULL; - } + sigdata->sample = malloc(sigdata->n_samples * sizeof(*sigdata->sample)); + if (!sigdata->sample) { + free(orderstotracks); + free(sigdata->order); + free(sigdata); + return NULL; + } - sigdata->restart_position = 0; + sigdata->restart_position = 0; - sigdata->song_message = NULL; - sigdata->instrument = NULL; - sigdata->pattern = NULL; - sigdata->midi = NULL; - sigdata->checkpoint = NULL; + sigdata->song_message = NULL; + sigdata->instrument = NULL; + sigdata->pattern = NULL; + sigdata->midi = NULL; + sigdata->checkpoint = NULL; - sigdata->n_instruments = 0; + sigdata->n_instruments = 0; - for ( i = 0; i < sigdata->n_samples; ++i ) - sigdata->sample[i].data = NULL; + for (i = 0; i < sigdata->n_samples; ++i) + sigdata->sample[i].data = NULL; - for ( i = 0; i < sigdata->n_samples; ++i ) { - int offset; - if ( it_amf_read_sample_header( &sigdata->sample[i], f, &offset, ver ) ) { - goto error_ott; - } - sampleseekpos[ i ] = offset; - if ( offset > maxsampleseekpos ) maxsampleseekpos = offset; - } + for (i = 0; i < sigdata->n_samples; ++i) { + int offset; + if (it_amf_read_sample_header(&sigdata->sample[i], f, &offset, ver)) { + goto error_ott; + } + sampleseekpos[i] = offset; + if (offset > maxsampleseekpos) + maxsampleseekpos = offset; + } - sigdata->n_patterns = sigdata->n_orders; + sigdata->n_patterns = sigdata->n_orders; - sigdata->pattern = malloc( sigdata->n_patterns * sizeof( *sigdata->pattern ) ); - if ( !sigdata->pattern ) { - goto error_ott; - } - for (i = 0; i < sigdata->n_patterns; ++i) - sigdata->pattern[i].entry = NULL; + sigdata->pattern = malloc(sigdata->n_patterns * sizeof(*sigdata->pattern)); + if (!sigdata->pattern) { + goto error_ott; + } + for (i = 0; i < sigdata->n_patterns; ++i) + sigdata->pattern[i].entry = NULL; - trackmap = malloc( ntracks * sizeof( unsigned short ) ); - if ( !trackmap ) { - goto error_ott; - } + trackmap = malloc(ntracks * sizeof(unsigned short)); + if (!trackmap) { + goto error_ott; + } - if ( dumbfile_getnc( ( char * ) trackmap, ntracks * sizeof( unsigned short ), f ) != (long)(ntracks * sizeof( unsigned short )) ) { - goto error_tm; - } + if (dumbfile_getnc((char *)trackmap, ntracks * sizeof(unsigned short), f) != + (long)(ntracks * sizeof(unsigned short))) { + goto error_tm; + } - realntracks = 0; + realntracks = 0; - for ( i = 0; i < ntracks; i++ ) { - if ( trackmap[ i ] > realntracks ) realntracks = trackmap[ i ]; - } + for (i = 0; i < ntracks; i++) { + if (trackmap[i] > realntracks) + realntracks = trackmap[i]; + } - track = calloc( realntracks, sizeof( unsigned char * ) ); - if ( !track ) { - goto error_tm; - } + track = calloc(realntracks, sizeof(unsigned char *)); + if (!track) { + goto error_tm; + } - for ( i = 0; i < realntracks; i++ ) { - int tracksize = dumbfile_igetw( f ); - tracksize += dumbfile_getc( f ) << 16; - track[ i ] = malloc( tracksize * 3 + 3 ); - if ( !track[ i ] ) { - goto error_all; - } - track[ i ][ 0 ] = tracksize & 255; - track[ i ][ 1 ] = ( tracksize >> 8 ) & 255; - track[ i ][ 2 ] = ( tracksize >> 16 ) & 255; - if ( dumbfile_getnc( (char *) track[ i ] + 3, tracksize * 3, f ) != tracksize * 3 ) { - goto error_all; - } - } + for (i = 0; i < realntracks; i++) { + int tracksize = dumbfile_igetw(f); + tracksize += dumbfile_getc(f) << 16; + track[i] = malloc(tracksize * 3 + 3); + if (!track[i]) { + goto error_all; + } + track[i][0] = tracksize & 255; + track[i][1] = (tracksize >> 8) & 255; + track[i][2] = (tracksize >> 16) & 255; + if (dumbfile_getnc((char *)track[i] + 3, tracksize * 3, f) != + tracksize * 3) { + goto error_all; + } + } - for ( i = 1; i <= maxsampleseekpos; i++ ) { - for ( j = 0; j < sigdata->n_samples; j++ ) { - if ( sampleseekpos[ j ] == i ) { - if ( it_amf_read_sample_data( &sigdata->sample[ j ], f ) ) { - goto error_all; - } - break; - } - } - } + for (i = 1; i <= maxsampleseekpos; i++) { + for (j = 0; j < sigdata->n_samples; j++) { + if (sampleseekpos[j] == i) { + if (it_amf_read_sample_data(&sigdata->sample[j], f)) { + goto error_all; + } + break; + } + } + } - /* Process tracks into patterns */ - for ( i = 0; i < sigdata->n_patterns; i++ ) { - IT_ENTRY * entry_table = calloc( tracksize[ i ] * nchannels, sizeof( IT_ENTRY ) ); - if ( !entry_table ) { - goto error_all; - } - for ( j = 0; j < nchannels; j++ ) { - int ntrack = orderstotracks[ i * nchannels + j ]; - if ( ntrack && ntrack <= ntracks ) { - int realtrack = trackmap[ ntrack - 1 ]; - if ( realtrack ) { - realtrack--; - if ( realtrack < realntracks && track[ realtrack ] ) { - it_amf_process_track( entry_table + j, track[ realtrack ], tracksize[ i ], nchannels ); - } - } - } - } - if ( it_amf_process_pattern( &sigdata->pattern[ i ], entry_table, tracksize[ i ], nchannels ) ) { - free( entry_table ); - goto error_all; - } - free( entry_table ); - } + /* Process tracks into patterns */ + for (i = 0; i < sigdata->n_patterns; i++) { + IT_ENTRY *entry_table = + calloc(tracksize[i] * nchannels, sizeof(IT_ENTRY)); + if (!entry_table) { + goto error_all; + } + for (j = 0; j < nchannels; j++) { + int ntrack = orderstotracks[i * nchannels + j]; + if (ntrack && ntrack <= ntracks) { + int realtrack = trackmap[ntrack - 1]; + if (realtrack) { + realtrack--; + if (realtrack < realntracks && track[realtrack]) { + it_amf_process_track(entry_table + j, track[realtrack], + tracksize[i], nchannels); + } + } + } + } + if (it_amf_process_pattern(&sigdata->pattern[i], entry_table, + tracksize[i], nchannels)) { + free(entry_table); + goto error_all; + } + free(entry_table); + } - /* Now let's initialise the remaining variables, and we're done! */ - sigdata->flags = IT_OLD_EFFECTS | IT_COMPATIBLE_GXX | IT_STEREO | IT_WAS_AN_S3M; + /* Now let's initialise the remaining variables, and we're done! */ + sigdata->flags = + IT_OLD_EFFECTS | IT_COMPATIBLE_GXX | IT_STEREO | IT_WAS_AN_S3M; - sigdata->global_volume = 128; - sigdata->mixing_volume = 48; - sigdata->pan_separation = 128; + sigdata->global_volume = 128; + sigdata->mixing_volume = 48; + sigdata->pan_separation = 128; - _dumb_it_fix_invalid_orders(sigdata); + _dumb_it_fix_invalid_orders(sigdata); - for ( i = 0; i < realntracks; i++ ) { - if ( track[ i ] ) { - free( track[ i ] ); - } - } - free( track ); - free( trackmap ); - free( orderstotracks ); + for (i = 0; i < realntracks; i++) { + if (track[i]) { + free(track[i]); + } + } + free(track); + free(trackmap); + free(orderstotracks); - return sigdata; + return sigdata; error_all: - for ( i = 0; i < realntracks; i++ ) { - if ( track[ i ] ) { - free( track[ i ] ); - } - } - free( track ); + for (i = 0; i < realntracks; i++) { + if (track[i]) { + free(track[i]); + } + } + free(track); error_tm: - free( trackmap ); + free(trackmap); error_ott: - free( orderstotracks ); - _dumb_it_unload_sigdata( sigdata ); - return NULL; + free(orderstotracks); + _dumb_it_unload_sigdata(sigdata); + return NULL; } +DUH *dumb_read_amf_quick(DUMBFILE *f) { + sigdata_t *sigdata; + DUH_SIGTYPE_DESC *descptr = &_dumb_sigtype_it; -DUH *dumb_read_amf_quick(DUMBFILE *f) -{ - sigdata_t *sigdata; + int version; - DUH_SIGTYPE_DESC *descptr = &_dumb_sigtype_it; + sigdata = it_amf_load_sigdata(f, &version); - int version; + if (!sigdata) + return NULL; - sigdata = it_amf_load_sigdata(f, &version); - - if (!sigdata) - return NULL; - - { - const char *tag[2][2]; - char ver_string[14]; - tag[0][0] = "TITLE"; + { + const char *tag[2][2]; + char ver_string[14]; + tag[0][0] = "TITLE"; tag[0][1] = (const char *)(((DUMB_IT_SIGDATA *)sigdata)->name); - tag[1][0] = "FORMAT"; - memcpy( ver_string, "DSMI AMF v", 10 ); - ver_string[10] = '0' + version / 10; - ver_string[11] = '.'; - ver_string[12] = '0' + version % 10; - ver_string[13] = 0; - tag[1][1] = ver_string; - return make_duh(-1, 2, (const char *const (*)[2])tag, 1, &descptr, &sigdata); - } + tag[1][0] = "FORMAT"; + memcpy(ver_string, "DSMI AMF v", 10); + ver_string[10] = '0' + version / 10; + ver_string[11] = '.'; + ver_string[12] = '0' + version % 10; + ver_string[13] = 0; + tag[1][1] = ver_string; + return make_duh(-1, 2, (const char *const(*)[2])tag, 1, &descptr, + &sigdata); + } } diff --git a/Frameworks/Dumb/dumb/src/it/readamf2.c b/Frameworks/Dumb/dumb/src/it/readamf2.c index c2258fc89..397f28145 100644 --- a/Frameworks/Dumb/dumb/src/it/readamf2.c +++ b/Frameworks/Dumb/dumb/src/it/readamf2.c @@ -19,11 +19,8 @@ #include "dumb.h" - - -DUH *dumb_read_amf(DUMBFILE *f) -{ - DUH *duh = dumb_read_amf_quick(f); - dumb_it_do_initial_runthrough(duh); - return duh; +DUH *dumb_read_amf(DUMBFILE *f) { + DUH *duh = dumb_read_amf_quick(f); + dumb_it_do_initial_runthrough(duh); + return duh; } diff --git a/Frameworks/Dumb/dumb/src/it/readany.c b/Frameworks/Dumb/dumb/src/it/readany.c index ec9e37db1..3f5c8d805 100644 --- a/Frameworks/Dumb/dumb/src/it/readany.c +++ b/Frameworks/Dumb/dumb/src/it/readany.c @@ -1,132 +1,103 @@ -/* _______ ____ __ ___ ___ - * \ _ \ \ / \ / \ \ / / ' ' ' - * | | \ \ | | || | \/ | . . - * | | | | | | || ||\ /| | - * | | | | | | || || \/ | | ' ' ' - * | | | | | | || || | | . . - * | |_/ / \ \__// || | | - * /_______/ynamic \____/niversal /__\ /____\usic /| . . ibliotheque - * / \ - * / . \ - * readany.c - Code to detect and read any of the / / \ \ - * module formats supported by DUMB. | < / \_ - * | \/ /\ / - * By Chris Moeller. \_ / > / - * | \ / / - * | ' / - * \__/ - */ - -#include -#include - -#include "dumb.h" - -#ifdef _MSC_VER - #define strnicmp _strnicmp -#else - #if defined(unix) || defined(__unix__) || defined(__unix) - #include - #endif - #define strnicmp strncasecmp -#endif - -enum { maximum_signature_size = 0x30 }; - -DUH *dumb_read_any_quick(DUMBFILE *f, int restrict_, int subsong) -{ - unsigned char signature[ maximum_signature_size ]; - unsigned long signature_size; - DUH * duh = NULL; - - /* signature_size = dumbfile_get_size(f); */ - - signature_size = dumbfile_getnc( (char *)signature, maximum_signature_size, f ); - dumbfile_seek( f, 0, DFS_SEEK_SET ); - - if (signature_size >= 4 && - signature[0] == 'I' && signature[1] == 'M' && - signature[2] == 'P' && signature[3] == 'M') - { - duh = dumb_read_it_quick( f ); - } - else if (signature_size >= 17 && !memcmp(signature, "Extended Module: ", 17)) - { - duh = dumb_read_xm_quick( f ); - } - else if (signature_size >= 0x30 && - signature[0x2C] == 'S' && signature[0x2D] == 'C' && - signature[0x2E] == 'R' && signature[0x2F] == 'M') - { - duh = dumb_read_s3m_quick( f ); - } - else if (signature_size >= 30 && - /*signature[28] == 0x1A &&*/ signature[29] == 2 && - ( ! strnicmp( ( const char * ) signature + 20, "!Scream!", 8 ) || - ! strnicmp( ( const char * ) signature + 20, "BMOD2STM", 8 ) || - ! strnicmp( ( const char * ) signature + 20, "WUZAMOD!", 8 ) ) ) - { - duh = dumb_read_stm_quick( f ); - } - else if (signature_size >= 2 && - ((signature[0] == 0x69 && signature[1] == 0x66) || - (signature[0] == 0x4A && signature[1] == 0x4E))) - { - duh = dumb_read_669_quick( f ); - } - else if (signature_size >= 0x30 && - signature[0x2C] == 'P' && signature[0x2D] == 'T' && - signature[0x2E] == 'M' && signature[0x2F] == 'F') - { - duh = dumb_read_ptm_quick( f ); - } - else if (signature_size >= 4 && - signature[0] == 'P' && signature[1] == 'S' && - signature[2] == 'M' && signature[3] == ' ') - { - duh = dumb_read_psm_quick( f, subsong ); - } - else if (signature_size >= 4 && - signature[0] == 'P' && signature[1] == 'S' && - signature[2] == 'M' && signature[3] == 254) - { - duh = dumb_read_old_psm_quick( f ); - } - else if (signature_size >= 3 && - signature[0] == 'M' && signature[1] == 'T' && - signature[2] == 'M') - { - duh = dumb_read_mtm_quick( f ); - } - else if ( signature_size >= 4 && - signature[0] == 'R' && signature[1] == 'I' && - signature[2] == 'F' && signature[3] == 'F') - { - duh = dumb_read_riff_quick( f ); - } - else if ( signature_size >= 24 && - !memcmp( signature, "ASYLUM Music Format", 19 ) && - !memcmp( signature + 19, " V1.0", 5 ) ) - { - duh = dumb_read_asy_quick( f ); - } - else if ( signature_size >= 3 && - signature[0] == 'A' && signature[1] == 'M' && - signature[2] == 'F') - { - duh = dumb_read_amf_quick( f ); - } - else if ( signature_size >= 8 && - !memcmp( signature, "OKTASONG", 8 ) ) - { - duh = dumb_read_okt_quick( f ); - } - - if ( !duh ) - { - dumbfile_seek( f, 0, DFS_SEEK_SET ); - duh = dumb_read_mod_quick( f, restrict_ ); - } - - return duh; -} +/* _______ ____ __ ___ ___ + * \ _ \ \ / \ / \ \ / / ' ' ' + * | | \ \ | | || | \/ | . . + * | | | | | | || ||\ /| | + * | | | | | | || || \/ | | ' ' ' + * | | | | | | || || | | . . + * | |_/ / \ \__// || | | + * /_______/ynamic \____/niversal /__\ /____\usic /| . . ibliotheque + * / \ + * / . \ + * readany.c - Code to detect and read any of the / / \ \ + * module formats supported by DUMB. | < / \_ + * | \/ /\ / + * By Chris Moeller. \_ / > / + * | \ / / + * | ' / + * \__/ + */ + +#include +#include + +#include "dumb.h" + +#ifdef _MSC_VER +#define strnicmp _strnicmp +#else +#if defined(unix) || defined(__unix__) || defined(__unix) +#include +#endif +#define strnicmp strncasecmp +#endif + +enum { maximum_signature_size = 0x30 }; + +DUH *dumb_read_any_quick(DUMBFILE *f, int restrict_, int subsong) { + unsigned char signature[maximum_signature_size]; + unsigned long signature_size; + DUH *duh = NULL; + + /* signature_size = dumbfile_get_size(f); */ + + signature_size = + dumbfile_getnc((char *)signature, maximum_signature_size, f); + dumbfile_seek(f, 0, DFS_SEEK_SET); + + if (signature_size >= 4 && signature[0] == 'I' && signature[1] == 'M' && + signature[2] == 'P' && signature[3] == 'M') { + duh = dumb_read_it_quick(f); + } else if (signature_size >= 17 && + !memcmp(signature, "Extended Module: ", 17)) { + duh = dumb_read_xm_quick(f); + } else if (signature_size >= 0x30 && signature[0x2C] == 'S' && + signature[0x2D] == 'C' && signature[0x2E] == 'R' && + signature[0x2F] == 'M') { + duh = dumb_read_s3m_quick(f); + } else if (signature_size >= 30 && + /*signature[28] == 0x1A &&*/ signature[29] == 2 && + (!strnicmp((const char *)signature + 20, "!Scream!", 8) || + !strnicmp((const char *)signature + 20, "BMOD2STM", 8) || + !strnicmp((const char *)signature + 20, "WUZAMOD!", 8))) { + duh = dumb_read_stm_quick(f); + } else if (signature_size >= 2 && + ((signature[0] == 0x69 && signature[1] == 0x66) || + (signature[0] == 0x4A && signature[1] == 0x4E))) { + duh = dumb_read_669_quick(f); + } else if (signature_size >= 0x30 && signature[0x2C] == 'P' && + signature[0x2D] == 'T' && signature[0x2E] == 'M' && + signature[0x2F] == 'F') { + duh = dumb_read_ptm_quick(f); + } else if (signature_size >= 4 && signature[0] == 'P' && + signature[1] == 'S' && signature[2] == 'M' && + signature[3] == ' ') { + duh = dumb_read_psm_quick(f, subsong); + } else if (signature_size >= 4 && signature[0] == 'P' && + signature[1] == 'S' && signature[2] == 'M' && + signature[3] == 254) { + duh = dumb_read_old_psm_quick(f); + } else if (signature_size >= 3 && signature[0] == 'M' && + signature[1] == 'T' && signature[2] == 'M') { + duh = dumb_read_mtm_quick(f); + } else if (signature_size >= 4 && signature[0] == 'R' && + signature[1] == 'I' && signature[2] == 'F' && + signature[3] == 'F') { + duh = dumb_read_riff_quick(f); + } else if (signature_size >= 24 && + !memcmp(signature, "ASYLUM Music Format", 19) && + !memcmp(signature + 19, " V1.0", 5)) { + duh = dumb_read_asy_quick(f); + } else if (signature_size >= 3 && signature[0] == 'A' && + signature[1] == 'M' && signature[2] == 'F') { + duh = dumb_read_amf_quick(f); + } else if (signature_size >= 8 && !memcmp(signature, "OKTASONG", 8)) { + duh = dumb_read_okt_quick(f); + } + + if (!duh) { + dumbfile_seek(f, 0, DFS_SEEK_SET); + duh = dumb_read_mod_quick(f, restrict_); + } + + return duh; +} diff --git a/Frameworks/Dumb/dumb/src/it/readany2.c b/Frameworks/Dumb/dumb/src/it/readany2.c index ac881a717..fef2023cd 100644 --- a/Frameworks/Dumb/dumb/src/it/readany2.c +++ b/Frameworks/Dumb/dumb/src/it/readany2.c @@ -19,11 +19,8 @@ #include "dumb.h" - - -DUH *dumb_read_any(DUMBFILE *f, int restrict_, int subsong) -{ +DUH *dumb_read_any(DUMBFILE *f, int restrict_, int subsong) { DUH *duh = dumb_read_any_quick(f, restrict_, subsong); - dumb_it_do_initial_runthrough(duh); - return duh; + dumb_it_do_initial_runthrough(duh); + return duh; } diff --git a/Frameworks/Dumb/dumb/src/it/readasy.c b/Frameworks/Dumb/dumb/src/it/readasy.c index 7768ea53f..8ebe4a3d7 100644 --- a/Frameworks/Dumb/dumb/src/it/readasy.c +++ b/Frameworks/Dumb/dumb/src/it/readasy.c @@ -24,316 +24,318 @@ #include "dumb.h" #include "internal/it.h" +static int it_asy_read_pattern(IT_PATTERN *pattern, DUMBFILE *f, + unsigned char *buffer) { + int pos; + int channel; + int row; + IT_ENTRY *entry; + pattern->n_rows = 64; -static int it_asy_read_pattern( IT_PATTERN *pattern, DUMBFILE *f, unsigned char *buffer ) -{ - int pos; - int channel; - int row; - IT_ENTRY *entry; + if (dumbfile_getnc((char *)buffer, 64 * 8 * 4, f) != 64 * 8 * 4) + return -1; - pattern->n_rows = 64; + /* compute number of entries */ + pattern->n_entries = 64; /* Account for the row end markers */ + pos = 0; + for (row = 0; row < 64; ++row) { + for (channel = 0; channel < 8; ++channel) { + if (buffer[pos + 0] | buffer[pos + 1] | buffer[pos + 2] | + buffer[pos + 3]) + ++pattern->n_entries; + pos += 4; + } + } - if ( dumbfile_getnc( (char *) buffer, 64 * 8 * 4, f ) != 64 * 8 * 4 ) - return -1; + pattern->entry = malloc(pattern->n_entries * sizeof(*pattern->entry)); + if (!pattern->entry) + return -1; - /* compute number of entries */ - pattern->n_entries = 64; /* Account for the row end markers */ - pos = 0; - for ( row = 0; row < 64; ++row ) { - for ( channel = 0; channel < 8; ++channel ) { - if ( buffer[ pos + 0 ] | buffer[ pos + 1 ] | buffer[ pos + 2 ] | buffer[ pos + 3 ] ) - ++pattern->n_entries; - pos += 4; - } - } + entry = pattern->entry; + pos = 0; + for (row = 0; row < 64; ++row) { + for (channel = 0; channel < 8; ++channel) { + if (buffer[pos + 0] | buffer[pos + 1] | buffer[pos + 2] | + buffer[pos + 3]) { + entry->channel = channel; + entry->mask = 0; - pattern->entry = malloc( pattern->n_entries * sizeof( *pattern->entry ) ); - if ( !pattern->entry ) - return -1; - - entry = pattern->entry; - pos = 0; - for ( row = 0; row < 64; ++row ) { - for ( channel = 0; channel < 8; ++channel ) { - if ( buffer[ pos + 0 ] | buffer[ pos + 1 ] | buffer[ pos + 2 ] | buffer[ pos + 3 ] ) { - entry->channel = channel; - entry->mask = 0; - - if ( buffer[ pos + 0 ] && buffer[ pos + 0 ] < 96 ) { - entry->note = buffer[ pos + 0 ]; - entry->mask |= IT_ENTRY_NOTE; - } - - if ( buffer[ pos + 1 ] && buffer[ pos + 1 ] <= 64 ) { - entry->instrument = buffer[ pos + 1 ]; - entry->mask |= IT_ENTRY_INSTRUMENT; - } - - _dumb_it_xm_convert_effect( buffer[ pos + 2 ], buffer[ pos + 3 ], entry, 1 ); - - // fixup - switch ( entry->effect ) { - case IT_SET_PANNING: - entry->effectvalue <<= 1; - break; + if (buffer[pos + 0] && buffer[pos + 0] < 96) { + entry->note = buffer[pos + 0]; + entry->mask |= IT_ENTRY_NOTE; } - if ( entry->mask ) ++entry; - } - pos += 4; - } - IT_SET_END_ROW( entry ); - ++entry; - } + if (buffer[pos + 1] && buffer[pos + 1] <= 64) { + entry->instrument = buffer[pos + 1]; + entry->mask |= IT_ENTRY_INSTRUMENT; + } - pattern->n_entries = (int)(entry - pattern->entry); + _dumb_it_xm_convert_effect(buffer[pos + 2], buffer[pos + 3], + entry, 1); - return 0; + // fixup + switch (entry->effect) { + case IT_SET_PANNING: + entry->effectvalue <<= 1; + break; + } + + if (entry->mask) + ++entry; + } + pos += 4; + } + IT_SET_END_ROW(entry); + ++entry; + } + + pattern->n_entries = (int)(entry - pattern->entry); + + return 0; } +static int it_asy_read_sample_header(IT_SAMPLE *sample, DUMBFILE *f) { + int finetune, key_offset; + /** + 21 22 Chars Sample 1 name. If the name is not a full + 22 chars in length, it will be null + terminated. -static int it_asy_read_sample_header( IT_SAMPLE *sample, DUMBFILE *f ) -{ - int finetune, key_offset; + If + the sample name begins with a '#' character (ASCII $23 (35)) then this is + assumed not to be an instrument name, and is probably a message. + */ + dumbfile_getnc((char *)sample->name, 22, f); + sample->name[22] = 0; -/** - 21 22 Chars Sample 1 name. If the name is not a full - 22 chars in length, it will be null - terminated. + sample->filename[0] = 0; -If -the sample name begins with a '#' character (ASCII $23 (35)) then this is -assumed not to be an instrument name, and is probably a message. -*/ - dumbfile_getnc( (char *) sample->name, 22, f ); - sample->name[22] = 0; + /** Each finetune step changes the note 1/8th of a semitone. */ + finetune = (signed char)(dumbfile_getc(f) << 4) >> 4; /* signed nibble */ + sample->default_volume = + dumbfile_getc(f); // Should we be setting global_volume to this instead? + sample->global_volume = 64; + if (sample->default_volume > 64) + sample->default_volume = 64; + key_offset = (signed char)dumbfile_getc(f); /* base key offset */ + sample->length = dumbfile_igetl(f); + sample->loop_start = dumbfile_igetl(f); + sample->loop_end = sample->loop_start + dumbfile_igetl(f); - sample->filename[0] = 0; + if (sample->length <= 0) { + sample->flags = 0; + return 0; + } -/** Each finetune step changes the note 1/8th of a semitone. */ - finetune = ( signed char ) ( dumbfile_getc( f ) << 4 ) >> 4; /* signed nibble */ - sample->default_volume = dumbfile_getc( f ); // Should we be setting global_volume to this instead? - sample->global_volume = 64; - if ( sample->default_volume > 64 ) sample->default_volume = 64; - key_offset = ( signed char ) dumbfile_getc( f ); /* base key offset */ - sample->length = dumbfile_igetl( f ); - sample->loop_start = dumbfile_igetl( f ); - sample->loop_end = sample->loop_start + dumbfile_igetl( f ); + sample->flags = IT_SAMPLE_EXISTS; - if ( sample->length <= 0 ) { - sample->flags = 0; - return 0; - } + sample->default_pan = 0; + sample->C5_speed = + (int)(AMIGA_CLOCK / 214.0 * + pow(DUMB_SEMITONE_BASE, key_offset)); //( long )( 16726.0 * pow( + // DUMB_PITCH_BASE, finetune + //* 32 ) ); + sample->finetune = finetune * 32; + // the above line might be wrong - sample->flags = IT_SAMPLE_EXISTS; + if ((sample->loop_end - sample->loop_start > 2) && + (sample->loop_end <= sample->length)) + sample->flags |= IT_SAMPLE_LOOP; - sample->default_pan = 0; - sample->C5_speed = (int)( AMIGA_CLOCK / 214.0 * pow( DUMB_SEMITONE_BASE, key_offset ) );//( long )( 16726.0 * pow( DUMB_PITCH_BASE, finetune * 32 ) ); - sample->finetune = finetune * 32; - // the above line might be wrong + sample->vibrato_speed = 0; + sample->vibrato_depth = 0; + sample->vibrato_rate = 0; + sample->vibrato_waveform = 0; // do we have to set _all_ these? + sample->max_resampling_quality = -1; - if ( ( sample->loop_end - sample->loop_start > 2 ) && ( sample->loop_end <= sample->length ) ) - sample->flags |= IT_SAMPLE_LOOP; - - sample->vibrato_speed = 0; - sample->vibrato_depth = 0; - sample->vibrato_rate = 0; - sample->vibrato_waveform = 0; // do we have to set _all_ these? - sample->max_resampling_quality = -1; - - return dumbfile_error(f); + return dumbfile_error(f); } +static int it_asy_read_sample_data(IT_SAMPLE *sample, DUMBFILE *f) { + long truncated_size; + /* let's get rid of the sample data coming after the end of the loop */ + if ((sample->flags & IT_SAMPLE_LOOP) && sample->loop_end < sample->length) { + truncated_size = sample->length - sample->loop_end; + sample->length = sample->loop_end; + } else { + truncated_size = 0; + } -static int it_asy_read_sample_data( IT_SAMPLE *sample, DUMBFILE *f ) -{ - long truncated_size; + sample->data = malloc(sample->length); - /* let's get rid of the sample data coming after the end of the loop */ - if ( ( sample->flags & IT_SAMPLE_LOOP ) && sample->loop_end < sample->length ) { - truncated_size = sample->length - sample->loop_end; - sample->length = sample->loop_end; - } else { - truncated_size = 0; - } + if (!sample->data) + return -1; - sample->data = malloc( sample->length ); + if (sample->length) + dumbfile_getnc(sample->data, sample->length, f); - if ( !sample->data ) - return -1; + dumbfile_skip(f, truncated_size); - if ( sample->length ) - dumbfile_getnc( sample->data, sample->length, f ); - - dumbfile_skip( f, truncated_size ); - - return dumbfile_error( f ); + return dumbfile_error(f); } +static DUMB_IT_SIGDATA *it_asy_load_sigdata(DUMBFILE *f) { + DUMB_IT_SIGDATA *sigdata; + int i; + static const char sig_part[] = "ASYLUM Music Format"; + static const char sig_rest[] = + " V1.0"; /* whee, string space optimization with format type below */ -static DUMB_IT_SIGDATA *it_asy_load_sigdata(DUMBFILE *f) -{ - DUMB_IT_SIGDATA *sigdata; - int i; + char signature[32]; - static const char sig_part[] = "ASYLUM Music Format"; - static const char sig_rest[] = " V1.0"; /* whee, string space optimization with format type below */ + if (dumbfile_getnc(signature, 32, f) != 32 || + memcmp(signature, sig_part, 19) || + memcmp(signature + 19, sig_rest, 5)) { + return NULL; + } - char signature [32]; + sigdata = malloc(sizeof(*sigdata)); + if (!sigdata) { + return NULL; + } - if ( dumbfile_getnc( signature, 32, f ) != 32 || - memcmp( signature, sig_part, 19 ) || - memcmp( signature + 19, sig_rest, 5 ) ) { - return NULL; - } + sigdata->speed = dumbfile_getc(f); /* XXX seems to fit the files I have */ + sigdata->tempo = dumbfile_getc(f); /* ditto */ + sigdata->n_samples = dumbfile_getc(f); /* ditto */ + sigdata->n_patterns = dumbfile_getc(f); + sigdata->n_orders = dumbfile_getc(f); + sigdata->restart_position = dumbfile_getc(f); - sigdata = malloc(sizeof(*sigdata)); - if (!sigdata) { - return NULL; - } + if (dumbfile_error(f) || !sigdata->n_samples || sigdata->n_samples > 64 || + !sigdata->n_patterns || !sigdata->n_orders) { + free(sigdata); + return NULL; + } - sigdata->speed = dumbfile_getc( f ); /* XXX seems to fit the files I have */ - sigdata->tempo = dumbfile_getc( f ); /* ditto */ - sigdata->n_samples = dumbfile_getc( f ); /* ditto */ - sigdata->n_patterns = dumbfile_getc( f ); - sigdata->n_orders = dumbfile_getc( f ); - sigdata->restart_position = dumbfile_getc( f ); + if (sigdata->restart_position > sigdata->n_orders) /* XXX */ + sigdata->restart_position = 0; - if ( dumbfile_error( f ) || !sigdata->n_samples || sigdata->n_samples > 64 || !sigdata->n_patterns || - !sigdata->n_orders ) { - free( sigdata ); - return NULL; - } + sigdata->order = malloc(sigdata->n_orders); + if (!sigdata->order) { + free(sigdata); + return NULL; + } - if ( sigdata->restart_position > sigdata->n_orders ) /* XXX */ - sigdata->restart_position = 0; + if (dumbfile_getnc((char *)sigdata->order, sigdata->n_orders, f) != + sigdata->n_orders || + dumbfile_skip(f, 256 - sigdata->n_orders)) { + free(sigdata->order); + free(sigdata); + return NULL; + } - sigdata->order = malloc( sigdata->n_orders ); - if ( !sigdata->order ) { - free( sigdata ); - return NULL; - } + sigdata->sample = malloc(sigdata->n_samples * sizeof(*sigdata->sample)); + if (!sigdata->sample) { + free(sigdata->order); + free(sigdata); + return NULL; + } - if ( dumbfile_getnc( (char *) sigdata->order, sigdata->n_orders, f ) != sigdata->n_orders || - dumbfile_skip( f, 256 - sigdata->n_orders ) ) { - free( sigdata->order ); - free( sigdata ); - return NULL; - } + sigdata->song_message = NULL; + sigdata->instrument = NULL; + sigdata->pattern = NULL; + sigdata->midi = NULL; + sigdata->checkpoint = NULL; - sigdata->sample = malloc( sigdata->n_samples * sizeof( *sigdata->sample ) ); - if ( !sigdata->sample ) { - free( sigdata->order ); - free( sigdata ); - return NULL; - } + sigdata->n_instruments = 0; - sigdata->song_message = NULL; - sigdata->instrument = NULL; - sigdata->pattern = NULL; - sigdata->midi = NULL; - sigdata->checkpoint = NULL; + for (i = 0; i < sigdata->n_samples; ++i) + sigdata->sample[i].data = NULL; - sigdata->n_instruments = 0; + for (i = 0; i < sigdata->n_samples; ++i) { + if (it_asy_read_sample_header(&sigdata->sample[i], f)) { + _dumb_it_unload_sigdata(sigdata); + return NULL; + } + } - for ( i = 0; i < sigdata->n_samples; ++i ) - sigdata->sample[i].data = NULL; + if (dumbfile_skip(f, 37 * (64 - sigdata->n_samples))) { + _dumb_it_unload_sigdata(sigdata); + return NULL; + } - for ( i = 0; i < sigdata->n_samples; ++i ) { - if ( it_asy_read_sample_header( &sigdata->sample[i], f ) ) { - _dumb_it_unload_sigdata( sigdata ); - return NULL; - } - } + sigdata->pattern = malloc(sigdata->n_patterns * sizeof(*sigdata->pattern)); + if (!sigdata->pattern) { + _dumb_it_unload_sigdata(sigdata); + return NULL; + } + for (i = 0; i < sigdata->n_patterns; ++i) + sigdata->pattern[i].entry = NULL; - if ( dumbfile_skip( f, 37 * ( 64 - sigdata->n_samples ) ) ) { - _dumb_it_unload_sigdata( sigdata ); - return NULL; - } + /* Read in the patterns */ + { + unsigned char *buffer = + malloc(64 * 8 * 4); /* 64 rows * 8 channels * 4 bytes */ + if (!buffer) { + _dumb_it_unload_sigdata(sigdata); + return NULL; + } + for (i = 0; i < sigdata->n_patterns; ++i) { + if (it_asy_read_pattern(&sigdata->pattern[i], f, buffer) != 0) { + free(buffer); + _dumb_it_unload_sigdata(sigdata); + return NULL; + } + } + free(buffer); + } - sigdata->pattern = malloc( sigdata->n_patterns * sizeof( *sigdata->pattern ) ); - if ( !sigdata->pattern ) { - _dumb_it_unload_sigdata( sigdata ); - return NULL; - } - for (i = 0; i < sigdata->n_patterns; ++i) - sigdata->pattern[i].entry = NULL; + /* And finally, the sample data */ + for (i = 0; i < sigdata->n_samples; ++i) { + if (it_asy_read_sample_data(&sigdata->sample[i], f)) { + _dumb_it_unload_sigdata(sigdata); + return NULL; + } + } - /* Read in the patterns */ - { - unsigned char *buffer = malloc( 64 * 8 * 4 ); /* 64 rows * 8 channels * 4 bytes */ - if ( !buffer ) { - _dumb_it_unload_sigdata( sigdata ); - return NULL; - } - for ( i = 0; i < sigdata->n_patterns; ++i ) { - if ( it_asy_read_pattern( &sigdata->pattern[i], f, buffer ) != 0 ) { - free( buffer ); - _dumb_it_unload_sigdata( sigdata ); - return NULL; - } - } - free( buffer ); - } + /* Now let's initialise the remaining variables, and we're done! */ + sigdata->flags = IT_WAS_AN_XM | IT_WAS_A_MOD | IT_OLD_EFFECTS | + IT_COMPATIBLE_GXX | IT_STEREO; - /* And finally, the sample data */ - for ( i = 0; i < sigdata->n_samples; ++i ) { - if ( it_asy_read_sample_data( &sigdata->sample[i], f ) ) { - _dumb_it_unload_sigdata( sigdata ); - return NULL; - } - } + sigdata->global_volume = 128; + sigdata->mixing_volume = 48; + sigdata->pan_separation = 128; - /* Now let's initialise the remaining variables, and we're done! */ - sigdata->flags = IT_WAS_AN_XM | IT_WAS_A_MOD | IT_OLD_EFFECTS | IT_COMPATIBLE_GXX | IT_STEREO; + sigdata->n_pchannels = 8; - sigdata->global_volume = 128; - sigdata->mixing_volume = 48; - sigdata->pan_separation = 128; + sigdata->name[0] = 0; - sigdata->n_pchannels = 8; + memset(sigdata->channel_volume, 64, DUMB_IT_N_CHANNELS); - sigdata->name[0] = 0; + for (i = 0; i < DUMB_IT_N_CHANNELS; i += 4) { + int sep = 32 * dumb_it_default_panning_separation / 100; + sigdata->channel_pan[i + 0] = 32 - sep; + sigdata->channel_pan[i + 1] = 32 + sep; + sigdata->channel_pan[i + 2] = 32 + sep; + sigdata->channel_pan[i + 3] = 32 - sep; + } - memset(sigdata->channel_volume, 64, DUMB_IT_N_CHANNELS); + _dumb_it_fix_invalid_orders(sigdata); - for (i = 0; i < DUMB_IT_N_CHANNELS; i += 4) { - int sep = 32 * dumb_it_default_panning_separation / 100; - sigdata->channel_pan[i+0] = 32 - sep; - sigdata->channel_pan[i+1] = 32 + sep; - sigdata->channel_pan[i+2] = 32 + sep; - sigdata->channel_pan[i+3] = 32 - sep; - } - - _dumb_it_fix_invalid_orders(sigdata); - - return sigdata; + return sigdata; } +DUH *dumb_read_asy_quick(DUMBFILE *f) { + sigdata_t *sigdata; + DUH_SIGTYPE_DESC *descptr = &_dumb_sigtype_it; -DUH *dumb_read_asy_quick(DUMBFILE *f) -{ - sigdata_t *sigdata; + sigdata = it_asy_load_sigdata(f); - DUH_SIGTYPE_DESC *descptr = &_dumb_sigtype_it; + if (!sigdata) + return NULL; - sigdata = it_asy_load_sigdata(f); - - if (!sigdata) - return NULL; - - { - const char *tag[2][2]; - tag[0][0] = "TITLE"; + { + const char *tag[2][2]; + tag[0][0] = "TITLE"; tag[0][1] = (const char *)(((DUMB_IT_SIGDATA *)sigdata)->name); - tag[1][0] = "FORMAT"; - tag[1][1] = "ASYLUM Music Format"; - return make_duh(-1, 2, (const char *const (*)[2])tag, 1, &descptr, &sigdata); - } + tag[1][0] = "FORMAT"; + tag[1][1] = "ASYLUM Music Format"; + return make_duh(-1, 2, (const char *const(*)[2])tag, 1, &descptr, + &sigdata); + } } diff --git a/Frameworks/Dumb/dumb/src/it/readdsmf.c b/Frameworks/Dumb/dumb/src/it/readdsmf.c index 62c74e815..2095f66b7 100644 --- a/Frameworks/Dumb/dumb/src/it/readdsmf.c +++ b/Frameworks/Dumb/dumb/src/it/readdsmf.c @@ -24,360 +24,367 @@ #include "internal/it.h" #include "internal/riff.h" -static int it_riff_dsmf_process_sample( IT_SAMPLE * sample, DUMBFILE * f, int len ) -{ - int flags; +static int it_riff_dsmf_process_sample(IT_SAMPLE *sample, DUMBFILE *f, + int len) { + int flags; - dumbfile_getnc( (char *) sample->filename, 13, f ); - sample->filename[ 14 ] = 0; - - flags = dumbfile_igetw( f ); - sample->default_volume = dumbfile_getc( f ); - sample->length = dumbfile_igetl( f ); - sample->loop_start = dumbfile_igetl( f ); - sample->loop_end = dumbfile_igetl( f ); - dumbfile_skip( f, 32 - 28 ); - sample->C5_speed = dumbfile_igetw( f ) * 2; - dumbfile_skip( f, 36 - 34 ); - dumbfile_getnc( (char *) sample->name, 28, f ); - sample->name[ 28 ] = 0; + dumbfile_getnc((char *)sample->filename, 13, f); + sample->filename[14] = 0; - /*if ( data[ 0x38 ] || data[ 0x39 ] || data[ 0x3A ] || data[ 0x3B ] ) - return -1;*/ + flags = dumbfile_igetw(f); + sample->default_volume = dumbfile_getc(f); + sample->length = dumbfile_igetl(f); + sample->loop_start = dumbfile_igetl(f); + sample->loop_end = dumbfile_igetl(f); + dumbfile_skip(f, 32 - 28); + sample->C5_speed = dumbfile_igetw(f) * 2; + dumbfile_skip(f, 36 - 34); + dumbfile_getnc((char *)sample->name, 28, f); + sample->name[28] = 0; - if ( ! sample->length ) { - sample->flags &= ~IT_SAMPLE_EXISTS; - return 0; - } + /*if ( data[ 0x38 ] || data[ 0x39 ] || data[ 0x3A ] || data[ 0x3B ] ) + return -1;*/ - /*if ( flags & ~( 2 | 1 ) ) - return -1;*/ + if (!sample->length) { + sample->flags &= ~IT_SAMPLE_EXISTS; + return 0; + } - if ( sample->length + 64 > len ) - return -1; + /*if ( flags & ~( 2 | 1 ) ) + return -1;*/ - sample->flags = IT_SAMPLE_EXISTS; + if (sample->length + 64 > len) + return -1; - sample->default_pan = 0; - sample->global_volume = 64; - sample->vibrato_speed = 0; - sample->vibrato_depth = 0; - sample->vibrato_rate = 0; - sample->vibrato_waveform = IT_VIBRATO_SINE; - sample->finetune = 0; - sample->max_resampling_quality = -1; + sample->flags = IT_SAMPLE_EXISTS; - if ( flags & 1 ) - { - if (((unsigned int)sample->loop_end <= (unsigned int)sample->length) && - ((unsigned int)sample->loop_start < (unsigned int)sample->loop_end)) - { - sample->length = sample->loop_end; - sample->flags |= IT_SAMPLE_LOOP; - if ( flags & 0x10 ) sample->flags |= IT_SAMPLE_PINGPONG_LOOP; - } - } + sample->default_pan = 0; + sample->global_volume = 64; + sample->vibrato_speed = 0; + sample->vibrato_depth = 0; + sample->vibrato_rate = 0; + sample->vibrato_waveform = IT_VIBRATO_SINE; + sample->finetune = 0; + sample->max_resampling_quality = -1; - sample->data = malloc( sample->length ); - if ( ! sample->data ) - return -1; + if (flags & 1) { + if (((unsigned int)sample->loop_end <= (unsigned int)sample->length) && + ((unsigned int)sample->loop_start < + (unsigned int)sample->loop_end)) { + sample->length = sample->loop_end; + sample->flags |= IT_SAMPLE_LOOP; + if (flags & 0x10) + sample->flags |= IT_SAMPLE_PINGPONG_LOOP; + } + } - dumbfile_getnc( sample->data, sample->length, f ); + sample->data = malloc(sample->length); + if (!sample->data) + return -1; - if ( ! ( flags & 2 ) ) - { - for ( flags = 0; flags < sample->length; ++flags ) - ( ( signed char * ) sample->data ) [ flags ] ^= 0x80; - } + dumbfile_getnc(sample->data, sample->length, f); - return 0; + if (!(flags & 2)) { + for (flags = 0; flags < sample->length; ++flags) + ((signed char *)sample->data)[flags] ^= 0x80; + } + + return 0; } -static int it_riff_dsmf_process_pattern( IT_PATTERN * pattern, DUMBFILE * f, int len ) -{ +static int it_riff_dsmf_process_pattern(IT_PATTERN *pattern, DUMBFILE *f, + int len) { int length, row; - unsigned flags; + unsigned flags; long start, end; int p, q, r; - IT_ENTRY * entry; + IT_ENTRY *entry; - length = dumbfile_igetw( f ); - if ( length > len ) return -1; + length = dumbfile_igetw(f); + if (length > len) + return -1; - len = length - 2; + len = length - 2; - pattern->n_rows = 64; - pattern->n_entries = 64; + pattern->n_rows = 64; + pattern->n_entries = 64; - row = 0; + row = 0; - start = dumbfile_pos( f ); + start = dumbfile_pos(f); end = start + len; - while ( (row < 64) && !dumbfile_error( f ) && (dumbfile_pos( f ) < end) ) { - p = dumbfile_getc( f ); - if ( ! p ) { - ++ row; - continue; - } + while ((row < 64) && !dumbfile_error(f) && (dumbfile_pos(f) < end)) { + p = dumbfile_getc(f); + if (!p) { + ++row; + continue; + } flags = p & 0xF0; - if (flags) { - ++ pattern->n_entries; - if (flags & 0x80) dumbfile_skip( f, 1 ); - if (flags & 0x40) dumbfile_skip( f, 1 ); - if (flags & 0x20) dumbfile_skip( f, 1 ); - if (flags & 0x10) dumbfile_skip( f, 2 ); - } - } + if (flags) { + ++pattern->n_entries; + if (flags & 0x80) + dumbfile_skip(f, 1); + if (flags & 0x40) + dumbfile_skip(f, 1); + if (flags & 0x20) + dumbfile_skip(f, 1); + if (flags & 0x10) + dumbfile_skip(f, 2); + } + } - if ( pattern->n_entries == 64 ) return 0; + if (pattern->n_entries == 64) + return 0; - pattern->entry = malloc( pattern->n_entries * sizeof( * pattern->entry ) ); - if ( ! pattern->entry ) return -1; + pattern->entry = malloc(pattern->n_entries * sizeof(*pattern->entry)); + if (!pattern->entry) + return -1; - entry = pattern->entry; + entry = pattern->entry; - row = 0; + row = 0; - if ( dumbfile_seek( f, start, DFS_SEEK_SET ) ) return -1; + if (dumbfile_seek(f, start, DFS_SEEK_SET)) + return -1; - while ( ( row < 64 ) && !dumbfile_error( f ) && ( dumbfile_pos( f ) < end ) ) - { - p = dumbfile_getc( f ); - if ( ! p ) - { - IT_SET_END_ROW( entry ); - ++ entry; - ++ row; - continue; - } + while ((row < 64) && !dumbfile_error(f) && (dumbfile_pos(f) < end)) { + p = dumbfile_getc(f); + if (!p) { + IT_SET_END_ROW(entry); + ++entry; + ++row; + continue; + } flags = p; - entry->channel = flags & 0x0F; - entry->mask = 0; + entry->channel = flags & 0x0F; + entry->mask = 0; - if ( flags & 0xF0 ) - { - if ( flags & 0x80 ) - { - q = dumbfile_getc( f ); - if ( q ) - { - entry->mask |= IT_ENTRY_NOTE; + if (flags & 0xF0) { + if (flags & 0x80) { + q = dumbfile_getc(f); + if (q) { + entry->mask |= IT_ENTRY_NOTE; entry->note = q - 1; - } - } + } + } - if ( flags & 0x40 ) - { - q = dumbfile_getc( f ); - if ( q ) - { - entry->mask |= IT_ENTRY_INSTRUMENT; + if (flags & 0x40) { + q = dumbfile_getc(f); + if (q) { + entry->mask |= IT_ENTRY_INSTRUMENT; entry->instrument = q; - } - } + } + } - if ( flags & 0x20 ) - { - entry->mask |= IT_ENTRY_VOLPAN; - entry->volpan = dumbfile_getc( f ); - } + if (flags & 0x20) { + entry->mask |= IT_ENTRY_VOLPAN; + entry->volpan = dumbfile_getc(f); + } - if ( flags & 0x10 ) - { - q = dumbfile_getc( f ); - r = dumbfile_getc( f ); - _dumb_it_xm_convert_effect( q, r, entry, 0 ); - } + if (flags & 0x10) { + q = dumbfile_getc(f); + r = dumbfile_getc(f); + _dumb_it_xm_convert_effect(q, r, entry, 0); + } - if (entry->mask) entry++; - } - } + if (entry->mask) + entry++; + } + } - while ( row < 64 ) - { - IT_SET_END_ROW( entry ); - ++ entry; - ++ row; - } + while (row < 64) { + IT_SET_END_ROW(entry); + ++entry; + ++row; + } - pattern->n_entries = entry - pattern->entry; - if ( ! pattern->n_entries ) return -1; + pattern->n_entries = (int)((long)entry - (long)pattern->entry); + if (!pattern->n_entries) + return -1; - return 0; + return 0; } -static DUMB_IT_SIGDATA *it_riff_dsmf_load_sigdata( DUMBFILE * f, struct riff * stream ) -{ - DUMB_IT_SIGDATA *sigdata; +static DUMB_IT_SIGDATA *it_riff_dsmf_load_sigdata(DUMBFILE *f, + struct riff *stream) { + DUMB_IT_SIGDATA *sigdata; - int n, o, found; + int n, o, found; - if ( ! stream ) goto error; + if (!stream) + goto error; - if ( stream->type != DUMB_ID( 'D', 'S', 'M', 'F' ) ) goto error; + if (stream->type != DUMB_ID('D', 'S', 'M', 'F')) + goto error; - sigdata = malloc(sizeof(*sigdata)); - if ( ! sigdata ) goto error; + sigdata = malloc(sizeof(*sigdata)); + if (!sigdata) + goto error; - sigdata->n_patterns = 0; - sigdata->n_samples = 0; - sigdata->name[0] = 0; + sigdata->n_patterns = 0; + sigdata->n_samples = 0; + sigdata->name[0] = 0; - found = 0; + found = 0; - for ( n = 0; (unsigned)n < stream->chunk_count; ++n ) - { - struct riff_chunk * c = stream->chunks + n; - switch( c->type ) - { - case DUMB_ID( 'S' ,'O' ,'N' ,'G' ): - /* initialization data */ - if ( ( found ) || ( c->size < 192 ) ) goto error_sd; - found = 1; - break; + for (n = 0; (unsigned)n < stream->chunk_count; ++n) { + struct riff_chunk *c = stream->chunks + n; + switch (c->type) { + case DUMB_ID('S', 'O', 'N', 'G'): + /* initialization data */ + if ((found) || (c->size < 192)) + goto error_sd; + found = 1; + break; - case DUMB_ID( 'P', 'A', 'T', 'T' ): - ++ sigdata->n_patterns; - break; + case DUMB_ID('P', 'A', 'T', 'T'): + ++sigdata->n_patterns; + break; - case DUMB_ID( 'I', 'N', 'S', 'T' ): - ++ sigdata->n_samples; - break; - } - } + case DUMB_ID('I', 'N', 'S', 'T'): + ++sigdata->n_samples; + break; + } + } - if ( !found || !sigdata->n_samples || !sigdata->n_patterns ) goto error_sd; + if (!found || !sigdata->n_samples || !sigdata->n_patterns) + goto error_sd; - if ( sigdata->n_samples > 255 || sigdata->n_patterns > 255 ) goto error_sd; + if (sigdata->n_samples > 255 || sigdata->n_patterns > 255) + goto error_sd; - sigdata->song_message = NULL; - sigdata->order = NULL; - sigdata->instrument = NULL; - sigdata->sample = NULL; - sigdata->pattern = NULL; - sigdata->midi = NULL; - sigdata->checkpoint = NULL; + sigdata->song_message = NULL; + sigdata->order = NULL; + sigdata->instrument = NULL; + sigdata->sample = NULL; + sigdata->pattern = NULL; + sigdata->midi = NULL; + sigdata->checkpoint = NULL; - sigdata->mixing_volume = 48; - sigdata->pan_separation = 128; + sigdata->mixing_volume = 48; + sigdata->pan_separation = 128; - sigdata->n_instruments = 0; - sigdata->n_orders = 0; - sigdata->restart_position = 0; + sigdata->n_instruments = 0; + sigdata->n_orders = 0; + sigdata->restart_position = 0; - memset(sigdata->channel_volume, 64, DUMB_IT_N_CHANNELS); + memset(sigdata->channel_volume, 64, DUMB_IT_N_CHANNELS); - for (n = 0; n < DUMB_IT_N_CHANNELS; n += 4) { - int sep = 32 * dumb_it_default_panning_separation / 100; - sigdata->channel_pan[n ] = 32 - sep; - sigdata->channel_pan[n+1] = 32 + sep; - sigdata->channel_pan[n+2] = 32 + sep; - sigdata->channel_pan[n+3] = 32 - sep; - } + for (n = 0; n < DUMB_IT_N_CHANNELS; n += 4) { + int sep = 32 * dumb_it_default_panning_separation / 100; + sigdata->channel_pan[n] = 32 - sep; + sigdata->channel_pan[n + 1] = 32 + sep; + sigdata->channel_pan[n + 2] = 32 + sep; + sigdata->channel_pan[n + 3] = 32 - sep; + } - for ( n = 0; (unsigned)n < stream->chunk_count; ++n ) - { - struct riff_chunk * c = stream->chunks + n; - switch ( c->type ) - { - case DUMB_ID( 'S', 'O', 'N', 'G' ): - if ( dumbfile_seek( f, c->offset, DFS_SEEK_SET ) ) goto error_usd; - dumbfile_getnc( (char *) sigdata->name, 28, f ); - sigdata->name[ 28 ] = 0; - sigdata->flags = IT_STEREO | IT_OLD_EFFECTS | IT_COMPATIBLE_GXX; - dumbfile_skip( f, 36 - 28 ); - sigdata->n_orders = dumbfile_igetw( f ); - //sigdata->n_samples = ptr[ 38 ] | ( ptr[ 39 ] << 8 ); // whatever - //sigdata->n_patterns = ptr[ 40 ] | ( ptr[ 41 ] << 8 ); - dumbfile_skip( f, 42 - 38 ); - sigdata->n_pchannels = dumbfile_igetw( f ); - sigdata->global_volume = dumbfile_getc( f ); - sigdata->mixing_volume = dumbfile_getc( f ); - sigdata->speed = dumbfile_getc( f ); - sigdata->tempo = dumbfile_getc( f ); + for (n = 0; (unsigned)n < stream->chunk_count; ++n) { + struct riff_chunk *c = stream->chunks + n; + switch (c->type) { + case DUMB_ID('S', 'O', 'N', 'G'): + if (dumbfile_seek(f, c->offset, DFS_SEEK_SET)) + goto error_usd; + dumbfile_getnc((char *)sigdata->name, 28, f); + sigdata->name[28] = 0; + sigdata->flags = IT_STEREO | IT_OLD_EFFECTS | IT_COMPATIBLE_GXX; + dumbfile_skip(f, 36 - 28); + sigdata->n_orders = dumbfile_igetw(f); + // sigdata->n_samples = ptr[ 38 ] | ( ptr[ 39 ] << 8 ); // whatever + // sigdata->n_patterns = ptr[ 40 ] | ( ptr[ 41 ] << 8 ); + dumbfile_skip(f, 42 - 38); + sigdata->n_pchannels = dumbfile_igetw(f); + sigdata->global_volume = dumbfile_getc(f); + sigdata->mixing_volume = dumbfile_getc(f); + sigdata->speed = dumbfile_getc(f); + sigdata->tempo = dumbfile_getc(f); - for ( o = 0; o < 16; ++o ) - { - sigdata->channel_pan[ o ] = dumbfile_getc( f ) / 2; - } + for (o = 0; o < 16; ++o) { + sigdata->channel_pan[o] = dumbfile_getc(f) / 2; + } - sigdata->order = malloc( 128 ); - if ( ! sigdata->order ) goto error_usd; - dumbfile_getnc( (char *) sigdata->order, 128, f ); + sigdata->order = malloc(128); + if (!sigdata->order) + goto error_usd; + dumbfile_getnc((char *)sigdata->order, 128, f); - break; - } - } + break; + } + } - sigdata->pattern = malloc( sigdata->n_patterns * sizeof( *sigdata->pattern ) ); - if ( ! sigdata->pattern ) goto error_usd; - for ( n = 0; n < sigdata->n_patterns; ++n ) - sigdata->pattern[ n ].entry = NULL; + sigdata->pattern = malloc(sigdata->n_patterns * sizeof(*sigdata->pattern)); + if (!sigdata->pattern) + goto error_usd; + for (n = 0; n < sigdata->n_patterns; ++n) + sigdata->pattern[n].entry = NULL; - sigdata->sample = malloc( sigdata->n_samples * sizeof( *sigdata->sample ) ); - if ( ! sigdata->sample ) goto error_usd; - for ( n = 0; n < sigdata->n_samples; ++n ) - { - IT_SAMPLE * sample = sigdata->sample + n; - sample->data = NULL; - } + sigdata->sample = malloc(sigdata->n_samples * sizeof(*sigdata->sample)); + if (!sigdata->sample) + goto error_usd; + for (n = 0; n < sigdata->n_samples; ++n) { + IT_SAMPLE *sample = sigdata->sample + n; + sample->data = NULL; + } - sigdata->n_samples = 0; - sigdata->n_patterns = 0; + sigdata->n_samples = 0; + sigdata->n_patterns = 0; - for ( n = 0; (unsigned)n < stream->chunk_count; ++n ) - { - struct riff_chunk * c = stream->chunks + n; - switch ( c->type ) - { - case DUMB_ID( 'P', 'A', 'T', 'T' ): - if ( dumbfile_seek( f, c->offset, DFS_SEEK_SET ) ) goto error_usd; - if ( it_riff_dsmf_process_pattern( sigdata->pattern + sigdata->n_patterns, f, c->size ) ) goto error_usd; - ++ sigdata->n_patterns; - break; + for (n = 0; (unsigned)n < stream->chunk_count; ++n) { + struct riff_chunk *c = stream->chunks + n; + switch (c->type) { + case DUMB_ID('P', 'A', 'T', 'T'): + if (dumbfile_seek(f, c->offset, DFS_SEEK_SET)) + goto error_usd; + if (it_riff_dsmf_process_pattern( + sigdata->pattern + sigdata->n_patterns, f, c->size)) + goto error_usd; + ++sigdata->n_patterns; + break; - case DUMB_ID( 'I', 'N', 'S', 'T' ): - if ( dumbfile_seek( f, c->offset, DFS_SEEK_SET ) ) goto error_usd; - if ( it_riff_dsmf_process_sample( sigdata->sample + sigdata->n_samples, f, c->size ) ) goto error_usd; - ++ sigdata->n_samples; - break; - } - } + case DUMB_ID('I', 'N', 'S', 'T'): + if (dumbfile_seek(f, c->offset, DFS_SEEK_SET)) + goto error_usd; + if (it_riff_dsmf_process_sample( + sigdata->sample + sigdata->n_samples, f, c->size)) + goto error_usd; + ++sigdata->n_samples; + break; + } + } - _dumb_it_fix_invalid_orders( sigdata ); + _dumb_it_fix_invalid_orders(sigdata); - return sigdata; + return sigdata; error_usd: - _dumb_it_unload_sigdata( sigdata ); - goto error; + _dumb_it_unload_sigdata(sigdata); + goto error; error_sd: - free( sigdata ); + free(sigdata); error: - return NULL; + return NULL; } -DUH *dumb_read_riff_dsmf( DUMBFILE * f, struct riff * stream ) -{ - sigdata_t *sigdata; +DUH *dumb_read_riff_dsmf(DUMBFILE *f, struct riff *stream) { + sigdata_t *sigdata; - DUH_SIGTYPE_DESC *descptr = &_dumb_sigtype_it; + DUH_SIGTYPE_DESC *descptr = &_dumb_sigtype_it; - sigdata = it_riff_dsmf_load_sigdata( f, stream ); + sigdata = it_riff_dsmf_load_sigdata(f, stream); - if (!sigdata) - return NULL; + if (!sigdata) + return NULL; - { - const char *tag[2][2]; - tag[0][0] = "TITLE"; + { + const char *tag[2][2]; + tag[0][0] = "TITLE"; tag[0][1] = (const char *)(((DUMB_IT_SIGDATA *)sigdata)->name); - tag[1][0] = "FORMAT"; - tag[1][1] = "RIFF DSMF"; - return make_duh( -1, 2, ( const char * const (*) [ 2 ] ) tag, 1, & descptr, & sigdata ); - } + tag[1][0] = "FORMAT"; + tag[1][1] = "RIFF DSMF"; + return make_duh(-1, 2, (const char *const(*)[2])tag, 1, &descptr, + &sigdata); + } } diff --git a/Frameworks/Dumb/dumb/src/it/readmod.c b/Frameworks/Dumb/dumb/src/it/readmod.c index a4dad5c14..6c130e56d 100644 --- a/Frameworks/Dumb/dumb/src/it/readmod.c +++ b/Frameworks/Dumb/dumb/src/it/readmod.c @@ -25,456 +25,454 @@ #include "internal/dumb.h" #include "internal/it.h" +static int it_mod_read_pattern(IT_PATTERN *pattern, DUMBFILE *f, int n_channels, + unsigned char *buffer) { + int pos; + int channel; + int row; + IT_ENTRY *entry; + pattern->n_rows = 64; -static int it_mod_read_pattern(IT_PATTERN *pattern, DUMBFILE *f, int n_channels, unsigned char *buffer) -{ - int pos; - int channel; - int row; - IT_ENTRY *entry; + if (n_channels == 0) { + /* Read the first four channels, leaving gaps for the rest. */ + for (pos = 0; pos < 64 * 8 * 4; pos += 8 * 4) + dumbfile_getnc((char *)buffer + pos, 4 * 4, f); + /* Read the other channels into the gaps we left. */ + for (pos = 4 * 4; pos < 64 * 8 * 4; pos += 8 * 4) + dumbfile_getnc((char *)buffer + pos, 4 * 4, f); - pattern->n_rows = 64; - - if (n_channels == 0) { - /* Read the first four channels, leaving gaps for the rest. */ - for (pos = 0; pos < 64*8*4; pos += 8*4) - dumbfile_getnc((char *)buffer + pos, 4*4, f); - /* Read the other channels into the gaps we left. */ - for (pos = 4*4; pos < 64*8*4; pos += 8*4) - dumbfile_getnc((char *)buffer + pos, 4*4, f); - - n_channels = 8; - } else + n_channels = 8; + } else dumbfile_getnc((char *)buffer, 64 * n_channels * 4, f); - if (dumbfile_error(f)) - return -1; + if (dumbfile_error(f)) + return -1; - /* compute number of entries */ - pattern->n_entries = 64; /* Account for the row end markers */ - pos = 0; - for (row = 0; row < 64; row++) { - for (channel = 0; channel < n_channels; channel++) { - if (buffer[pos+0] | buffer[pos+1] | buffer[pos+2] | buffer[pos+3]) - pattern->n_entries++; - pos += 4; - } - } + /* compute number of entries */ + pattern->n_entries = 64; /* Account for the row end markers */ + pos = 0; + for (row = 0; row < 64; row++) { + for (channel = 0; channel < n_channels; channel++) { + if (buffer[pos + 0] | buffer[pos + 1] | buffer[pos + 2] | + buffer[pos + 3]) + pattern->n_entries++; + pos += 4; + } + } - pattern->entry = malloc(pattern->n_entries * sizeof(*pattern->entry)); - if (!pattern->entry) - return -1; + pattern->entry = malloc(pattern->n_entries * sizeof(*pattern->entry)); + if (!pattern->entry) + return -1; - entry = pattern->entry; - pos = 0; - for (row = 0; row < 64; row++) { - for (channel = 0; channel < n_channels; channel++) { - if (buffer[pos+0] | buffer[pos+1] | buffer[pos+2] | buffer[pos+3]) { - unsigned char sample = (buffer[pos+0] & 0xF0) | (buffer[pos+2] >> 4); - int period = ((int)(buffer[pos+0] & 0x0F) << 8) | buffer[pos+1]; + entry = pattern->entry; + pos = 0; + for (row = 0; row < 64; row++) { + for (channel = 0; channel < n_channels; channel++) { + if (buffer[pos + 0] | buffer[pos + 1] | buffer[pos + 2] | + buffer[pos + 3]) { + unsigned char sample = + (buffer[pos + 0] & 0xF0) | (buffer[pos + 2] >> 4); + int period = + ((int)(buffer[pos + 0] & 0x0F) << 8) | buffer[pos + 1]; - entry->channel = channel; - entry->mask = 0; + entry->channel = channel; + entry->mask = 0; - if (period) { - int note; - entry->mask |= IT_ENTRY_NOTE; + if (period) { + int note; + entry->mask |= IT_ENTRY_NOTE; - /* frequency = (AMIGA_DIVISOR / 8) / (period * 2) - * C-1: period = 214 -> frequency = 16726 - * so, set C5_speed to 16726 - * and period = 214 should translate to C5 aka 60 - * halve the period, go up an octive - * - * period = 214 / pow(DUMB_SEMITONE_BASE, note - 60) - * pow(DUMB_SEMITONE_BASE, note - 60) = 214 / period - * note - 60 = log(214/period) / log(DUMB_SEMITONE_BASE) - */ - note = (int)floor(log(214.0/period) / log(DUMB_SEMITONE_BASE) + 60.5); - entry->note = MID(0, note, 119); - // or should we preserve the period? - //entry->note = buffer[pos+0] & 0x0F; /* High nibble */ - //entry->volpan = buffer[pos+1]; /* Low byte */ - // and what about finetune? - } + /* frequency = (AMIGA_DIVISOR / 8) / (period * 2) + * C-1: period = 214 -> frequency = 16726 + * so, set C5_speed to 16726 + * and period = 214 should translate to C5 aka 60 + * halve the period, go up an octive + * + * period = 214 / pow(DUMB_SEMITONE_BASE, note - 60) + * pow(DUMB_SEMITONE_BASE, note - 60) = 214 / period + * note - 60 = log(214/period) / log(DUMB_SEMITONE_BASE) + */ + note = (int)floor( + log(214.0 / period) / log(DUMB_SEMITONE_BASE) + 60.5); + entry->note = MID(0, note, 119); + // or should we preserve the period? + // entry->note = buffer[pos+0] & 0x0F; /* High nibble */ + // entry->volpan = buffer[pos+1]; /* Low byte */ + // and what about finetune? + } - if (sample) { - entry->mask |= IT_ENTRY_INSTRUMENT; - entry->instrument = sample; - } + if (sample) { + entry->mask |= IT_ENTRY_INSTRUMENT; + entry->instrument = sample; + } - _dumb_it_xm_convert_effect(buffer[pos+2] & 0x0F, buffer[pos+3], entry, 1); + _dumb_it_xm_convert_effect(buffer[pos + 2] & 0x0F, + buffer[pos + 3], entry, 1); - entry++; - } - pos += 4; - } - IT_SET_END_ROW(entry); - entry++; - } + entry++; + } + pos += 4; + } + IT_SET_END_ROW(entry); + entry++; + } - return 0; + return 0; } +static int it_mod_read_sample_header(IT_SAMPLE *sample, DUMBFILE *f, + unsigned long fft, int stk) { + int finetune, loop_start, loop_length; + /** + 21 22 Chars Sample 1 name. If the name is not a full + 22 chars in length, it will be null + terminated. -static int it_mod_read_sample_header(IT_SAMPLE *sample, DUMBFILE *f, unsigned long fft, int stk) -{ - int finetune, loop_start, loop_length; - -/** - 21 22 Chars Sample 1 name. If the name is not a full - 22 chars in length, it will be null - terminated. - -If -the sample name begins with a '#' character (ASCII $23 (35)) then this is -assumed not to be an instrument name, and is probably a message. -*/ + If + the sample name begins with a '#' character (ASCII $23 (35)) then this is + assumed not to be an instrument name, and is probably a message. + */ dumbfile_getnc((char *)sample->name, 22, f); - sample->name[22] = 0; + sample->name[22] = 0; - sample->filename[0] = 0; + sample->filename[0] = 0; - sample->length = dumbfile_mgetw(f) << 1; - if (fft == DUMB_ID('F','E','S','T')) - finetune = (signed char)((-dumbfile_getc(f) & 0x1F) << 3) >> 3; - else - finetune = (signed char)(dumbfile_getc(f) << 4) >> 4; /* signed nibble */ -/** Each finetune step changes the note 1/8th of a semitone. */ - sample->global_volume = 64; - sample->default_volume = dumbfile_getc(f); // Should we be setting global_volume to this instead? - loop_start = dumbfile_mgetw(f); - if ( !stk ) loop_start <<= 1; - loop_length = dumbfile_mgetw(f) << 1; - if ( loop_length > 2 && loop_start + loop_length > sample->length && loop_start / 2 + loop_length <= sample->length ) - loop_start /= 2; - sample->loop_start = loop_start; - sample->loop_end = loop_start + loop_length; -/** -Once this sample has been played completely from beginning -to end, if the repeat length (next field) is greater than two bytes it -will loop back to this position in the sample and continue playing. Once -it has played for the repeat length, it continues to loop back to the -repeat start offset. This means the sample continues playing until it is -told to stop. -*/ + sample->length = dumbfile_mgetw(f) << 1; + if (fft == DUMB_ID('F', 'E', 'S', 'T')) + finetune = (signed char)((-dumbfile_getc(f) & 0x1F) << 3) >> 3; + else + finetune = + (signed char)(dumbfile_getc(f) << 4) >> 4; /* signed nibble */ + /** Each finetune step changes the note 1/8th of a semitone. */ + sample->global_volume = 64; + sample->default_volume = + dumbfile_getc(f); // Should we be setting global_volume to this instead? + loop_start = dumbfile_mgetw(f); + if (!stk) + loop_start <<= 1; + loop_length = dumbfile_mgetw(f) << 1; + if (loop_length > 2 && loop_start + loop_length > sample->length && + loop_start / 2 + loop_length <= sample->length) + loop_start /= 2; + sample->loop_start = loop_start; + sample->loop_end = loop_start + loop_length; + /** + Once this sample has been played completely from beginning + to end, if the repeat length (next field) is greater than two bytes it + will loop back to this position in the sample and continue playing. Once + it has played for the repeat length, it continues to loop back to the + repeat start offset. This means the sample continues playing until it is + told to stop. + */ - if (sample->length <= 0) { - sample->flags = 0; - return 0; - } + if (sample->length <= 0) { + sample->flags = 0; + return 0; + } - sample->flags = IT_SAMPLE_EXISTS; + sample->flags = IT_SAMPLE_EXISTS; - sample->default_pan = 0; - sample->C5_speed = (int)( AMIGA_CLOCK / 214.0 ); //(long)(16726.0*pow(DUMB_PITCH_BASE, finetune*32)); - sample->finetune = finetune * ((fft == DUMB_ID('F','E','S','T')) ? 16 : 32); - // the above line might be wrong + sample->default_pan = 0; + sample->C5_speed = + (int)(AMIGA_CLOCK / + 214.0); //(long)(16726.0*pow(DUMB_PITCH_BASE, finetune*32)); + sample->finetune = + finetune * ((fft == DUMB_ID('F', 'E', 'S', 'T')) ? 16 : 32); + // the above line might be wrong - if (sample->loop_end > sample->length) - sample->loop_end = sample->length; + if (sample->loop_end > sample->length) + sample->loop_end = sample->length; - if (sample->loop_end - sample->loop_start > 2) - sample->flags |= IT_SAMPLE_LOOP; + if (sample->loop_end - sample->loop_start > 2) + sample->flags |= IT_SAMPLE_LOOP; - sample->vibrato_speed = 0; - sample->vibrato_depth = 0; - sample->vibrato_rate = 0; - sample->vibrato_waveform = 0; // do we have to set _all_ these? - sample->max_resampling_quality = -1; + sample->vibrato_speed = 0; + sample->vibrato_depth = 0; + sample->vibrato_rate = 0; + sample->vibrato_waveform = 0; // do we have to set _all_ these? + sample->max_resampling_quality = -1; - return dumbfile_error(f); + return dumbfile_error(f); } +static int it_mod_read_sample_data(IT_SAMPLE *sample, DUMBFILE *f, + unsigned long fft) { + long i; + long truncated_size; + /* let's get rid of the sample data coming after the end of the loop */ + if ((sample->flags & IT_SAMPLE_LOOP) && sample->loop_end < sample->length) { + truncated_size = sample->length - sample->loop_end; + sample->length = sample->loop_end; + } else { + truncated_size = 0; + } -static int it_mod_read_sample_data(IT_SAMPLE *sample, DUMBFILE *f, unsigned long fft) -{ - long i; - long truncated_size; + if (sample->length) { + sample->data = malloc(sample->length); - /* let's get rid of the sample data coming after the end of the loop */ - if ((sample->flags & IT_SAMPLE_LOOP) && sample->loop_end < sample->length) { - truncated_size = sample->length - sample->loop_end; - sample->length = sample->loop_end; - } else { - truncated_size = 0; - } + if (!sample->data) + return -1; - if (sample->length) { - sample->data = malloc(sample->length); + /* Sample data are stored in "8-bit two's compliment format" (sic). */ + /* + for (i = 0; i < sample->length; i++) + ((signed char *)sample->left)[i] = dumbfile_getc(f); + */ + /* F U Olivier Lapicque */ + if (sample->length >= 5) { + i = dumbfile_getnc(sample->data, 5, f); + if (i == 5) { + if (!memcmp(sample->data, "ADPCM", 5)) { + if (_dumb_it_read_sample_data_adpcm4(sample, f) < 0) + return -1; - if (!sample->data) - return -1; + return 0; + } else { + i += dumbfile_getnc(((char *)sample->data) + 5, + sample->length - 5, f); + } + } + } else { + i = dumbfile_getnc(sample->data, sample->length, f); + } + if (i < sample->length) { + if (i <= 0) { + sample->flags = 0; + return 0; + } + sample->length = i; + if (sample->loop_end > i) + sample->loop_end = i; + // holy crap! + if (sample->loop_start > i) + sample->flags &= ~IT_SAMPLE_LOOP; + } else { + /* skip truncated data */ + int feh = dumbfile_error(f); - /* Sample data are stored in "8-bit two's compliment format" (sic). */ - /* - for (i = 0; i < sample->length; i++) - ((signed char *)sample->left)[i] = dumbfile_getc(f); - */ - /* F U Olivier Lapicque */ - if (sample->length >= 5) - { - i = dumbfile_getnc(sample->data, 5, f); - if (i == 5) - { - if (!memcmp(sample->data, "ADPCM", 5)) - { - if (_dumb_it_read_sample_data_adpcm4(sample, f) < 0) - return -1; + if (truncated_size) + dumbfile_skip(f, truncated_size); + // Should we be truncating it? - return 0; - } - else - { - i += dumbfile_getnc(((char *)sample->data) + 5, sample->length - 5, f); - } - } - } - else - { - i = dumbfile_getnc(sample->data, sample->length, f); - } - if (i < sample->length) - { - if (i <= 0) - { - sample->flags = 0; - return 0; - } - sample->length = i; - if (sample->loop_end > i) sample->loop_end = i; - // holy crap! - if (sample->loop_start > i) sample->flags &= ~IT_SAMPLE_LOOP; - } - else - { - /* skip truncated data */ - int feh = dumbfile_error(f); + if (feh) + return -1; + } - if (truncated_size) dumbfile_skip(f, truncated_size); - // Should we be truncating it? + if (fft == DUMB_ID('M', 0, 0, 0) || fft == DUMB_ID('8', 0, 0, 0)) { + int delta = 0; + for (i = 0; i < sample->length; i++) { + delta += ((signed char *)sample->data)[i]; + ((signed char *)sample->data)[i] = delta; + } + } + } - if (feh) - return -1; - } - - if (fft == DUMB_ID('M',0,0,0) || fft == DUMB_ID('8',0,0,0)) { - int delta = 0; - for (i = 0; i < sample->length; i++) { - delta += ((signed char *)sample->data)[i]; - ((signed char *)sample->data)[i] = delta; - } - } - } - - return 0; + return 0; } +#define MOD_FFT_OFFSET (20 + 31 * (22 + 2 + 1 + 1 + 2 + 2) + 1 + 1 + 128) +static DUMB_IT_SIGDATA *it_mod_load_sigdata(DUMBFILE *f, int restrict_) { + DUMB_IT_SIGDATA *sigdata; + int n_channels; + int i; + unsigned long fft; -#define MOD_FFT_OFFSET (20 + 31*(22+2+1+1+2+2) + 1 + 1 + 128) + if (dumbfile_seek(f, MOD_FFT_OFFSET, DFS_SEEK_SET)) + return NULL; -static DUMB_IT_SIGDATA *it_mod_load_sigdata(DUMBFILE *f, int restrict_) -{ - DUMB_IT_SIGDATA *sigdata; - int n_channels; - int i; - unsigned long fft; + fft = dumbfile_mgetl(f); + if (dumbfile_error(f)) + return NULL; - if ( dumbfile_seek(f, MOD_FFT_OFFSET, DFS_SEEK_SET) ) - return NULL; + if (dumbfile_seek(f, 0, DFS_SEEK_SET)) + return NULL; - fft = dumbfile_mgetl(f); - if (dumbfile_error(f)) - return NULL; + sigdata = malloc(sizeof(*sigdata)); + if (!sigdata) { + return NULL; + } - if ( dumbfile_seek(f, 0, DFS_SEEK_SET) ) - return NULL; - - sigdata = malloc(sizeof(*sigdata)); - if (!sigdata) { - return NULL; - } - - /** - 1 20 Chars Title of the song. If the title is not a - full 20 chars in length, it will be null- - terminated. - */ + /** + 1 20 Chars Title of the song. If the title is not a + full 20 chars in length, it will be null- + terminated. + */ if (dumbfile_getnc((char *)sigdata->name, 20, f) < 20) { - free(sigdata); + free(sigdata); return NULL; - } - sigdata->name[20] = 0; + } + sigdata->name[20] = 0; - sigdata->n_samples = 31; + sigdata->n_samples = 31; - switch (fft) { - case DUMB_ID('M','.','K','.'): - case DUMB_ID('M','!','K','!'): - case DUMB_ID('M','&','K','!'): - case DUMB_ID('N','.','T','.'): - case DUMB_ID('N','S','M','S'): - case DUMB_ID('F','L','T','4'): - case DUMB_ID('M',0,0,0): - case DUMB_ID('8',0,0,0): - case DUMB_ID('F','E','S','T'): - n_channels = 4; - break; - case DUMB_ID('F','L','T','8'): - n_channels = 0; - /* 0 indicates a special case; two four-channel patterns must be - * combined into one eight-channel pattern. Pattern indexes must - * be halved. Why oh why do they obfuscate so? - */ - /*for (i = 0; i < 128; i++) - sigdata->order[i] >>= 1;*/ - break; - case DUMB_ID('C','D','8','1'): - case DUMB_ID('O','C','T','A'): - case DUMB_ID('O','K','T','A'): - n_channels = 8; - break; - case DUMB_ID('1','6','C','N'): - n_channels = 16; - break; - case DUMB_ID('3','2','C','N'): - n_channels = 32; - break; - default: - /* If we get an illegal tag, assume 4 channels 15 samples. */ - if ((fft & 0x0000FFFFL) == DUMB_ID(0,0,'C','H')) { - if (fft >= '1' << 24 && fft < '4' << 24) { - n_channels = ((fft & 0x00FF0000L) >> 16) - '0'; - if ((unsigned int)n_channels >= 10) { - /* Rightmost character wasn't a digit. */ - n_channels = 4; - sigdata->n_samples = 15; - } else { - n_channels += (((fft & 0xFF000000L) >> 24) - '0') * 10; - /* MODs should really only go up to 32 channels, but we're lenient. */ - if ((unsigned int)(n_channels - 1) >= DUMB_IT_N_CHANNELS - 1) { - /* No channels or too many? Can't be right... */ - n_channels = 4; - sigdata->n_samples = 15; - } - } - } else { - n_channels = 4; - sigdata->n_samples = 15; - } - } else if ((fft & 0x00FFFFFFL) == DUMB_ID(0,'C','H','N')) { - n_channels = (fft >> 24) - '0'; - if ((unsigned int)(n_channels - 1) >= 9) { - /* Character was '0' or it wasn't a digit */ - n_channels = 4; - sigdata->n_samples = 15; - } - } else if ((fft & 0xFFFFFF00L) == DUMB_ID('T','D','Z',0)) { - n_channels = (fft & 0x000000FFL) - '0'; - if ((unsigned int)(n_channels - 1) >= 9) { - /* We've been very lenient, given that it should have - * been 1, 2 or 3, but this MOD has been very naughty and - * must be punished. - */ - n_channels = 4; - sigdata->n_samples = 15; - } - } else { - n_channels = 4; - sigdata->n_samples = 15; - fft = 0; - } - } + switch (fft) { + case DUMB_ID('M', '.', 'K', '.'): + case DUMB_ID('M', '!', 'K', '!'): + case DUMB_ID('M', '&', 'K', '!'): + case DUMB_ID('N', '.', 'T', '.'): + case DUMB_ID('N', 'S', 'M', 'S'): + case DUMB_ID('F', 'L', 'T', '4'): + case DUMB_ID('M', 0, 0, 0): + case DUMB_ID('8', 0, 0, 0): + case DUMB_ID('F', 'E', 'S', 'T'): + n_channels = 4; + break; + case DUMB_ID('F', 'L', 'T', '8'): + n_channels = 0; + /* 0 indicates a special case; two four-channel patterns must be + * combined into one eight-channel pattern. Pattern indexes must + * be halved. Why oh why do they obfuscate so? + */ + /*for (i = 0; i < 128; i++) + sigdata->order[i] >>= 1;*/ + break; + case DUMB_ID('C', 'D', '8', '1'): + case DUMB_ID('O', 'C', 'T', 'A'): + case DUMB_ID('O', 'K', 'T', 'A'): + n_channels = 8; + break; + case DUMB_ID('1', '6', 'C', 'N'): + n_channels = 16; + break; + case DUMB_ID('3', '2', 'C', 'N'): + n_channels = 32; + break; + default: + /* If we get an illegal tag, assume 4 channels 15 samples. */ + if ((fft & 0x0000FFFFL) == DUMB_ID(0, 0, 'C', 'H')) { + if (fft >= '1' << 24 && fft < '4' << 24) { + n_channels = ((fft & 0x00FF0000L) >> 16) - '0'; + if ((unsigned int)n_channels >= 10) { + /* Rightmost character wasn't a digit. */ + n_channels = 4; + sigdata->n_samples = 15; + } else { + n_channels += (((fft & 0xFF000000L) >> 24) - '0') * 10; + /* MODs should really only go up to 32 channels, but we're + * lenient. */ + if ((unsigned int)(n_channels - 1) >= + DUMB_IT_N_CHANNELS - 1) { + /* No channels or too many? Can't be right... */ + n_channels = 4; + sigdata->n_samples = 15; + } + } + } else { + n_channels = 4; + sigdata->n_samples = 15; + } + } else if ((fft & 0x00FFFFFFL) == DUMB_ID(0, 'C', 'H', 'N')) { + n_channels = (int)((fft >> 24) - '0'); + if ((unsigned int)(n_channels - 1) >= 9) { + /* Character was '0' or it wasn't a digit */ + n_channels = 4; + sigdata->n_samples = 15; + } + } else if ((fft & 0xFFFFFF00L) == DUMB_ID('T', 'D', 'Z', 0)) { + n_channels = (fft & 0x000000FFL) - '0'; + if ((unsigned int)(n_channels - 1) >= 9) { + /* We've been very lenient, given that it should have + * been 1, 2 or 3, but this MOD has been very naughty and + * must be punished. + */ + n_channels = 4; + sigdata->n_samples = 15; + } + } else { + n_channels = 4; + sigdata->n_samples = 15; + fft = 0; + } + } - // moo - if ( ( restrict_ & 1 ) && sigdata->n_samples == 15 ) - { - free(sigdata); + // moo + if ((restrict_ & 1) && sigdata->n_samples == 15) { + free(sigdata); return NULL; - } + } - sigdata->n_pchannels = n_channels ? n_channels : 8; /* special case for 0, see above */ + sigdata->n_pchannels = + n_channels ? n_channels : 8; /* special case for 0, see above */ - sigdata->sample = malloc(sigdata->n_samples * sizeof(*sigdata->sample)); - if (!sigdata->sample) { - free(sigdata); + sigdata->sample = malloc(sigdata->n_samples * sizeof(*sigdata->sample)); + if (!sigdata->sample) { + free(sigdata); return NULL; - } + } - sigdata->song_message = NULL; - sigdata->order = NULL; - sigdata->instrument = NULL; - sigdata->pattern = NULL; - sigdata->midi = NULL; - sigdata->checkpoint = NULL; + sigdata->song_message = NULL; + sigdata->order = NULL; + sigdata->instrument = NULL; + sigdata->pattern = NULL; + sigdata->midi = NULL; + sigdata->checkpoint = NULL; - sigdata->n_instruments = 0; + sigdata->n_instruments = 0; - for (i = 0; i < sigdata->n_samples; i++) - sigdata->sample[i].data = NULL; + for (i = 0; i < sigdata->n_samples; i++) + sigdata->sample[i].data = NULL; - for (i = 0; i < sigdata->n_samples; i++) { - if (it_mod_read_sample_header(&sigdata->sample[i], f, fft, sigdata->n_samples == 15)) { - _dumb_it_unload_sigdata(sigdata); + for (i = 0; i < sigdata->n_samples; i++) { + if (it_mod_read_sample_header(&sigdata->sample[i], f, fft, + sigdata->n_samples == 15)) { + _dumb_it_unload_sigdata(sigdata); return NULL; - } - } + } + } - sigdata->n_orders = dumbfile_getc(f); - sigdata->restart_position = dumbfile_getc(f); - // what if this is >= 127? what about with Fast Tracker II? + sigdata->n_orders = dumbfile_getc(f); + sigdata->restart_position = dumbfile_getc(f); + // what if this is >= 127? what about with Fast Tracker II? -/* if (sigdata->n_orders <= 0 || sigdata->n_orders > 128) { // is this right? - _dumb_it_unload_sigdata(sigdata); + /* if (sigdata->n_orders <= 0 || sigdata->n_orders > 128) { // is this + right? _dumb_it_unload_sigdata(sigdata); return NULL; + }*/ + + // if (sigdata->restart_position >= sigdata->n_orders) + // sigdata->restart_position = 0; + + sigdata->order = malloc(128); /* We may need to scan the extra ones! */ + if (!sigdata->order) { + _dumb_it_unload_sigdata(sigdata); return NULL; - }*/ - - //if (sigdata->restart_position >= sigdata->n_orders) - //sigdata->restart_position = 0; - - sigdata->order = malloc(128); /* We may need to scan the extra ones! */ - if (!sigdata->order) { - _dumb_it_unload_sigdata(sigdata); - return NULL; - } + } if (dumbfile_getnc((char *)sigdata->order, 128, f) < 128) { - _dumb_it_unload_sigdata(sigdata); + _dumb_it_unload_sigdata(sigdata); return NULL; - } + } - if (sigdata->n_orders <= 0 || sigdata->n_orders > 128) { // is this right? - sigdata->n_orders = 128; - //while (sigdata->n_orders > 1 && !sigdata->order[sigdata->n_orders - 1]) sigdata->n_orders--; - } + if (sigdata->n_orders <= 0 || sigdata->n_orders > 128) { // is this right? + sigdata->n_orders = 128; + // while (sigdata->n_orders > 1 && !sigdata->order[sigdata->n_orders - + // 1]) sigdata->n_orders--; + } - if ( ! n_channels ) - for (i = 0; i < 128; i++) - sigdata->order[i] >>= 1; + if (!n_channels) + for (i = 0; i < 128; i++) + sigdata->order[i] >>= 1; - /* "The old NST format contains only 15 samples (instead of 31). Further - * it doesn't contain a file format tag (id). So Pattern data offset is - * at 20+15*30+1+1+128." - * - Then I shall assume the File Format Tag never exists if there are - * only 15 samples. I hope this isn't a faulty assumption... - */ - if (sigdata->n_samples == 31) - dumbfile_skip(f, 4); + /* "The old NST format contains only 15 samples (instead of 31). Further + * it doesn't contain a file format tag (id). So Pattern data offset is + * at 20+15*30+1+1+128." + * - Then I shall assume the File Format Tag never exists if there are + * only 15 samples. I hope this isn't a faulty assumption... + */ + if (sigdata->n_samples == 31) + dumbfile_skip(f, 4); - sigdata->n_patterns = -1; + sigdata->n_patterns = -1; - if ( ( restrict_ & 2 ) ) - { + if ((restrict_ & 2)) { unsigned char buffer[5]; long sample_number; long total_sample_size; long offset = dumbfile_pos(f); long remain = dumbfile_get_size(f) - offset; - if ( dumbfile_error( f ) || - dumbfile_seek( f, 0, SEEK_END ) ) { + if (dumbfile_error(f) || dumbfile_seek(f, 0, SEEK_END)) { _dumb_it_unload_sigdata(sigdata); return NULL; } @@ -482,20 +480,32 @@ static DUMB_IT_SIGDATA *it_mod_load_sigdata(DUMBFILE *f, int restrict_) total_sample_size = 0; while (dumbfile_pos(f) > offset && sample_number >= 0) { if (sigdata->sample[sample_number].flags & IT_SAMPLE_EXISTS) { - if ( dumbfile_seek(f, -((sigdata->sample[sample_number].length + 1) / 2 + 5 + 16), DFS_SEEK_CUR) || - dumbfile_getnc((char *)buffer, 5, f) < 5 ) { + if (dumbfile_seek( + f, + -((sigdata->sample[sample_number].length + 1) / 2 + 5 + + 16), + DFS_SEEK_CUR) || + dumbfile_getnc((char *)buffer, 5, f) < 5) { _dumb_it_unload_sigdata(sigdata); return NULL; } - if ( !memcmp( buffer, "ADPCM", 5 ) ) { /* BAH */ - total_sample_size += (sigdata->sample[sample_number].length + 1) / 2 + 5 + 16; - if ( dumbfile_seek(f, -5, DFS_SEEK_CUR) ) { + if (!memcmp(buffer, "ADPCM", 5)) { /* BAH */ + total_sample_size += + (sigdata->sample[sample_number].length + 1) / 2 + 5 + + 16; + if (dumbfile_seek(f, -5, DFS_SEEK_CUR)) { _dumb_it_unload_sigdata(sigdata); return NULL; } } else { total_sample_size += sigdata->sample[sample_number].length; - if ( dumbfile_seek(f, -(sigdata->sample[sample_number].length - ((sigdata->sample[sample_number].length + 1) / 2 + 5 + 16) + 5), DFS_SEEK_CUR) ) { + if (dumbfile_seek( + f, + -(sigdata->sample[sample_number].length - + ((sigdata->sample[sample_number].length + 1) / 2 + + 5 + 16) + + 5), + DFS_SEEK_CUR)) { _dumb_it_unload_sigdata(sigdata); return NULL; } @@ -504,135 +514,135 @@ static DUMB_IT_SIGDATA *it_mod_load_sigdata(DUMBFILE *f, int restrict_) --sample_number; } - if (remain > total_sample_size) { - sigdata->n_patterns = ( remain - total_sample_size + 4 ) / ( 256 * sigdata->n_pchannels ); - if (fft == DUMB_ID('M',0,0,0) || fft == DUMB_ID('8',0,0,0)) { - remain -= sigdata->n_patterns * 256 * sigdata->n_pchannels; - if (dumbfile_skip(f, remain - total_sample_size)) { - _dumb_it_unload_sigdata(sigdata); - return NULL; - } - } - } - } - else - { - for (i = 0; i < 128; i++) - { + if (remain > total_sample_size) { + sigdata->n_patterns = (int)((remain - total_sample_size + 4) / + (256 * sigdata->n_pchannels)); + if (fft == DUMB_ID('M', 0, 0, 0) || fft == DUMB_ID('8', 0, 0, 0)) { + remain -= sigdata->n_patterns * 256 * sigdata->n_pchannels; + if (dumbfile_skip(f, remain - total_sample_size)) { + _dumb_it_unload_sigdata(sigdata); + return NULL; + } + } + } + } else { + for (i = 0; i < 128; i++) { if (sigdata->order[i] > sigdata->n_patterns) sigdata->n_patterns = sigdata->order[i]; } - sigdata->n_patterns++; - } + sigdata->n_patterns++; + } - if ( sigdata->n_patterns <= 0 ) { - _dumb_it_unload_sigdata(sigdata); - return NULL; - } + if (sigdata->n_patterns <= 0) { + _dumb_it_unload_sigdata(sigdata); + return NULL; + } - /* May as well try to save a tiny bit of memory. */ - if (sigdata->n_orders < 128) { - unsigned char *order = realloc(sigdata->order, sigdata->n_orders); - if (order) sigdata->order = order; - } + /* May as well try to save a tiny bit of memory. */ + if (sigdata->n_orders < 128) { + unsigned char *order = realloc(sigdata->order, sigdata->n_orders); + if (order) + sigdata->order = order; + } - sigdata->pattern = malloc(sigdata->n_patterns * sizeof(*sigdata->pattern)); - if (!sigdata->pattern) { - _dumb_it_unload_sigdata(sigdata); - return NULL; - } - for (i = 0; i < sigdata->n_patterns; i++) - sigdata->pattern[i].entry = NULL; + sigdata->pattern = malloc(sigdata->n_patterns * sizeof(*sigdata->pattern)); + if (!sigdata->pattern) { + _dumb_it_unload_sigdata(sigdata); + return NULL; + } + for (i = 0; i < sigdata->n_patterns; i++) + sigdata->pattern[i].entry = NULL; - /* Read in the patterns */ - { - unsigned char *buffer = malloc(256 * sigdata->n_pchannels); /* 64 rows * 4 bytes */ - if (!buffer) { - _dumb_it_unload_sigdata(sigdata); - return NULL; - } - for (i = 0; i < sigdata->n_patterns; i++) { - if (it_mod_read_pattern(&sigdata->pattern[i], f, n_channels, buffer) != 0) { - free(buffer); - _dumb_it_unload_sigdata(sigdata); - return NULL; - } - } - free(buffer); - } + /* Read in the patterns */ + { + unsigned char *buffer = + malloc(256 * sigdata->n_pchannels); /* 64 rows * 4 bytes */ + if (!buffer) { + _dumb_it_unload_sigdata(sigdata); + return NULL; + } + for (i = 0; i < sigdata->n_patterns; i++) { + if (it_mod_read_pattern(&sigdata->pattern[i], f, n_channels, + buffer) != 0) { + free(buffer); + _dumb_it_unload_sigdata(sigdata); + return NULL; + } + } + free(buffer); + } - /* And finally, the sample data */ - for (i = 0; i < sigdata->n_samples; i++) { - if (it_mod_read_sample_data(&sigdata->sample[i], f, fft)) { - _dumb_it_unload_sigdata(sigdata); - return NULL; - } - } + /* And finally, the sample data */ + for (i = 0; i < sigdata->n_samples; i++) { + if (it_mod_read_sample_data(&sigdata->sample[i], f, fft)) { + _dumb_it_unload_sigdata(sigdata); + return NULL; + } + } - /* w00t! */ - /*if ( n_channels == 4 && - ( sigdata->n_samples == 15 || - ( ( fft & 240 ) != DUMB_ID( 0, 0, 'C', 0 ) && - ( fft & 240 ) != DUMB_ID( 0, 0, 'H', 0 ) && - ( fft & 240 ) != 0 ) ) ) { - for ( i = 0; i < sigdata->n_samples; ++i ) { - IT_SAMPLE * sample = &sigdata->sample [i]; - if ( sample && ( sample->flags & IT_SAMPLE_EXISTS ) ) { - int n, o; - o = sample->length; - if ( o > 4 ) o = 4; - for ( n = 0; n < o; ++n ) - ( ( char * ) sample->data ) [n] = 0; - } - } - }*/ + /* w00t! */ + /*if ( n_channels == 4 && + ( sigdata->n_samples == 15 || + ( ( fft & 240 ) != DUMB_ID( 0, 0, 'C', 0 ) && + ( fft & 240 ) != DUMB_ID( 0, 0, 'H', 0 ) && + ( fft & 240 ) != 0 ) ) ) { + for ( i = 0; i < sigdata->n_samples; ++i ) { + IT_SAMPLE * sample = &sigdata->sample [i]; + if ( sample && ( sample->flags & IT_SAMPLE_EXISTS ) ) { + int n, o; + o = sample->length; + if ( o > 4 ) o = 4; + for ( n = 0; n < o; ++n ) + ( ( char * ) sample->data ) [n] = 0; + } + } + }*/ - /* Now let's initialise the remaining variables, and we're done! */ - sigdata->flags = IT_WAS_AN_XM | IT_WAS_A_MOD | IT_OLD_EFFECTS | IT_COMPATIBLE_GXX | IT_STEREO; + /* Now let's initialise the remaining variables, and we're done! */ + sigdata->flags = IT_WAS_AN_XM | IT_WAS_A_MOD | IT_OLD_EFFECTS | + IT_COMPATIBLE_GXX | IT_STEREO; - sigdata->global_volume = 128; - sigdata->mixing_volume = 48; - /* We want 50 ticks per second; 50/6 row advances per second; - * 50*10=500 row advances per minute; 500/4=125 beats per minute. - */ - sigdata->speed = 6; - sigdata->tempo = 125; - sigdata->pan_separation = 128; + sigdata->global_volume = 128; + sigdata->mixing_volume = 48; + /* We want 50 ticks per second; 50/6 row advances per second; + * 50*10=500 row advances per minute; 500/4=125 beats per minute. + */ + sigdata->speed = 6; + sigdata->tempo = 125; + sigdata->pan_separation = 128; - memset(sigdata->channel_volume, 64, DUMB_IT_N_CHANNELS); + memset(sigdata->channel_volume, 64, DUMB_IT_N_CHANNELS); - for (i = 0; i < DUMB_IT_N_CHANNELS; i += 4) { - int sep = 32 * dumb_it_default_panning_separation / 100; - sigdata->channel_pan[i+0] = 32 - sep; - sigdata->channel_pan[i+1] = 32 + sep; - sigdata->channel_pan[i+2] = 32 + sep; - sigdata->channel_pan[i+3] = 32 - sep; - } + for (i = 0; i < DUMB_IT_N_CHANNELS; i += 4) { + int sep = 32 * dumb_it_default_panning_separation / 100; + sigdata->channel_pan[i + 0] = 32 - sep; + sigdata->channel_pan[i + 1] = 32 + sep; + sigdata->channel_pan[i + 2] = 32 + sep; + sigdata->channel_pan[i + 3] = 32 - sep; + } - _dumb_it_fix_invalid_orders(sigdata); + _dumb_it_fix_invalid_orders(sigdata); - return sigdata; + return sigdata; } +DUH *dumb_read_mod_quick(DUMBFILE *f, int restrict_) { + sigdata_t *sigdata; + DUH_SIGTYPE_DESC *descptr = &_dumb_sigtype_it; -DUH *dumb_read_mod_quick(DUMBFILE *f, int restrict_) -{ - sigdata_t *sigdata; + sigdata = it_mod_load_sigdata(f, restrict_); - DUH_SIGTYPE_DESC *descptr = &_dumb_sigtype_it; + if (!sigdata) + return NULL; - sigdata = it_mod_load_sigdata(f, restrict_); - - if (!sigdata) - return NULL; - - { - const char *tag[2][2]; - tag[0][0] = "TITLE"; + { + const char *tag[2][2]; + tag[0][0] = "TITLE"; tag[0][1] = (const char *)(((DUMB_IT_SIGDATA *)sigdata)->name); - tag[1][0] = "FORMAT"; - tag[1][1] = "MOD"; - return make_duh(-1, 2, (const char *const (*)[2])tag, 1, &descptr, &sigdata); - } + tag[1][0] = "FORMAT"; + tag[1][1] = "MOD"; + return make_duh(-1, 2, (const char *const(*)[2])tag, 1, &descptr, + &sigdata); + } } diff --git a/Frameworks/Dumb/dumb/src/it/readmod2.c b/Frameworks/Dumb/dumb/src/it/readmod2.c index fa5eacc50..2d5ceacec 100644 --- a/Frameworks/Dumb/dumb/src/it/readmod2.c +++ b/Frameworks/Dumb/dumb/src/it/readmod2.c @@ -19,11 +19,8 @@ #include "dumb.h" - - -DUH *dumb_read_mod(DUMBFILE *f, int restrict_) -{ - DUH *duh = dumb_read_mod_quick(f, restrict_); - dumb_it_do_initial_runthrough(duh); - return duh; +DUH *dumb_read_mod(DUMBFILE *f, int restrict_) { + DUH *duh = dumb_read_mod_quick(f, restrict_); + dumb_it_do_initial_runthrough(duh); + return duh; } diff --git a/Frameworks/Dumb/dumb/src/it/readmtm.c b/Frameworks/Dumb/dumb/src/it/readmtm.c index 0daa5b83b..c5a273e76 100644 --- a/Frameworks/Dumb/dumb/src/it/readmtm.c +++ b/Frameworks/Dumb/dumb/src/it/readmtm.c @@ -24,407 +24,432 @@ #include "dumb.h" #include "internal/it.h" -size_t strlen_max(const char * ptr, size_t max) -{ - const char * end, * start; - if (ptr==0) return 0; - start = ptr; - end = ptr + max; - while(ptr < end && *ptr) ptr++; - return ptr - start; +size_t strlen_max(const char *ptr, size_t max) { + const char *end, *start; + if (ptr == 0) + return 0; + start = ptr; + end = ptr + max; + while (ptr < end && *ptr) + ptr++; + return ptr - start; } -static int it_mtm_assemble_pattern(IT_PATTERN *pattern, const unsigned char * track, const unsigned short * sequence, int n_rows) -{ - int n, o, note, sample; - const unsigned char * t; - IT_ENTRY * entry; +static int it_mtm_assemble_pattern(IT_PATTERN *pattern, + const unsigned char *track, + const unsigned short *sequence, int n_rows) { + int n, o, note, sample; + const unsigned char *t; + IT_ENTRY *entry; - pattern->n_rows = n_rows; - pattern->n_entries = n_rows; + pattern->n_rows = n_rows; + pattern->n_entries = n_rows; - for (n = 0; n < 32; n++) { - if (sequence[n]) { - t = &track[192 * (sequence[n] - 1)]; - for (o = 0; o < n_rows; o++) { - if (t[0] || t[1] || t[2]) pattern->n_entries++; - t += 3; - } - } - } + for (n = 0; n < 32; n++) { + if (sequence[n]) { + t = &track[192 * (sequence[n] - 1)]; + for (o = 0; o < n_rows; o++) { + if (t[0] || t[1] || t[2]) + pattern->n_entries++; + t += 3; + } + } + } - entry = malloc(pattern->n_entries * sizeof(*entry)); - if (!entry) return -1; - pattern->entry = entry; + entry = malloc(pattern->n_entries * sizeof(*entry)); + if (!entry) + return -1; + pattern->entry = entry; - for (n = 0; n < n_rows; n++) { - for (o = 0; o < 32; o++) { - if (sequence[o]) { - t = &track[192 * (sequence[o] - 1) + (n * 3)]; - if (t[0] || t[1] || t[2]) { - entry->channel = o; - entry->mask = 0; - note = t[0] >> 2; - sample = ((t[0] << 4) | (t[1] >> 4)) & 0x3F; + for (n = 0; n < n_rows; n++) { + for (o = 0; o < 32; o++) { + if (sequence[o]) { + t = &track[192 * (sequence[o] - 1) + (n * 3)]; + if (t[0] || t[1] || t[2]) { + entry->channel = o; + entry->mask = 0; + note = t[0] >> 2; + sample = ((t[0] << 4) | (t[1] >> 4)) & 0x3F; - if (note) { - entry->mask |= IT_ENTRY_NOTE; - entry->note = note + 24; - } + if (note) { + entry->mask |= IT_ENTRY_NOTE; + entry->note = note + 24; + } - if (sample) { - entry->mask |= IT_ENTRY_INSTRUMENT; - entry->instrument = sample; - } + if (sample) { + entry->mask |= IT_ENTRY_INSTRUMENT; + entry->instrument = sample; + } - _dumb_it_xm_convert_effect(t[1] & 0xF, t[2], entry, 1); + _dumb_it_xm_convert_effect(t[1] & 0xF, t[2], entry, 1); - if (entry->mask) entry++; - } - } - } - IT_SET_END_ROW(entry); - entry++; - } + if (entry->mask) + entry++; + } + } + } + IT_SET_END_ROW(entry); + entry++; + } - pattern->n_entries = (int)(entry - pattern->entry); + pattern->n_entries = (int)(entry - pattern->entry); - return 0; + return 0; } -static int it_mtm_read_sample_header(IT_SAMPLE *sample, DUMBFILE *f, int * skip_bytes) -{ - int finetune, flags; +static int it_mtm_read_sample_header(IT_SAMPLE *sample, DUMBFILE *f, + int *skip_bytes) { + int finetune, flags; dumbfile_getnc((char *)sample->name, 22, f); - sample->name[22] = 0; + sample->name[22] = 0; - sample->filename[0] = 0; + sample->filename[0] = 0; - sample->length = dumbfile_igetl(f); - sample->loop_start = dumbfile_igetl(f); - sample->loop_end = dumbfile_igetl(f); - finetune = (signed char)(dumbfile_getc(f) << 4) >> 4; /* signed nibble */ - sample->global_volume = 64; - sample->default_volume = dumbfile_getc(f); + sample->length = dumbfile_igetl(f); + sample->loop_start = dumbfile_igetl(f); + sample->loop_end = dumbfile_igetl(f); + finetune = (signed char)(dumbfile_getc(f) << 4) >> 4; /* signed nibble */ + sample->global_volume = 64; + sample->default_volume = dumbfile_getc(f); - flags = dumbfile_getc(f); + flags = dumbfile_getc(f); - if (sample->length <= 0) { - sample->flags = 0; - return 0; - } + if (sample->length <= 0) { + sample->flags = 0; + return 0; + } - sample->flags = IT_SAMPLE_EXISTS; + sample->flags = IT_SAMPLE_EXISTS; - *skip_bytes = 0; - if (flags & 1) { - *skip_bytes = sample->length & 1; - sample->flags |= IT_SAMPLE_16BIT; - sample->length >>= 1; - sample->loop_start >>= 1; - sample->loop_end >>= 1; - } + *skip_bytes = 0; + if (flags & 1) { + *skip_bytes = sample->length & 1; + sample->flags |= IT_SAMPLE_16BIT; + sample->length >>= 1; + sample->loop_start >>= 1; + sample->loop_end >>= 1; + } - sample->default_pan = 0; - sample->C5_speed = (int)( AMIGA_CLOCK / 214.0 );//(long)(16726.0*pow(DUMB_PITCH_BASE, finetune*32)); - sample->finetune = finetune * 32; - // the above line might be wrong + sample->default_pan = 0; + sample->C5_speed = + (int)(AMIGA_CLOCK / + 214.0); //(long)(16726.0*pow(DUMB_PITCH_BASE, finetune*32)); + sample->finetune = finetune * 32; + // the above line might be wrong - if (sample->loop_end > sample->length) - sample->loop_end = sample->length; + if (sample->loop_end > sample->length) + sample->loop_end = sample->length; - if (sample->loop_end - sample->loop_start > 2) - sample->flags |= IT_SAMPLE_LOOP; + if (sample->loop_end - sample->loop_start > 2) + sample->flags |= IT_SAMPLE_LOOP; - sample->vibrato_speed = 0; - sample->vibrato_depth = 0; - sample->vibrato_rate = 0; - sample->vibrato_waveform = 0; // do we have to set _all_ these? - sample->max_resampling_quality = -1; + sample->vibrato_speed = 0; + sample->vibrato_depth = 0; + sample->vibrato_rate = 0; + sample->vibrato_waveform = 0; // do we have to set _all_ these? + sample->max_resampling_quality = -1; - return dumbfile_error(f); + return dumbfile_error(f); } -static int it_mtm_read_sample_data(IT_SAMPLE *sample, DUMBFILE *f, int skip_bytes) -{ - long i; - long truncated_size; - long bytes_per_sample; +static int it_mtm_read_sample_data(IT_SAMPLE *sample, DUMBFILE *f, + int skip_bytes) { + long i; + long truncated_size; + long bytes_per_sample; - /* let's get rid of the sample data coming after the end of the loop */ - if ((sample->flags & IT_SAMPLE_LOOP) && sample->loop_end < sample->length) { - truncated_size = sample->length - sample->loop_end; - sample->length = sample->loop_end; - } else { - truncated_size = 0; - } - - bytes_per_sample = (sample->flags & IT_SAMPLE_16BIT) ? 2 : 1; + /* let's get rid of the sample data coming after the end of the loop */ + if ((sample->flags & IT_SAMPLE_LOOP) && sample->loop_end < sample->length) { + truncated_size = sample->length - sample->loop_end; + sample->length = sample->loop_end; + } else { + truncated_size = 0; + } - sample->data = malloc(sample->length * bytes_per_sample); + bytes_per_sample = (sample->flags & IT_SAMPLE_16BIT) ? 2 : 1; - if (!sample->data) - return -1; + sample->data = malloc(sample->length * bytes_per_sample); - dumbfile_getnc((char *)sample->data, sample->length * bytes_per_sample, f); - dumbfile_skip(f, truncated_size * bytes_per_sample); - dumbfile_skip(f, skip_bytes); + if (!sample->data) + return -1; - if (dumbfile_error(f)) - return -1; + dumbfile_getnc((char *)sample->data, sample->length * bytes_per_sample, f); + dumbfile_skip(f, truncated_size * bytes_per_sample); + dumbfile_skip(f, skip_bytes); - if (bytes_per_sample == 1) - for (i = 0; i < sample->length; i++) - ((signed char *)sample->data)[i] ^= 0x80; + if (dumbfile_error(f)) + return -1; - return 0; + if (bytes_per_sample == 1) + for (i = 0; i < sample->length; i++) + ((signed char *)sample->data)[i] ^= 0x80; + + return 0; } -static DUMB_IT_SIGDATA *it_mtm_load_sigdata(DUMBFILE *f, int * version) -{ - DUMB_IT_SIGDATA *sigdata; +static DUMB_IT_SIGDATA *it_mtm_load_sigdata(DUMBFILE *f, int *version) { + DUMB_IT_SIGDATA *sigdata; - int n, o, n_tracks, l_comment, n_rows, n_channels; + int n, o, n_tracks, l_comment, n_rows, n_channels; - unsigned char * track; + unsigned char *track; - unsigned short * sequence; + unsigned short *sequence; - char * comment; - - int * skip_bytes; + char *comment; - if (dumbfile_getc(f) != 'M' || - dumbfile_getc(f) != 'T' || - dumbfile_getc(f) != 'M') goto error; + int *skip_bytes; - *version = dumbfile_getc(f); + if (dumbfile_getc(f) != 'M' || dumbfile_getc(f) != 'T' || + dumbfile_getc(f) != 'M') + goto error; - sigdata = malloc(sizeof(*sigdata)); - if (!sigdata) goto error; + *version = dumbfile_getc(f); + + sigdata = malloc(sizeof(*sigdata)); + if (!sigdata) + goto error; dumbfile_getnc((char *)sigdata->name, 20, f); - sigdata->name[20] = 0; + sigdata->name[20] = 0; - n_tracks = dumbfile_igetw(f); - sigdata->n_patterns = dumbfile_getc(f) + 1; - sigdata->n_orders = dumbfile_getc(f) + 1; - l_comment = dumbfile_igetw(f); - sigdata->n_samples = dumbfile_getc(f); - //if (dumbfile_getc(f)) goto error_sd; - dumbfile_getc(f); - n_rows = dumbfile_getc(f); - n_channels = dumbfile_getc(f); + n_tracks = dumbfile_igetw(f); + sigdata->n_patterns = dumbfile_getc(f) + 1; + sigdata->n_orders = dumbfile_getc(f) + 1; + l_comment = dumbfile_igetw(f); + sigdata->n_samples = dumbfile_getc(f); + // if (dumbfile_getc(f)) goto error_sd; + dumbfile_getc(f); + n_rows = dumbfile_getc(f); + n_channels = dumbfile_getc(f); - if (dumbfile_error(f) || - (n_tracks <= 0) || - (sigdata->n_samples <= 0) || - (n_rows <= 0 || n_rows > 64) || - (n_channels <= 0 || n_channels > 32)) goto error_sd; + if (dumbfile_error(f) || (n_tracks <= 0) || (sigdata->n_samples <= 0) || + (n_rows <= 0 || n_rows > 64) || (n_channels <= 0 || n_channels > 32)) + goto error_sd; - memset(sigdata->channel_volume, 64, DUMB_IT_N_CHANNELS); + memset(sigdata->channel_volume, 64, DUMB_IT_N_CHANNELS); - if (dumbfile_getnc((char *)sigdata->channel_pan, 32, f) < 32) goto error_sd; + if (dumbfile_getnc((char *)sigdata->channel_pan, 32, f) < 32) + goto error_sd; - for (n = 0; n < 32; n++) { - if (sigdata->channel_pan[n] <= 15) { - sigdata->channel_pan[n] -= (sigdata->channel_pan[n] & 8) >> 3; - sigdata->channel_pan[n] = (sigdata->channel_pan[n] * 32) / 7; - } else { - sigdata->channel_volume[n] = 0; - sigdata->channel_pan[n] = 7; - } - } + for (n = 0; n < 32; n++) { + if (sigdata->channel_pan[n] <= 15) { + sigdata->channel_pan[n] -= (sigdata->channel_pan[n] & 8) >> 3; + sigdata->channel_pan[n] = (sigdata->channel_pan[n] * 32) / 7; + } else { + sigdata->channel_volume[n] = 0; + sigdata->channel_pan[n] = 7; + } + } - for (n = 32; n < DUMB_IT_N_CHANNELS; n += 4) { - int sep = 32 * dumb_it_default_panning_separation / 100; - sigdata->channel_pan[n ] = 32 - sep; - sigdata->channel_pan[n+1] = 32 + sep; - sigdata->channel_pan[n+2] = 32 + sep; - sigdata->channel_pan[n+3] = 32 - sep; - } + for (n = 32; n < DUMB_IT_N_CHANNELS; n += 4) { + int sep = 32 * dumb_it_default_panning_separation / 100; + sigdata->channel_pan[n] = 32 - sep; + sigdata->channel_pan[n + 1] = 32 + sep; + sigdata->channel_pan[n + 2] = 32 + sep; + sigdata->channel_pan[n + 3] = 32 - sep; + } - sigdata->sample = malloc(sigdata->n_samples * sizeof(*sigdata->sample)); - if (!sigdata->sample) goto error_sd; + sigdata->sample = malloc(sigdata->n_samples * sizeof(*sigdata->sample)); + if (!sigdata->sample) + goto error_sd; - sigdata->flags = IT_WAS_AN_XM | IT_WAS_A_MOD | IT_STEREO | IT_OLD_EFFECTS | IT_COMPATIBLE_GXX; + sigdata->flags = IT_WAS_AN_XM | IT_WAS_A_MOD | IT_STEREO | IT_OLD_EFFECTS | + IT_COMPATIBLE_GXX; - sigdata->global_volume = 128; - sigdata->mixing_volume = 48; - sigdata->speed = 6; - sigdata->tempo = 125; - sigdata->pan_separation = 128; + sigdata->global_volume = 128; + sigdata->mixing_volume = 48; + sigdata->speed = 6; + sigdata->tempo = 125; + sigdata->pan_separation = 128; - sigdata->song_message = NULL; - sigdata->order = NULL; - sigdata->instrument = NULL; - sigdata->pattern = NULL; - sigdata->midi = NULL; - sigdata->checkpoint = NULL; + sigdata->song_message = NULL; + sigdata->order = NULL; + sigdata->instrument = NULL; + sigdata->pattern = NULL; + sigdata->midi = NULL; + sigdata->checkpoint = NULL; - sigdata->n_instruments = 0; + sigdata->n_instruments = 0; - sigdata->restart_position = 0; - sigdata->n_pchannels = n_channels; - - for (n = 0; n < sigdata->n_samples; n++) - sigdata->sample[n].data = NULL; + sigdata->restart_position = 0; + sigdata->n_pchannels = n_channels; - skip_bytes = calloc(sizeof(int), sigdata->n_samples); - if (!skip_bytes) goto error_usd; - - for (n = 0; n < sigdata->n_samples; n++) { - if (it_mtm_read_sample_header(&sigdata->sample[n], f, skip_bytes + n)) goto error_sb; - } + for (n = 0; n < sigdata->n_samples; n++) + sigdata->sample[n].data = NULL; - sigdata->order = malloc(sigdata->n_orders); - if (!sigdata->order) goto error_sb; + skip_bytes = calloc(sizeof(int), sigdata->n_samples); + if (!skip_bytes) + goto error_usd; - if (dumbfile_getnc((char *)sigdata->order, sigdata->n_orders, f) < sigdata->n_orders) goto error_sb; - if (sigdata->n_orders < 128) - if (dumbfile_skip(f, 128 - sigdata->n_orders)) goto error_sb; + for (n = 0; n < sigdata->n_samples; n++) { + if (it_mtm_read_sample_header(&sigdata->sample[n], f, skip_bytes + n)) + goto error_sb; + } - track = malloc(192 * n_tracks); - if (!track) goto error_sb; + sigdata->order = malloc(sigdata->n_orders); + if (!sigdata->order) + goto error_sb; - if (dumbfile_getnc((char *)track, 192 * n_tracks, f) < 192 * n_tracks) goto error_ft; + if (dumbfile_getnc((char *)sigdata->order, sigdata->n_orders, f) < + sigdata->n_orders) + goto error_sb; + if (sigdata->n_orders < 128) + if (dumbfile_skip(f, 128 - sigdata->n_orders)) + goto error_sb; - sigdata->pattern = malloc(sigdata->n_patterns * sizeof(*sigdata->pattern)); - if (!sigdata->pattern) goto error_ft; - for (n = 0; n < sigdata->n_patterns; n++) - sigdata->pattern[n].entry = NULL; + track = malloc(192 * n_tracks); + if (!track) + goto error_sb; - sequence = malloc(sigdata->n_patterns * 32 * sizeof(*sequence)); - if (!sequence) goto error_ft; + if (dumbfile_getnc((char *)track, 192 * n_tracks, f) < 192 * n_tracks) + goto error_ft; - for (n = 0; n < sigdata->n_patterns; n++) { - for (o = 0; o < 32; o++) { - sequence[(n * 32) + o] = dumbfile_igetw(f); - if (sequence[(n * 32) + o] > n_tracks) - { - //goto error_fs; - // illegal track number, silence instead of rejecting the file - sequence[(n * 32) + o] = 0; - } - } - } + sigdata->pattern = malloc(sigdata->n_patterns * sizeof(*sigdata->pattern)); + if (!sigdata->pattern) + goto error_ft; + for (n = 0; n < sigdata->n_patterns; n++) + sigdata->pattern[n].entry = NULL; - for (n = 0; n < sigdata->n_patterns; n++) { - if (it_mtm_assemble_pattern(&sigdata->pattern[n], track, &sequence[n * 32], n_rows)) goto error_fs; - } + sequence = malloc(sigdata->n_patterns * 32 * sizeof(*sequence)); + if (!sequence) + goto error_ft; - if (l_comment) { - comment = malloc(l_comment); - if (!comment) goto error_fs; - if (dumbfile_getnc(comment, l_comment, f) < l_comment) goto error_fc; + for (n = 0; n < sigdata->n_patterns; n++) { + for (o = 0; o < 32; o++) { + sequence[(n * 32) + o] = dumbfile_igetw(f); + if (sequence[(n * 32) + o] > n_tracks) { + // goto error_fs; + // illegal track number, silence instead of rejecting the file + sequence[(n * 32) + o] = 0; + } + } + } - /* Time for annoying "logic", yes. We want each line which has text, - * and each blank line in between all the valid lines. - */ + for (n = 0; n < sigdata->n_patterns; n++) { + if (it_mtm_assemble_pattern(&sigdata->pattern[n], track, + &sequence[n * 32], n_rows)) + goto error_fs; + } - /* Find last actual line. */ - for (o = -1, n = 0; n < l_comment; n += 40) { - if (comment[n]) o = n; - } + if (l_comment) { + comment = malloc(l_comment); + if (!comment) + goto error_fs; + if (dumbfile_getnc(comment, l_comment, f) < l_comment) + goto error_fc; - if (o >= 0) { + /* Time for annoying "logic", yes. We want each line which has text, + * and each blank line in between all the valid lines. + */ - int l, m; + /* Find last actual line. */ + for (o = -1, n = 0; n < l_comment; n += 40) { + if (comment[n]) + o = n; + } - for (l = 0, n = 0; n <= o; n += 40) { - int maxlen = l_comment - n; - l += strlen_max(&comment[n], maxlen > 40 ? 40 : maxlen) + 2; - } + if (o >= 0) { - l -= 1; + int l, m; - sigdata->song_message = malloc(l); - if (!sigdata->song_message) goto error_fc; + for (l = 0, n = 0; n <= o; n += 40) { + int maxlen = l_comment - n; + l += strlen_max(&comment[n], maxlen > 40 ? 40 : maxlen) + 2; + } - for (m = 0, n = 0; n <= o; n += 40) { - int maxlen = l_comment - n; - int p = (int) strlen_max(&comment[n], maxlen > 40 ? 40 : maxlen); - if (p) { - memcpy(sigdata->song_message + m, &comment[n], p); - m += p; - } - if (l - m > 1) { - sigdata->song_message[m++] = 13; - sigdata->song_message[m++] = 10; - } - } - - sigdata->song_message[m] = 0; - } + l -= 1; - free(comment); - } + sigdata->song_message = malloc(l); + if (!sigdata->song_message) + goto error_fc; - for (n = 0; n < sigdata->n_samples; n++) { - if (it_mtm_read_sample_data(&sigdata->sample[n], f, skip_bytes[n])) goto error_fs; - } - - _dumb_it_fix_invalid_orders(sigdata); + for (m = 0, n = 0; n <= o; n += 40) { + int maxlen = l_comment - n; + int p = (int)strlen_max(&comment[n], maxlen > 40 ? 40 : maxlen); + if (p) { + memcpy(sigdata->song_message + m, &comment[n], p); + m += p; + } + if (l - m > 1) { + sigdata->song_message[m++] = 13; + sigdata->song_message[m++] = 10; + } + } - free(sequence); - free(track); - free(skip_bytes); + sigdata->song_message[m] = 0; + } - return sigdata; + free(comment); + } + + for (n = 0; n < sigdata->n_samples; n++) { + if (it_mtm_read_sample_data(&sigdata->sample[n], f, skip_bytes[n])) + goto error_fs; + } + + _dumb_it_fix_invalid_orders(sigdata); + + free(sequence); + free(track); + free(skip_bytes); + + return sigdata; error_fc: - free(comment); + free(comment); error_fs: - free(sequence); + free(sequence); error_ft: - free(track); + free(track); error_sb: - free(skip_bytes); + free(skip_bytes); error_usd: - _dumb_it_unload_sigdata(sigdata); - return NULL; + _dumb_it_unload_sigdata(sigdata); + return NULL; error_sd: - free(sigdata); + free(sigdata); error: - return NULL; + return NULL; } -static char hexdigit(int in) -{ - if (in < 10) return in + '0'; - else return in + 'A' - 10; +static char hexdigit(int in) { + if (in < 10) + return in + '0'; + else + return in + 'A' - 10; } -DUH *dumb_read_mtm_quick(DUMBFILE *f) -{ - sigdata_t *sigdata; - int ver; +DUH *dumb_read_mtm_quick(DUMBFILE *f) { + sigdata_t *sigdata; + int ver; - DUH_SIGTYPE_DESC *descptr = &_dumb_sigtype_it; + DUH_SIGTYPE_DESC *descptr = &_dumb_sigtype_it; - sigdata = it_mtm_load_sigdata(f, &ver); + sigdata = it_mtm_load_sigdata(f, &ver); - if (!sigdata) - return NULL; + if (!sigdata) + return NULL; - { - char version[16]; - const char *tag[2][2]; - tag[0][0] = "TITLE"; + { + char version[16]; + const char *tag[2][2]; + tag[0][0] = "TITLE"; tag[0][1] = (const char *)(((DUMB_IT_SIGDATA *)sigdata)->name); - tag[1][0] = "FORMAT"; - version[0] = 'M'; - version[1] = 'T'; - version[2] = 'M'; - version[3] = ' '; - version[4] = 'v'; - version[5] = hexdigit(ver >> 4); - version[6] = '.'; - version[7] = hexdigit(ver & 15); - version[8] = 0; - tag[1][1] = (const char *) &version; - return make_duh(-1, 2, (const char *const (*)[2])tag, 1, &descptr, &sigdata); - } + tag[1][0] = "FORMAT"; + version[0] = 'M'; + version[1] = 'T'; + version[2] = 'M'; + version[3] = ' '; + version[4] = 'v'; + version[5] = hexdigit(ver >> 4); + version[6] = '.'; + version[7] = hexdigit(ver & 15); + version[8] = 0; + tag[1][1] = (const char *)&version; + return make_duh(-1, 2, (const char *const(*)[2])tag, 1, &descptr, + &sigdata); + } } diff --git a/Frameworks/Dumb/dumb/src/it/readokt.c b/Frameworks/Dumb/dumb/src/it/readokt.c index 75a38e1c9..8ac7c201d 100644 --- a/Frameworks/Dumb/dumb/src/it/readokt.c +++ b/Frameworks/Dumb/dumb/src/it/readokt.c @@ -24,535 +24,579 @@ #include "dumb.h" #include "internal/it.h" +static int it_okt_read_pattern(IT_PATTERN *pattern, const unsigned char *data, + int length, int n_channels) { + int pos; + int channel; + int row; + int n_rows; + IT_ENTRY *entry; + if (length < 2) + return -1; -static int it_okt_read_pattern(IT_PATTERN *pattern, const unsigned char *data, int length, int n_channels) -{ - int pos; - int channel; - int row; - int n_rows; - IT_ENTRY *entry; + n_rows = (data[0] << 8) | data[1]; + if (!n_rows) + n_rows = 64; - if (length < 2) return -1; + if (length < 2 + (n_rows * n_channels * 4)) + return -1; - n_rows = (data[0] << 8) | data[1]; - if (!n_rows) n_rows = 64; + pattern->n_rows = n_rows; - if (length < 2 + (n_rows * n_channels * 4)) return -1; + /* compute number of entries */ + pattern->n_entries = n_rows; /* Account for the row end markers */ + pos = 2; + for (row = 0; row < pattern->n_rows; row++) { + for (channel = 0; channel < n_channels; channel++) { + if (data[pos + 0] | data[pos + 2]) + pattern->n_entries++; + pos += 4; + } + } - pattern->n_rows = n_rows; + pattern->entry = + (IT_ENTRY *)malloc(pattern->n_entries * sizeof(*pattern->entry)); + if (!pattern->entry) + return -1; - /* compute number of entries */ - pattern->n_entries = n_rows; /* Account for the row end markers */ - pos = 2; - for (row = 0; row < pattern->n_rows; row++) { - for (channel = 0; channel < n_channels; channel++) { - if (data[pos+0] | data[pos+2]) - pattern->n_entries++; - pos += 4; - } - } + entry = pattern->entry; + pos = 2; + for (row = 0; row < n_rows; row++) { + for (channel = 0; channel < n_channels; channel++) { + if (data[pos + 0] | data[pos + 2]) { + entry->channel = channel; + entry->mask = 0; - pattern->entry = (IT_ENTRY *) malloc(pattern->n_entries * sizeof(*pattern->entry)); - if (!pattern->entry) - return -1; + if (data[pos + 0] > 0 && data[pos + 0] <= 36) { + entry->mask |= IT_ENTRY_NOTE | IT_ENTRY_INSTRUMENT; - entry = pattern->entry; - pos = 2; - for (row = 0; row < n_rows; row++) { - for (channel = 0; channel < n_channels; channel++) { - if (data[pos+0] | data[pos+2]) { - entry->channel = channel; - entry->mask = 0; + entry->note = data[pos + 0] + 35; + entry->instrument = data[pos + 1] + 1; + } - if (data[pos+0] > 0 && data[pos+0] <= 36) { - entry->mask |= IT_ENTRY_NOTE | IT_ENTRY_INSTRUMENT; + entry->effect = 0; + entry->effectvalue = data[pos + 3]; - entry->note = data[pos+0] + 35; - entry->instrument = data[pos+1] + 1; - } + switch (data[pos + 2]) { + case 2: + if (data[pos + 3]) + entry->effect = IT_PORTAMENTO_DOWN; + break; // XXX code calls this rs_portu, but it's adding to + // the period, which decreases the pitch + case 13: + if (data[pos + 3]) + entry->effect = IT_OKT_NOTE_SLIDE_DOWN; + break; + case 21: + if (data[pos + 3]) + entry->effect = IT_OKT_NOTE_SLIDE_DOWN_ROW; + break; - entry->effect = 0; - entry->effectvalue = data[pos+3]; + case 1: + if (data[pos + 3]) + entry->effect = IT_PORTAMENTO_UP; + break; // XXX same deal here, increasing the pitch + case 17: + if (data[pos + 3]) + entry->effect = IT_OKT_NOTE_SLIDE_UP; + break; + case 30: + if (data[pos + 3]) + entry->effect = IT_OKT_NOTE_SLIDE_UP_ROW; + break; - switch (data[pos+2]) { - case 2: if (data[pos+3]) entry->effect = IT_PORTAMENTO_DOWN; break; // XXX code calls this rs_portu, but it's adding to the period, which decreases the pitch - case 13: if (data[pos+3]) entry->effect = IT_OKT_NOTE_SLIDE_DOWN; break; - case 21: if (data[pos+3]) entry->effect = IT_OKT_NOTE_SLIDE_DOWN_ROW; break; + case 10: + if (data[pos + 3]) + entry->effect = IT_OKT_ARPEGGIO_3; + break; + case 11: + if (data[pos + 3]) + entry->effect = IT_OKT_ARPEGGIO_4; + break; + case 12: + if (data[pos + 3]) + entry->effect = IT_OKT_ARPEGGIO_5; + break; - case 1: if (data[pos+3]) entry->effect = IT_PORTAMENTO_UP; break; // XXX same deal here, increasing the pitch - case 17: if (data[pos+3]) entry->effect = IT_OKT_NOTE_SLIDE_UP; break; - case 30: if (data[pos+3]) entry->effect = IT_OKT_NOTE_SLIDE_UP_ROW; break; + case 15: + entry->effect = IT_S; + entry->effectvalue = + EFFECT_VALUE(IT_S_SET_FILTER, data[pos + 3] & 0x0F); + break; - case 10: if (data[pos+3]) entry->effect = IT_OKT_ARPEGGIO_3; break; - case 11: if (data[pos+3]) entry->effect = IT_OKT_ARPEGGIO_4; break; - case 12: if (data[pos+3]) entry->effect = IT_OKT_ARPEGGIO_5; break; + case 25: + entry->effect = IT_JUMP_TO_ORDER; + break; - case 15: entry->effect = IT_S; entry->effectvalue = EFFECT_VALUE(IT_S_SET_FILTER, data[pos+3] & 0x0F); break; + case 27: + entry->note = IT_NOTE_OFF; + entry->mask |= IT_ENTRY_NOTE; + break; - case 25: entry->effect = IT_JUMP_TO_ORDER; break; + case 28: + entry->effect = IT_SET_SPEED; + break; - case 27: entry->note = IT_NOTE_OFF; entry->mask |= IT_ENTRY_NOTE; break; + case 31: + if (data[pos + 3] <= 0x40) + entry->effect = IT_SET_CHANNEL_VOLUME; + else if (data[pos + 3] <= 0x50) { + entry->effect = IT_OKT_VOLUME_SLIDE_DOWN; + entry->effectvalue = data[pos + 3] - 0x40; + } else if (data[pos + 3] <= 0x60) { + entry->effect = IT_OKT_VOLUME_SLIDE_UP; + entry->effectvalue = data[pos + 3] - 0x50; + } else if (data[pos + 3] <= 0x70) { + entry->effect = IT_OKT_VOLUME_SLIDE_DOWN; + entry->effectvalue = data[pos + 3] - 0x50; + } else if (data[pos + 3] <= 0x80) { + entry->effect = IT_OKT_VOLUME_SLIDE_UP; + entry->effectvalue = data[pos + 3] - 0x60; + } + break; + } - case 28: entry->effect = IT_SET_SPEED; break; + if (entry->effect) + entry->mask |= IT_ENTRY_EFFECT; - case 31: - if ( data[pos+3] <= 0x40 ) entry->effect = IT_SET_CHANNEL_VOLUME; - else if ( data[pos+3] <= 0x50 ) { entry->effect = IT_OKT_VOLUME_SLIDE_DOWN; entry->effectvalue = data[pos+3] - 0x40; } - else if ( data[pos+3] <= 0x60 ) { entry->effect = IT_OKT_VOLUME_SLIDE_UP; entry->effectvalue = data[pos+3] - 0x50; } - else if ( data[pos+3] <= 0x70 ) { entry->effect = IT_OKT_VOLUME_SLIDE_DOWN; entry->effectvalue = data[pos+3] - 0x50; } - else if ( data[pos+3] <= 0x80 ) { entry->effect = IT_OKT_VOLUME_SLIDE_UP; entry->effectvalue = data[pos+3] - 0x60; } - break; - } + entry++; + } + pos += 4; + } + IT_SET_END_ROW(entry); + entry++; + } - if ( entry->effect ) entry->mask |= IT_ENTRY_EFFECT; - - entry++; - } - pos += 4; - } - IT_SET_END_ROW(entry); - entry++; - } - - return 0; + return 0; } +static void it_okt_read_sample_header(IT_SAMPLE *sample, + const unsigned char *data) { + int loop_start, loop_length; + memcpy(sample->name, data, 20); + sample->name[20] = 0; -static void it_okt_read_sample_header(IT_SAMPLE *sample, const unsigned char * data) -{ - int loop_start, loop_length; + sample->filename[0] = 0; - memcpy(sample->name, data, 20); - sample->name[20] = 0; + sample->length = + (data[20] << 24) | (data[21] << 16) | (data[22] << 8) | data[23]; + sample->global_volume = 64; + sample->default_volume = data[29]; + loop_start = ((data[24] << 8) | data[25]) << 1; + loop_length = ((data[26] << 8) | data[27]) << 1; + sample->sus_loop_start = loop_start; + sample->sus_loop_end = loop_start + loop_length; - sample->filename[0] = 0; + if (sample->length <= 0) { + sample->flags = 0; + return; + } - sample->length = (data[20] << 24) | (data[21] << 16) | (data[22] << 8) | data[23]; - sample->global_volume = 64; - sample->default_volume = data[29]; - loop_start = ((data[24] << 8) | data[25]) << 1; - loop_length = ((data[26] << 8) | data[27]) << 1; - sample->sus_loop_start = loop_start; - sample->sus_loop_end = loop_start + loop_length; + sample->flags = IT_SAMPLE_EXISTS; - if (sample->length <= 0) { - sample->flags = 0; - return; - } + sample->default_pan = 0; + sample->C5_speed = + (int)(AMIGA_CLOCK / + 214.0); //(long)(16726.0*pow(DUMB_PITCH_BASE, finetune*32)); + sample->finetune = 0; - sample->flags = IT_SAMPLE_EXISTS; + if (sample->sus_loop_end > sample->length) + sample->sus_loop_end = sample->length; - sample->default_pan = 0; - sample->C5_speed = (int)( AMIGA_CLOCK / 214.0 ); //(long)(16726.0*pow(DUMB_PITCH_BASE, finetune*32)); - sample->finetune = 0; + if (loop_length > 2) + sample->flags |= IT_SAMPLE_SUS_LOOP; - if (sample->sus_loop_end > sample->length) - sample->sus_loop_end = sample->length; - - if (loop_length > 2) - sample->flags |= IT_SAMPLE_SUS_LOOP; - - sample->vibrato_speed = 0; - sample->vibrato_depth = 0; - sample->vibrato_rate = 0; - sample->vibrato_waveform = 0; // do we have to set _all_ these? - sample->max_resampling_quality = -1; + sample->vibrato_speed = 0; + sample->vibrato_depth = 0; + sample->vibrato_rate = 0; + sample->vibrato_waveform = 0; // do we have to set _all_ these? + sample->max_resampling_quality = -1; } +static int it_okt_read_sample_data(IT_SAMPLE *sample, const char *data, + int length) { + if (length && sample->length) { + if (length < sample->length) { + sample->length = length; + if (length < sample->sus_loop_end) + sample->sus_loop_end = length; + } + sample->data = malloc(length); -static int it_okt_read_sample_data(IT_SAMPLE *sample, const char * data, int length) -{ - if (length && sample->length) { - if (length < sample->length) { - sample->length = length; - if (length < sample->sus_loop_end) sample->sus_loop_end = length; - } + if (!sample->data) + return -1; - sample->data = malloc(length); + memcpy(sample->data, data, length); + } - if (!sample->data) - return -1; - - memcpy(sample->data, data, length); - } - - return 0; + return 0; } - - typedef struct IFF_CHUNK IFF_CHUNK; typedef struct IFF_CHUNKED IFF_CHUNKED; -struct IFF_CHUNK -{ - unsigned type; - unsigned char * data; - unsigned size; +struct IFF_CHUNK { + unsigned type; + unsigned char *data; + unsigned size; }; -struct IFF_CHUNKED -{ - unsigned chunk_count; - IFF_CHUNK * chunks; +struct IFF_CHUNKED { + unsigned chunk_count; + IFF_CHUNK *chunks; }; +static IFF_CHUNKED *dumbfile_read_okt(DUMBFILE *f) { + IFF_CHUNKED *mod = (IFF_CHUNKED *)malloc(sizeof(*mod)); + if (!mod) + return NULL; + mod->chunk_count = 0; + mod->chunks = 0; -static IFF_CHUNKED *dumbfile_read_okt(DUMBFILE *f) -{ - IFF_CHUNKED *mod = (IFF_CHUNKED *) malloc(sizeof(*mod)); - if (!mod) return NULL; + for (;;) { + long bytes_read; + IFF_CHUNK *chunk = (IFF_CHUNK *)realloc( + mod->chunks, (mod->chunk_count + 1) * sizeof(IFF_CHUNK)); + if (!chunk) { + if (mod->chunks) + free(mod->chunks); + free(mod); + return NULL; + } + mod->chunks = chunk; + chunk += mod->chunk_count; - mod->chunk_count = 0; - mod->chunks = 0; + bytes_read = dumbfile_mgetl(f); + if (bytes_read < 0) + break; - for (;;) - { - long bytes_read; - IFF_CHUNK * chunk = ( IFF_CHUNK * ) realloc( mod->chunks, ( mod->chunk_count + 1 ) * sizeof( IFF_CHUNK ) ); - if ( !chunk ) - { - if ( mod->chunks ) free( mod->chunks ); - free( mod ); - return NULL; - } - mod->chunks = chunk; - chunk += mod->chunk_count; + chunk->type = (unsigned int)bytes_read; + chunk->size = (unsigned int)dumbfile_mgetl(f); - bytes_read = dumbfile_mgetl( f ); - if ( bytes_read < 0 ) break; + if (dumbfile_error(f)) + break; - chunk->type = bytes_read; - chunk->size = dumbfile_mgetl( f ); + chunk->data = (unsigned char *)malloc(chunk->size); + if (!chunk->data) { + free(mod->chunks); + free(mod); + return NULL; + } - if ( dumbfile_error( f ) ) break; + bytes_read = dumbfile_getnc((char *)chunk->data, chunk->size, f); + if (bytes_read < chunk->size) { + if (bytes_read <= 0) { + free(chunk->data); + break; + } else { + chunk->size = (unsigned int)bytes_read; + mod->chunk_count++; + break; + } + } - chunk->data = (unsigned char *) malloc( chunk->size ); - if ( !chunk->data ) - { - free( mod->chunks ); - free( mod ); - return NULL; - } + mod->chunk_count++; + } - bytes_read = dumbfile_getnc( ( char * ) chunk->data, chunk->size, f ); - if ( bytes_read < chunk->size ) - { - if ( bytes_read <= 0 ) { - free( chunk->data ); - break; - } else { - chunk->size = bytes_read; - mod->chunk_count++; - break; - } - } + if (!mod->chunk_count) { + if (mod->chunks) + free(mod->chunks); + free(mod); + mod = NULL; + } - mod->chunk_count++; - } - - if ( !mod->chunk_count ) { - if ( mod->chunks ) free(mod->chunks); - free(mod); - mod = NULL; - } - - return mod; + return mod; } -void free_okt(IFF_CHUNKED * mod) -{ - unsigned i; - if (mod) - { - if (mod->chunks) - { - for (i = 0; i < mod->chunk_count; i++) - { - if (mod->chunks[i].data) free(mod->chunks[i].data); - } - free(mod->chunks); - } - free(mod); - } +void free_okt(IFF_CHUNKED *mod) { + unsigned i; + if (mod) { + if (mod->chunks) { + for (i = 0; i < mod->chunk_count; i++) { + if (mod->chunks[i].data) + free(mod->chunks[i].data); + } + free(mod->chunks); + } + free(mod); + } } -const IFF_CHUNK * get_chunk_by_type(IFF_CHUNKED * mod, unsigned type, unsigned offset) -{ - unsigned i; - if (mod) - { - if (mod->chunks) - { - for (i = 0; i < mod->chunk_count; i++) - { - if (mod->chunks[i].type == type) - { - if (!offset) return &mod->chunks[i]; - else offset--; - } - } - } - } - return NULL; +const IFF_CHUNK *get_chunk_by_type(IFF_CHUNKED *mod, unsigned type, + unsigned offset) { + unsigned i; + if (mod) { + if (mod->chunks) { + for (i = 0; i < mod->chunk_count; i++) { + if (mod->chunks[i].type == type) { + if (!offset) + return &mod->chunks[i]; + else + offset--; + } + } + } + } + return NULL; } -unsigned get_chunk_count(IFF_CHUNKED *mod, unsigned type) -{ - unsigned i, count = 0; - if (mod) - { - if (mod->chunks) - { - for (i = 0; i < mod->chunk_count; i++) - { - if (mod->chunks[i].type == type) count++; - } - } - } - return count; +unsigned get_chunk_count(IFF_CHUNKED *mod, unsigned type) { + unsigned i, count = 0; + if (mod) { + if (mod->chunks) { + for (i = 0; i < mod->chunk_count; i++) { + if (mod->chunks[i].type == type) + count++; + } + } + } + return count; } - -static DUMB_IT_SIGDATA *it_okt_load_sigdata(DUMBFILE *f) -{ - DUMB_IT_SIGDATA *sigdata; +static DUMB_IT_SIGDATA *it_okt_load_sigdata(DUMBFILE *f) { + DUMB_IT_SIGDATA *sigdata; int n_channels; int i, j, k, l; - IFF_CHUNKED *mod; - const IFF_CHUNK *chunk; + IFF_CHUNKED *mod; + const IFF_CHUNK *chunk; - char signature[8]; + char signature[8]; - if (dumbfile_getnc(signature, 8, f) < 8 || - memcmp(signature, "OKTASONG", 8)) { - return NULL; - } + if (dumbfile_getnc(signature, 8, f) < 8 || + memcmp(signature, "OKTASONG", 8)) { + return NULL; + } - mod = dumbfile_read_okt(f); - if (!mod) - return NULL; + mod = dumbfile_read_okt(f); + if (!mod) + return NULL; - sigdata = (DUMB_IT_SIGDATA *) malloc(sizeof(*sigdata)); - if (!sigdata) { - free_okt(mod); - return NULL; - } + sigdata = (DUMB_IT_SIGDATA *)malloc(sizeof(*sigdata)); + if (!sigdata) { + free_okt(mod); + return NULL; + } - sigdata->name[0] = 0; + sigdata->name[0] = 0; - chunk = get_chunk_by_type(mod, DUMB_ID('S','P','E','E'), 0); - if (!chunk || chunk->size < 2) { - free(sigdata); - free_okt(mod); - return NULL; - } + chunk = get_chunk_by_type(mod, DUMB_ID('S', 'P', 'E', 'E'), 0); + if (!chunk || chunk->size < 2) { + free(sigdata); + free_okt(mod); + return NULL; + } - sigdata->speed = (chunk->data[0] << 8) | chunk->data[1]; + sigdata->speed = (chunk->data[0] << 8) | chunk->data[1]; - chunk = get_chunk_by_type(mod, DUMB_ID('S','A','M','P'), 0); - if (!chunk || chunk->size < 32) { - free(sigdata); - free_okt(mod); - return NULL; - } + chunk = get_chunk_by_type(mod, DUMB_ID('S', 'A', 'M', 'P'), 0); + if (!chunk || chunk->size < 32) { + free(sigdata); + free_okt(mod); + return NULL; + } - sigdata->n_samples = chunk->size / 32; + sigdata->n_samples = chunk->size / 32; - chunk = get_chunk_by_type(mod, DUMB_ID('C','M','O','D'), 0); - if (!chunk || chunk->size < 8) { - free(sigdata); - free_okt(mod); - return NULL; - } + chunk = get_chunk_by_type(mod, DUMB_ID('C', 'M', 'O', 'D'), 0); + if (!chunk || chunk->size < 8) { + free(sigdata); + free_okt(mod); + return NULL; + } - n_channels = 0; + n_channels = 0; - for (i = 0; i < 4; i++) { - j = (chunk->data[i * 2] << 8) | chunk->data[i * 2 + 1]; - if (!j) n_channels++; - else if (j == 1) n_channels += 2; - } + for (i = 0; i < 4; i++) { + j = (chunk->data[i * 2] << 8) | chunk->data[i * 2 + 1]; + if (!j) + n_channels++; + else if (j == 1) + n_channels += 2; + } - if (!n_channels) { - free(sigdata); - free_okt(mod); - return NULL; - } + if (!n_channels) { + free(sigdata); + free_okt(mod); + return NULL; + } - sigdata->n_pchannels = n_channels; + sigdata->n_pchannels = n_channels; - sigdata->sample = (IT_SAMPLE *) malloc(sigdata->n_samples * sizeof(*sigdata->sample)); - if (!sigdata->sample) { - free(sigdata); - free_okt(mod); - return NULL; - } + sigdata->sample = + (IT_SAMPLE *)malloc(sigdata->n_samples * sizeof(*sigdata->sample)); + if (!sigdata->sample) { + free(sigdata); + free_okt(mod); + return NULL; + } - sigdata->song_message = NULL; - sigdata->order = NULL; - sigdata->instrument = NULL; - sigdata->pattern = NULL; - sigdata->midi = NULL; - sigdata->checkpoint = NULL; + sigdata->song_message = NULL; + sigdata->order = NULL; + sigdata->instrument = NULL; + sigdata->pattern = NULL; + sigdata->midi = NULL; + sigdata->checkpoint = NULL; - sigdata->n_instruments = 0; + sigdata->n_instruments = 0; - for (i = 0; i < sigdata->n_samples; i++) - sigdata->sample[i].data = NULL; + for (i = 0; i < sigdata->n_samples; i++) + sigdata->sample[i].data = NULL; - chunk = get_chunk_by_type(mod, DUMB_ID('S','A','M','P'), 0); + chunk = get_chunk_by_type(mod, DUMB_ID('S', 'A', 'M', 'P'), 0); - for (i = 0; i < sigdata->n_samples; i++) { - it_okt_read_sample_header(&sigdata->sample[i], chunk->data + 32 * i); - } + for (i = 0; i < sigdata->n_samples; i++) { + it_okt_read_sample_header(&sigdata->sample[i], chunk->data + 32 * i); + } - sigdata->restart_position = 0; + sigdata->restart_position = 0; - chunk = get_chunk_by_type(mod, DUMB_ID('P','L','E','N'), 0); - if (!chunk || chunk->size < 2) { - _dumb_it_unload_sigdata(sigdata); - free_okt(mod); - return NULL; - } + chunk = get_chunk_by_type(mod, DUMB_ID('P', 'L', 'E', 'N'), 0); + if (!chunk || chunk->size < 2) { + _dumb_it_unload_sigdata(sigdata); + free_okt(mod); + return NULL; + } - sigdata->n_orders = (chunk->data[0] << 8) | chunk->data[1]; - // what if this is > 128? + sigdata->n_orders = (chunk->data[0] << 8) | chunk->data[1]; + // what if this is > 128? - if (sigdata->n_orders <= 0 || sigdata->n_orders > 128) { - _dumb_it_unload_sigdata(sigdata); - free_okt(mod); - return NULL; - } + if (sigdata->n_orders <= 0 || sigdata->n_orders > 128) { + _dumb_it_unload_sigdata(sigdata); + free_okt(mod); + return NULL; + } - chunk = get_chunk_by_type(mod, DUMB_ID('P','A','T','T'), 0); + chunk = get_chunk_by_type(mod, DUMB_ID('P', 'A', 'T', 'T'), 0); if (!chunk || chunk->size < (unsigned)sigdata->n_orders) { - _dumb_it_unload_sigdata(sigdata); - free_okt(mod); - return NULL; - } + _dumb_it_unload_sigdata(sigdata); + free_okt(mod); + return NULL; + } - sigdata->order = (unsigned char *) malloc(sigdata->n_orders); - if (!sigdata->order) { - _dumb_it_unload_sigdata(sigdata); - free_okt(mod); - return NULL; - } + sigdata->order = (unsigned char *)malloc(sigdata->n_orders); + if (!sigdata->order) { + _dumb_it_unload_sigdata(sigdata); + free_okt(mod); + return NULL; + } - memcpy(sigdata->order, chunk->data, sigdata->n_orders); + memcpy(sigdata->order, chunk->data, sigdata->n_orders); - /* Work out how many patterns there are. */ - chunk = get_chunk_by_type(mod, DUMB_ID('S','L','E','N'), 0); - if (!chunk || chunk->size < 2) { - _dumb_it_unload_sigdata(sigdata); - free_okt(mod); - return NULL; - } + /* Work out how many patterns there are. */ + chunk = get_chunk_by_type(mod, DUMB_ID('S', 'L', 'E', 'N'), 0); + if (!chunk || chunk->size < 2) { + _dumb_it_unload_sigdata(sigdata); + free_okt(mod); + return NULL; + } - sigdata->n_patterns = (chunk->data[0] << 8) | chunk->data[1]; + sigdata->n_patterns = (chunk->data[0] << 8) | chunk->data[1]; - j = get_chunk_count(mod, DUMB_ID('P','B','O','D')); - if (sigdata->n_patterns > j) sigdata->n_patterns = j; + j = get_chunk_count(mod, DUMB_ID('P', 'B', 'O', 'D')); + if (sigdata->n_patterns > j) + sigdata->n_patterns = j; - if (!sigdata->n_patterns) { - _dumb_it_unload_sigdata(sigdata); - free_okt(mod); - return NULL; - } + if (!sigdata->n_patterns) { + _dumb_it_unload_sigdata(sigdata); + free_okt(mod); + return NULL; + } - sigdata->pattern = (IT_PATTERN *) malloc(sigdata->n_patterns * sizeof(*sigdata->pattern)); - if (!sigdata->pattern) { - _dumb_it_unload_sigdata(sigdata); - free_okt(mod); - return NULL; - } - for (i = 0; i < sigdata->n_patterns; i++) - sigdata->pattern[i].entry = NULL; + sigdata->pattern = + (IT_PATTERN *)malloc(sigdata->n_patterns * sizeof(*sigdata->pattern)); + if (!sigdata->pattern) { + _dumb_it_unload_sigdata(sigdata); + free_okt(mod); + return NULL; + } + for (i = 0; i < sigdata->n_patterns; i++) + sigdata->pattern[i].entry = NULL; - /* Read in the patterns */ - for (i = 0; i < sigdata->n_patterns; i++) { - chunk = get_chunk_by_type(mod, DUMB_ID('P','B','O','D'), i); - if (it_okt_read_pattern(&sigdata->pattern[i], chunk->data, chunk->size, n_channels) != 0) { - _dumb_it_unload_sigdata(sigdata); - free_okt(mod); - return NULL; - } - } + /* Read in the patterns */ + for (i = 0; i < sigdata->n_patterns; i++) { + chunk = get_chunk_by_type(mod, DUMB_ID('P', 'B', 'O', 'D'), i); + if (it_okt_read_pattern(&sigdata->pattern[i], chunk->data, chunk->size, + n_channels) != 0) { + _dumb_it_unload_sigdata(sigdata); + free_okt(mod); + return NULL; + } + } - /* And finally, the sample data */ - k = get_chunk_count(mod, DUMB_ID('S','B','O','D')); - for (i = 0, j = 0; i < sigdata->n_samples && j < k; i++) { - if (sigdata->sample[i].flags & IT_SAMPLE_EXISTS) { - chunk = get_chunk_by_type(mod, DUMB_ID('S','B','O','D'), j); - if (it_okt_read_sample_data(&sigdata->sample[i], (const char *)chunk->data, chunk->size)) { - _dumb_it_unload_sigdata(sigdata); - free_okt(mod); - return NULL; - } - j++; - } - } - for (; i < sigdata->n_samples; i++) { - sigdata->sample[i].flags = 0; - } + /* And finally, the sample data */ + k = get_chunk_count(mod, DUMB_ID('S', 'B', 'O', 'D')); + for (i = 0, j = 0; i < sigdata->n_samples && j < k; i++) { + if (sigdata->sample[i].flags & IT_SAMPLE_EXISTS) { + chunk = get_chunk_by_type(mod, DUMB_ID('S', 'B', 'O', 'D'), j); + if (it_okt_read_sample_data(&sigdata->sample[i], + (const char *)chunk->data, + chunk->size)) { + _dumb_it_unload_sigdata(sigdata); + free_okt(mod); + return NULL; + } + j++; + } + } + for (; i < sigdata->n_samples; i++) { + sigdata->sample[i].flags = 0; + } - chunk = get_chunk_by_type(mod, DUMB_ID('C','M','O','D'), 0); + chunk = get_chunk_by_type(mod, DUMB_ID('C', 'M', 'O', 'D'), 0); - for (i = 0, j = 0; i < n_channels && j < 4; j++) { - k = (chunk->data[j * 2] << 8) | chunk->data[j * 2 + 1]; - l = (j == 1 || j == 2) ? 48 : 16; - if (k == 0) { - sigdata->channel_pan[i++] = l; - } - else if (k == 1) { - sigdata->channel_pan[i++] = l; - sigdata->channel_pan[i++] = l; - } - } + for (i = 0, j = 0; i < n_channels && j < 4; j++) { + k = (chunk->data[j * 2] << 8) | chunk->data[j * 2 + 1]; + l = (j == 1 || j == 2) ? 48 : 16; + if (k == 0) { + sigdata->channel_pan[i++] = l; + } else if (k == 1) { + sigdata->channel_pan[i++] = l; + sigdata->channel_pan[i++] = l; + } + } - free_okt(mod); + free_okt(mod); - /* Now let's initialise the remaining variables, and we're done! */ - sigdata->flags = IT_WAS_AN_OKT | IT_WAS_AN_XM | IT_WAS_A_MOD | IT_OLD_EFFECTS | IT_COMPATIBLE_GXX | IT_STEREO; + /* Now let's initialise the remaining variables, and we're done! */ + sigdata->flags = IT_WAS_AN_OKT | IT_WAS_AN_XM | IT_WAS_A_MOD | + IT_OLD_EFFECTS | IT_COMPATIBLE_GXX | IT_STEREO; - sigdata->global_volume = 128; - sigdata->mixing_volume = 48; - /* We want 50 ticks per second; 50/6 row advances per second; - * 50*10=500 row advances per minute; 500/4=125 beats per minute. - */ - sigdata->tempo = 125; - sigdata->pan_separation = 128; + sigdata->global_volume = 128; + sigdata->mixing_volume = 48; + /* We want 50 ticks per second; 50/6 row advances per second; + * 50*10=500 row advances per minute; 500/4=125 beats per minute. + */ + sigdata->tempo = 125; + sigdata->pan_separation = 128; - memset(sigdata->channel_volume, 64, DUMB_IT_N_CHANNELS); - memset(sigdata->channel_pan + n_channels, 32, DUMB_IT_N_CHANNELS - n_channels); + memset(sigdata->channel_volume, 64, DUMB_IT_N_CHANNELS); + memset(sigdata->channel_pan + n_channels, 32, + DUMB_IT_N_CHANNELS - n_channels); - _dumb_it_fix_invalid_orders(sigdata); + _dumb_it_fix_invalid_orders(sigdata); - return sigdata; + return sigdata; } +DUH *dumb_read_okt_quick(DUMBFILE *f) { + sigdata_t *sigdata; - -DUH *dumb_read_okt_quick(DUMBFILE *f) -{ - sigdata_t *sigdata; - - DUH_SIGTYPE_DESC *descptr = &_dumb_sigtype_it; + DUH_SIGTYPE_DESC *descptr = &_dumb_sigtype_it; sigdata = it_okt_load_sigdata(f); - if (!sigdata) - return NULL; + if (!sigdata) + return NULL; - { - const char *tag[1][2]; - tag[0][0] = "FORMAT"; - tag[0][1] = "Oktalyzer"; - return make_duh(-1, 1, (const char *const (*)[2])tag, 1, &descptr, &sigdata); - } + { + const char *tag[1][2]; + tag[0][0] = "FORMAT"; + tag[0][1] = "Oktalyzer"; + return make_duh(-1, 1, (const char *const(*)[2])tag, 1, &descptr, + &sigdata); + } } diff --git a/Frameworks/Dumb/dumb/src/it/readokt2.c b/Frameworks/Dumb/dumb/src/it/readokt2.c index c3fc5ed57..dca436996 100644 --- a/Frameworks/Dumb/dumb/src/it/readokt2.c +++ b/Frameworks/Dumb/dumb/src/it/readokt2.c @@ -19,11 +19,8 @@ #include "dumb.h" - - -DUH *dumb_read_okt(DUMBFILE *f) -{ - DUH *duh = dumb_read_okt_quick(f); - dumb_it_do_initial_runthrough(duh); - return duh; +DUH *dumb_read_okt(DUMBFILE *f) { + DUH *duh = dumb_read_okt_quick(f); + dumb_it_do_initial_runthrough(duh); + return duh; } diff --git a/Frameworks/Dumb/dumb/src/it/readoldpsm.c b/Frameworks/Dumb/dumb/src/it/readoldpsm.c index 48f4d9e48..533ab53a3 100644 --- a/Frameworks/Dumb/dumb/src/it/readoldpsm.c +++ b/Frameworks/Dumb/dumb/src/it/readoldpsm.c @@ -24,671 +24,721 @@ #include "dumb.h" #include "internal/it.h" -static int psm_sample_compare(const void *e1, const void *e2) -{ - const unsigned char * pa = e1; - const unsigned char * pb = e2; - int a = pa[37] | (pa[38] << 8) | (pa[39] << 16) | (pa[40] << 24); - int b = pb[37] | (pb[38] << 8) | (pb[39] << 16) | (pb[40] << 24); - return a - b; +static int psm_sample_compare(const void *e1, const void *e2) { + const unsigned char *pa = e1; + const unsigned char *pb = e2; + int a = pa[37] | (pa[38] << 8) | (pa[39] << 16) | (pa[40] << 24); + int b = pb[37] | (pb[38] << 8) | (pb[39] << 16) | (pb[40] << 24); + return a - b; } -static int it_old_psm_read_samples(IT_SAMPLE ** sample, DUMBFILE * f, int * num) -{ +static int it_old_psm_read_samples(IT_SAMPLE **sample, DUMBFILE *f, int *num) { int n, o, count = *num, true_num, snum, offset, flags, finetune, delta; - unsigned char * buffer; - const unsigned char * sdata; + unsigned char *buffer; + const unsigned char *sdata; long sample_bytes; - buffer = malloc(count * 64); - if (!buffer) goto error; + buffer = malloc(count * 64); + if (!buffer) + goto error; - if (dumbfile_getnc((char *)buffer, count * 64, f) < count * 64) goto error_fb; + if (dumbfile_getnc((char *)buffer, count * 64, f) < count * 64) + goto error_fb; - true_num = 0; + true_num = 0; - for (n = 0; n < count; n++) { - snum = buffer[(n * 64) + 45] | (buffer[(n * 64) + 46] << 8); - if ((snum < 1) || (snum > 255)) goto error_fb; - if (true_num < snum) true_num = snum; - } + for (n = 0; n < count; n++) { + snum = buffer[(n * 64) + 45] | (buffer[(n * 64) + 46] << 8); + if ((snum < 1) || (snum > 255)) + goto error_fb; + if (true_num < snum) + true_num = snum; + } - if (true_num > count) { - IT_SAMPLE * meh = realloc(*sample, true_num * sizeof(*meh)); - if (!meh) goto error_fb; - for (n = count; n < true_num; n++) { - meh[n].data = NULL; - } - *sample = meh; - *num = true_num; - } + if (true_num > count) { + IT_SAMPLE *meh = realloc(*sample, true_num * sizeof(*meh)); + if (!meh) + goto error_fb; + for (n = count; n < true_num; n++) { + meh[n].data = NULL; + } + *sample = meh; + *num = true_num; + } - qsort(buffer, count, 64, &psm_sample_compare); + qsort(buffer, count, 64, &psm_sample_compare); - for (n = 0; n < *num; n++) { - (*sample)[n].flags = 0; - } + for (n = 0; n < *num; n++) { + (*sample)[n].flags = 0; + } - for (n = 0; n < count; n++) { - IT_SAMPLE smp; - IT_SAMPLE * s; - snum = buffer[(n * 64) + 45] | (buffer[(n * 64) + 46] << 8); - s = &((*sample)[snum - 1]); - memcpy(smp.filename, buffer + (n * 64), 13); - smp.filename[13] = 0; - memcpy(smp.name, buffer + (n * 64) + 13, 24); - smp.name[24] = 0; - offset = buffer[(n * 64) + 37] | (buffer[(n * 64) + 38] << 8) | - (buffer[(n * 64) + 39] << 16) | (buffer[(n * 64) + 40] << 24); - flags = buffer[(n * 64) + 47]; - smp.length = buffer[(n * 64) + 48] | (buffer[(n * 64) + 49] << 8) | - (buffer[(n * 64) + 50] << 16) | (buffer[(n * 64) + 51] << 24); - smp.loop_start = buffer[(n * 64) + 52] | (buffer[(n * 64) + 53] << 8) | - (buffer[(n * 64) + 54] << 16) | (buffer[(n * 64) + 55] << 24); - smp.loop_end = buffer[(n * 64) + 56] | (buffer[(n * 64) + 57] << 8) | - (buffer[(n * 64) + 58] << 16) | (buffer[(n * 64) + 59] << 24); + for (n = 0; n < count; n++) { + IT_SAMPLE smp; + IT_SAMPLE *s; + snum = buffer[(n * 64) + 45] | (buffer[(n * 64) + 46] << 8); + s = &((*sample)[snum - 1]); + memcpy(smp.filename, buffer + (n * 64), 13); + smp.filename[13] = 0; + memcpy(smp.name, buffer + (n * 64) + 13, 24); + smp.name[24] = 0; + offset = buffer[(n * 64) + 37] | (buffer[(n * 64) + 38] << 8) | + (buffer[(n * 64) + 39] << 16) | (buffer[(n * 64) + 40] << 24); + flags = buffer[(n * 64) + 47]; + smp.length = buffer[(n * 64) + 48] | (buffer[(n * 64) + 49] << 8) | + (buffer[(n * 64) + 50] << 16) | + (buffer[(n * 64) + 51] << 24); + smp.loop_start = buffer[(n * 64) + 52] | (buffer[(n * 64) + 53] << 8) | + (buffer[(n * 64) + 54] << 16) | + (buffer[(n * 64) + 55] << 24); + smp.loop_end = buffer[(n * 64) + 56] | (buffer[(n * 64) + 57] << 8) | + (buffer[(n * 64) + 58] << 16) | + (buffer[(n * 64) + 59] << 24); - if (smp.length <= 0) continue; + if (smp.length <= 0) + continue; - finetune = buffer[(n * 64) + 60]; - smp.default_volume = buffer[(n * 64) + 61]; - smp.C5_speed = buffer[(n * 64) + 62] | (buffer[(n * 64) + 63] << 8); - if (finetune & 15) { - finetune &= 15; - if (finetune >= 8) finetune -= 16; - //s->C5_speed = (long)((double)s->C5_speed * pow(DUMB_PITCH_BASE, finetune*32)); - smp.finetune = finetune * 32; - } - else smp.finetune = 0; + finetune = buffer[(n * 64) + 60]; + smp.default_volume = buffer[(n * 64) + 61]; + smp.C5_speed = buffer[(n * 64) + 62] | (buffer[(n * 64) + 63] << 8); + if (finetune & 15) { + finetune &= 15; + if (finetune >= 8) + finetune -= 16; + // s->C5_speed = (long)((double)s->C5_speed * pow(DUMB_PITCH_BASE, + // finetune*32)); + smp.finetune = finetune * 32; + } else + smp.finetune = 0; - smp.flags |= IT_SAMPLE_EXISTS; - if (flags & 0x41) - continue; - if (flags & 0x20) smp.flags |= IT_SAMPLE_PINGPONG_LOOP; - if (flags & 4) smp.flags |= IT_SAMPLE_16BIT; + smp.flags |= IT_SAMPLE_EXISTS; + if (flags & 0x41) + continue; + if (flags & 0x20) + smp.flags |= IT_SAMPLE_PINGPONG_LOOP; + if (flags & 4) + smp.flags |= IT_SAMPLE_16BIT; - if (flags & 0x80) { - smp.flags |= IT_SAMPLE_LOOP; - if ((unsigned int)smp.loop_end > (unsigned int)smp.length) - smp.loop_end = smp.length; - else if ((unsigned int)smp.loop_start >= (unsigned int)smp.loop_end) - smp.flags &= ~IT_SAMPLE_LOOP; - else - smp.length = smp.loop_end; - } + if (flags & 0x80) { + smp.flags |= IT_SAMPLE_LOOP; + if ((unsigned int)smp.loop_end > (unsigned int)smp.length) + smp.loop_end = smp.length; + else if ((unsigned int)smp.loop_start >= (unsigned int)smp.loop_end) + smp.flags &= ~IT_SAMPLE_LOOP; + else + smp.length = smp.loop_end; + } - smp.global_volume = 64; + smp.global_volume = 64; - smp.vibrato_speed = 0; - smp.vibrato_depth = 0; - smp.vibrato_rate = 0; - smp.vibrato_waveform = IT_VIBRATO_SINE; - smp.max_resampling_quality = -1; + smp.vibrato_speed = 0; + smp.vibrato_depth = 0; + smp.vibrato_rate = 0; + smp.vibrato_waveform = IT_VIBRATO_SINE; + smp.max_resampling_quality = -1; sample_bytes = smp.length * ((flags & 4) ? 2 : 1); smp.data = malloc(sample_bytes); - if (!smp.data) goto error_fb; - sdata = (const unsigned char *) smp.data; + if (!smp.data) + goto error_fb; + sdata = (const unsigned char *)smp.data; - if (dumbfile_seek(f, offset, DFS_SEEK_SET) || dumbfile_getnc(smp.data, sample_bytes, f) < sample_bytes) goto error_fd; + if (dumbfile_seek(f, offset, DFS_SEEK_SET) || + dumbfile_getnc(smp.data, sample_bytes, f) < sample_bytes) + goto error_fd; - if (flags & 0x10) { - if (flags & 8) { - if (flags & 4) { - for (o = 0; o < smp.length; o++) - ((short *)smp.data)[o] = (sdata[o * 2] | (sdata[(o * 2) + 1] << 8)) ^ 0x8000; - } else { - for (o = 0; o < smp.length; o++) - ((signed char *)smp.data)[o] = sdata[o] ^ 0x80; - } - } else { - if (flags & 4) { - for (o = 0; o < smp.length; o++) - ((short *)smp.data)[o] = sdata[o * 2] | (sdata[(o * 2) + 1] << 8); - } else { - memcpy(smp.data, sdata, smp.length); - } - } - } else { - delta = 0; - if (flags & 8) { - /* unsigned delta? mehhh, does anything even use this? */ - if (flags & 4) { - for (o = 0; o < smp.length; o++) { - delta += (short)(sdata[o * 2] | (sdata[(o * 2) + 1] << 8)); - ((short *)smp.data)[o] = delta ^ 0x8000; - } - } else { - for (o = 0; o < smp.length; o++) { - delta += (signed char)sdata[o]; - ((signed char *)smp.data)[o] = delta ^ 0x80; - } - } - } else { - if (flags & 4) { - for (o = 0; o < smp.length; o++) { - delta += (signed short)(sdata[o * 2] | (sdata[(o * 2) + 1] << 8)); - ((signed short *)smp.data)[o] = delta; - } - } else { - for (o = 0; o < smp.length; o++) { - delta += (signed char)sdata[o]; - ((signed char *)smp.data)[o] = delta; - } - } - } - } - - if (s->data) free(s->data); - *s = smp; - } + if (flags & 0x10) { + if (flags & 8) { + if (flags & 4) { + for (o = 0; o < smp.length; o++) + ((short *)smp.data)[o] = + (sdata[o * 2] | (sdata[(o * 2) + 1] << 8)) ^ 0x8000; + } else { + for (o = 0; o < smp.length; o++) + ((signed char *)smp.data)[o] = sdata[o] ^ 0x80; + } + } else { + if (flags & 4) { + for (o = 0; o < smp.length; o++) + ((short *)smp.data)[o] = + sdata[o * 2] | (sdata[(o * 2) + 1] << 8); + } else { + memcpy(smp.data, sdata, smp.length); + } + } + } else { + delta = 0; + if (flags & 8) { + /* unsigned delta? mehhh, does anything even use this? */ + if (flags & 4) { + for (o = 0; o < smp.length; o++) { + delta += + (short)(sdata[o * 2] | (sdata[(o * 2) + 1] << 8)); + ((short *)smp.data)[o] = delta ^ 0x8000; + } + } else { + for (o = 0; o < smp.length; o++) { + delta += (signed char)sdata[o]; + ((signed char *)smp.data)[o] = delta ^ 0x80; + } + } + } else { + if (flags & 4) { + for (o = 0; o < smp.length; o++) { + delta += (signed short)(sdata[o * 2] | + (sdata[(o * 2) + 1] << 8)); + ((signed short *)smp.data)[o] = delta; + } + } else { + for (o = 0; o < smp.length; o++) { + delta += (signed char)sdata[o]; + ((signed char *)smp.data)[o] = delta; + } + } + } + } - free(buffer); + if (s->data) + free(s->data); + *s = smp; + } - return 0; + free(buffer); + + return 0; error_fd: - free((void *)sdata); + free((void *)sdata); error_fb: - free(buffer); + free(buffer); error: - return -1; + return -1; } -static int it_old_psm_read_patterns(IT_PATTERN * pattern, DUMBFILE * f, int num, int size, int pchans) -{ - int n, offset, psize, rows, chans, row, flags, channel; +static int it_old_psm_read_patterns(IT_PATTERN *pattern, DUMBFILE *f, int num, + int size, int pchans) { + int n, offset, psize, rows, chans, row, flags, channel; - unsigned char * buffer, * ptr, * end; + unsigned char *buffer, *ptr, *end; - IT_ENTRY * entry; + IT_ENTRY *entry; - buffer = malloc(size); - if (!buffer) goto error; + buffer = malloc(size); + if (!buffer) + goto error; - if (dumbfile_getnc((char *)buffer, size, f) < size) goto error_fb; + if (dumbfile_getnc((char *)buffer, size, f) < size) + goto error_fb; - offset = 0; + offset = 0; - for (n = 0; n < num; n++) { - IT_PATTERN * p = &pattern[n]; + for (n = 0; n < num; n++) { + IT_PATTERN *p = &pattern[n]; - if (offset >= size) goto error_fb; + if (offset >= size) + goto error_fb; - ptr = buffer + offset; - psize = ptr[0] | (ptr[1] << 8); - rows = ptr[2]; - chans = ptr[3]; + ptr = buffer + offset; + psize = ptr[0] | (ptr[1] << 8); + rows = ptr[2]; + chans = ptr[3]; - if (!rows || !chans) { - p->n_rows = 1; - p->n_entries = 0; - continue; - } + if (!rows || !chans) { + p->n_rows = 1; + p->n_entries = 0; + continue; + } - psize = (psize + 15) & ~15; - - if (offset + psize > size) goto error_fb; + psize = (psize + 15) & ~15; - end = ptr + psize; - ptr += 4; + if (offset + psize > size) + goto error_fb; - p->n_rows = rows; - p->n_entries = rows; - row = 0; + end = ptr + psize; + ptr += 4; - while ((row < rows) && (ptr < end)) { - flags = *ptr++; - if (!flags) { - row++; - continue; - } - if (flags & 0xE0) { - p->n_entries++; - if (flags & 0x80) ptr += 2; - if (flags & 0x40) ptr++; - if (flags & 0x20) { - if (*ptr == 40) ptr += 4; - else ptr += 2; - } - } - } + p->n_rows = rows; + p->n_entries = rows; + row = 0; - entry = malloc(p->n_entries * sizeof(*p->entry)); - if (!entry) goto error_fb; + while ((row < rows) && (ptr < end)) { + flags = *ptr++; + if (!flags) { + row++; + continue; + } + if (flags & 0xE0) { + p->n_entries++; + if (flags & 0x80) + ptr += 2; + if (flags & 0x40) + ptr++; + if (flags & 0x20) { + if (*ptr == 40) + ptr += 4; + else + ptr += 2; + } + } + } - p->entry = entry; + entry = malloc(p->n_entries * sizeof(*p->entry)); + if (!entry) + goto error_fb; - ptr = buffer + offset + 4; - row = 0; + p->entry = entry; - while ((row < rows) && (ptr < end)) { - flags = *ptr++; - if (!flags) { - IT_SET_END_ROW(entry); - entry++; - row++; - continue; - } - if (flags & 0xE0) { - entry->mask = 0; - entry->channel = channel = flags & 0x1F; - if (channel >= chans) - { - //channel = 0; - //goto error_fb; - } - if (flags & 0x80) { - if ((*ptr < 60) && (channel < pchans)) { - entry->mask |= IT_ENTRY_NOTE; - entry->note = *ptr + 35; - } - ptr++; - if (*ptr) { - entry->mask |= IT_ENTRY_INSTRUMENT; - entry->instrument = *ptr; - } - ptr++; - } - if (flags & 0x40) { - if (*ptr <= 64) { - entry->mask |= IT_ENTRY_VOLPAN; - entry->volpan = *ptr; - } - ptr++; - } - if (flags & 0x20) { - entry->mask |= IT_ENTRY_EFFECT; + ptr = buffer + offset + 4; + row = 0; - switch (*ptr) { - case 1: - entry->effect = IT_XM_FINE_VOLSLIDE_UP; - entry->effectvalue = ptr[1]; - break; + while ((row < rows) && (ptr < end)) { + flags = *ptr++; + if (!flags) { + IT_SET_END_ROW(entry); + entry++; + row++; + continue; + } + if (flags & 0xE0) { + entry->mask = 0; + entry->channel = channel = flags & 0x1F; + if (channel >= chans) { + // channel = 0; + // goto error_fb; + } + if (flags & 0x80) { + if ((*ptr < 60) && (channel < pchans)) { + entry->mask |= IT_ENTRY_NOTE; + entry->note = *ptr + 35; + } + ptr++; + if (*ptr) { + entry->mask |= IT_ENTRY_INSTRUMENT; + entry->instrument = *ptr; + } + ptr++; + } + if (flags & 0x40) { + if (*ptr <= 64) { + entry->mask |= IT_ENTRY_VOLPAN; + entry->volpan = *ptr; + } + ptr++; + } + if (flags & 0x20) { + entry->mask |= IT_ENTRY_EFFECT; - case 2: - entry->effect = IT_VOLUME_SLIDE; - entry->effectvalue = (ptr[1] << 4) & 0xF0; - break; + switch (*ptr) { + case 1: + entry->effect = IT_XM_FINE_VOLSLIDE_UP; + entry->effectvalue = ptr[1]; + break; - case 3: - entry->effect = IT_XM_FINE_VOLSLIDE_DOWN; - entry->effectvalue = ptr[1]; - break; + case 2: + entry->effect = IT_VOLUME_SLIDE; + entry->effectvalue = (ptr[1] << 4) & 0xF0; + break; - case 4: - entry->effect = IT_VOLUME_SLIDE; - entry->effectvalue = ptr[1] & 0xF; - break; + case 3: + entry->effect = IT_XM_FINE_VOLSLIDE_DOWN; + entry->effectvalue = ptr[1]; + break; - case 10: - entry->effect = IT_PORTAMENTO_UP; - entry->effectvalue = EFFECT_VALUE(0xF, ptr[1]); - break; + case 4: + entry->effect = IT_VOLUME_SLIDE; + entry->effectvalue = ptr[1] & 0xF; + break; - case 11: - entry->effect = IT_PORTAMENTO_UP; - entry->effectvalue = ptr[1]; - break; + case 10: + entry->effect = IT_PORTAMENTO_UP; + entry->effectvalue = EFFECT_VALUE(0xF, ptr[1]); + break; - case 12: - entry->effect = IT_PORTAMENTO_DOWN; - entry->effectvalue = EFFECT_VALUE(ptr[1], 0xF); - break; + case 11: + entry->effect = IT_PORTAMENTO_UP; + entry->effectvalue = ptr[1]; + break; - case 13: - entry->effect = IT_PORTAMENTO_DOWN; - entry->effectvalue = ptr[1]; - break; + case 12: + entry->effect = IT_PORTAMENTO_DOWN; + entry->effectvalue = EFFECT_VALUE(ptr[1], 0xF); + break; - case 14: - entry->effect = IT_TONE_PORTAMENTO; - entry->effectvalue = ptr[1]; - break; + case 13: + entry->effect = IT_PORTAMENTO_DOWN; + entry->effectvalue = ptr[1]; + break; - case 15: - entry->effect = IT_S; - entry->effectvalue = EFFECT_VALUE(IT_S_SET_GLISSANDO_CONTROL, ptr[1] & 15); - break; + case 14: + entry->effect = IT_TONE_PORTAMENTO; + entry->effectvalue = ptr[1]; + break; - case 16: - entry->effect = IT_VOLSLIDE_TONEPORTA; - entry->effectvalue = ptr[1] << 4; - break; + case 15: + entry->effect = IT_S; + entry->effectvalue = EFFECT_VALUE( + IT_S_SET_GLISSANDO_CONTROL, ptr[1] & 15); + break; - case 17: - entry->effect = IT_VOLSLIDE_TONEPORTA; - entry->effectvalue = ptr[1] & 0xF; - break; + case 16: + entry->effect = IT_VOLSLIDE_TONEPORTA; + entry->effectvalue = ptr[1] << 4; + break; - case 20: - entry->effect = IT_VIBRATO; - entry->effectvalue = ptr[1]; - break; + case 17: + entry->effect = IT_VOLSLIDE_TONEPORTA; + entry->effectvalue = ptr[1] & 0xF; + break; - case 21: - entry->effect = IT_S; - entry->effectvalue = EFFECT_VALUE(IT_S_SET_VIBRATO_WAVEFORM, ptr[1] & 11); - break; + case 20: + entry->effect = IT_VIBRATO; + entry->effectvalue = ptr[1]; + break; - case 22: - entry->effect = IT_VOLSLIDE_VIBRATO; - entry->effectvalue = ptr[1] << 4; - break; + case 21: + entry->effect = IT_S; + entry->effectvalue = EFFECT_VALUE( + IT_S_SET_VIBRATO_WAVEFORM, ptr[1] & 11); + break; - case 23: - entry->effect = IT_VOLSLIDE_VIBRATO; - entry->effectvalue = ptr[1] & 0xF; - break; + case 22: + entry->effect = IT_VOLSLIDE_VIBRATO; + entry->effectvalue = ptr[1] << 4; + break; - case 30: - entry->effect = IT_TREMOLO; - entry->effectvalue = ptr[1]; - break; + case 23: + entry->effect = IT_VOLSLIDE_VIBRATO; + entry->effectvalue = ptr[1] & 0xF; + break; - case 31: - entry->effect = IT_S; - entry->effectvalue = EFFECT_VALUE(IT_S_SET_TREMOLO_WAVEFORM, ptr[1] & 11); - break; + case 30: + entry->effect = IT_TREMOLO; + entry->effectvalue = ptr[1]; + break; - case 40: - entry->effect = IT_SET_SAMPLE_OFFSET; - entry->effectvalue = ptr[2]; - ptr += 2; - break; + case 31: + entry->effect = IT_S; + entry->effectvalue = EFFECT_VALUE( + IT_S_SET_TREMOLO_WAVEFORM, ptr[1] & 11); + break; - case 41: - entry->effect = IT_XM_RETRIGGER_NOTE; - entry->effectvalue = ptr[1]; - break; + case 40: + entry->effect = IT_SET_SAMPLE_OFFSET; + entry->effectvalue = ptr[2]; + ptr += 2; + break; - case 42: - entry->effect = IT_S; - entry->effectvalue = EFFECT_VALUE(IT_S_DELAYED_NOTE_CUT, ptr[1] & 0xF); - break; + case 41: + entry->effect = IT_XM_RETRIGGER_NOTE; + entry->effectvalue = ptr[1]; + break; - case 43: - entry->effect = IT_S; - entry->effectvalue = EFFECT_VALUE(IT_S_NOTE_DELAY, ptr[1] & 0xF); - break; + case 42: + entry->effect = IT_S; + entry->effectvalue = + EFFECT_VALUE(IT_S_DELAYED_NOTE_CUT, ptr[1] & 0xF); + break; - case 50: - entry->effect = IT_JUMP_TO_ORDER; - entry->effectvalue = ptr[1]; - break; + case 43: + entry->effect = IT_S; + entry->effectvalue = + EFFECT_VALUE(IT_S_NOTE_DELAY, ptr[1] & 0xF); + break; - case 51: - entry->effect = IT_BREAK_TO_ROW; - entry->effectvalue = ptr[1]; - break; + case 50: + entry->effect = IT_JUMP_TO_ORDER; + entry->effectvalue = ptr[1]; + break; - case 52: - entry->effect = IT_S; - entry->effectvalue = EFFECT_VALUE(IT_S_PATTERN_LOOP, ptr[1] & 0xF); - break; + case 51: + entry->effect = IT_BREAK_TO_ROW; + entry->effectvalue = ptr[1]; + break; - case 53: - entry->effect = IT_S; - entry->effectvalue = EFFECT_VALUE(IT_S_PATTERN_DELAY, ptr[1] & 0xF); - break; + case 52: + entry->effect = IT_S; + entry->effectvalue = + EFFECT_VALUE(IT_S_PATTERN_LOOP, ptr[1] & 0xF); + break; - case 60: - entry->effect = IT_SET_SPEED; - entry->effectvalue = ptr[1]; - break; + case 53: + entry->effect = IT_S; + entry->effectvalue = + EFFECT_VALUE(IT_S_PATTERN_DELAY, ptr[1] & 0xF); + break; - case 61: - entry->effect = IT_SET_SONG_TEMPO; - entry->effectvalue = ptr[1]; - break; + case 60: + entry->effect = IT_SET_SPEED; + entry->effectvalue = ptr[1]; + break; - case 70: - entry->effect = IT_ARPEGGIO; - entry->effectvalue = ptr[1]; - break; + case 61: + entry->effect = IT_SET_SONG_TEMPO; + entry->effectvalue = ptr[1]; + break; - case 71: - entry->effect = IT_S; - entry->effectvalue = EFFECT_VALUE(IT_S_FINETUNE, ptr[1] & 0xF); - break; + case 70: + entry->effect = IT_ARPEGGIO; + entry->effectvalue = ptr[1]; + break; - case 72: - /* "balance" ... panning? */ - entry->effect = IT_SET_PANNING; - entry->effectvalue = ((ptr[1] - ((ptr[1] & 8) >> 3)) << 5) / 7; - break; + case 71: + entry->effect = IT_S; + entry->effectvalue = + EFFECT_VALUE(IT_S_FINETUNE, ptr[1] & 0xF); + break; - default: - entry->mask &= ~IT_ENTRY_EFFECT; - } + case 72: + /* "balance" ... panning? */ + entry->effect = IT_SET_PANNING; + entry->effectvalue = + ((ptr[1] - ((ptr[1] & 8) >> 3)) << 5) / 7; + break; - ptr += 2; - } - if (entry->mask) entry++; - } - } + default: + entry->mask &= ~IT_ENTRY_EFFECT; + } - p->n_entries = (int)(entry - p->entry); - offset += psize; - } + ptr += 2; + } + if (entry->mask) + entry++; + } + } - free(buffer); + p->n_entries = (int)(entry - p->entry); + offset += psize; + } - return 0; + free(buffer); + + return 0; error_fb: - free(buffer); + free(buffer); error: - return -1; + return -1; } -#define PSM_COMPONENT_ORDERS 0 -#define PSM_COMPONENT_PANPOS 1 -#define PSM_COMPONENT_PATTERNS 2 -#define PSM_COMPONENT_SAMPLE_HEADERS 3 -#define PSM_COMPONENT_COMMENTS 4 +#define PSM_COMPONENT_ORDERS 0 +#define PSM_COMPONENT_PANPOS 1 +#define PSM_COMPONENT_PATTERNS 2 +#define PSM_COMPONENT_SAMPLE_HEADERS 3 +#define PSM_COMPONENT_COMMENTS 4 -typedef struct PSM_COMPONENT -{ - unsigned char type; - long offset; -} -PSM_COMPONENT; +typedef struct PSM_COMPONENT { + unsigned char type; + long offset; +} PSM_COMPONENT; -static int psm_component_compare(const void *e1, const void *e2) -{ - return (int)(((const PSM_COMPONENT *)e1)->offset - - ((const PSM_COMPONENT *)e2)->offset); +static int psm_component_compare(const void *e1, const void *e2) { + return (int)(((const PSM_COMPONENT *)e1)->offset - + ((const PSM_COMPONENT *)e2)->offset); } -static DUMB_IT_SIGDATA *it_old_psm_load_sigdata(DUMBFILE *f) -{ - DUMB_IT_SIGDATA *sigdata; +static DUMB_IT_SIGDATA *it_old_psm_load_sigdata(DUMBFILE *f) { + DUMB_IT_SIGDATA *sigdata; - PSM_COMPONENT *component; - int n_components = 0; + PSM_COMPONENT *component; + int n_components = 0; - int n, flags, version, pver, n_orders, n_channels, total_pattern_size; + int n, flags, version, pver, n_orders, n_channels, total_pattern_size; - if (dumbfile_mgetl(f) != DUMB_ID('P','S','M',254)) goto error; + if (dumbfile_mgetl(f) != DUMB_ID('P', 'S', 'M', 254)) + goto error; - sigdata = malloc(sizeof(*sigdata)); - if (!sigdata) goto error; + sigdata = malloc(sizeof(*sigdata)); + if (!sigdata) + goto error; if (dumbfile_getnc((char *)sigdata->name, 60, f) < 60 || - sigdata->name[59] != 0x1A) goto error_sd; - sigdata->name[59] = 0; + sigdata->name[59] != 0x1A) + goto error_sd; + sigdata->name[59] = 0; - flags = dumbfile_getc(f); - version = dumbfile_getc(f); - pver = dumbfile_getc(f); - sigdata->speed = dumbfile_getc(f); - sigdata->tempo = dumbfile_getc(f); - sigdata->mixing_volume = dumbfile_getc(f); - sigdata->n_orders = dumbfile_igetw(f); - n_orders = dumbfile_igetw(f); - sigdata->n_patterns = dumbfile_igetw(f); - sigdata->n_samples = dumbfile_igetw(f); - sigdata->n_pchannels = dumbfile_igetw(f); - n_channels = dumbfile_igetw(f); + flags = dumbfile_getc(f); + version = dumbfile_getc(f); + pver = dumbfile_getc(f); + sigdata->speed = dumbfile_getc(f); + sigdata->tempo = dumbfile_getc(f); + sigdata->mixing_volume = dumbfile_getc(f); + sigdata->n_orders = dumbfile_igetw(f); + n_orders = dumbfile_igetw(f); + sigdata->n_patterns = dumbfile_igetw(f); + sigdata->n_samples = dumbfile_igetw(f); + sigdata->n_pchannels = dumbfile_igetw(f); + n_channels = dumbfile_igetw(f); - if (dumbfile_error(f) || - (flags & 1) || - (version != 1 && version != 0x10) || - (pver) || - (sigdata->n_orders <= 0) || - (sigdata->n_orders > 255) || - (n_orders > 255) || - (n_orders < sigdata->n_orders) || - (sigdata->n_patterns > 255) || - (sigdata->n_samples > 255) || - (sigdata->n_pchannels > DUMB_IT_N_CHANNELS) || - (sigdata->n_pchannels > n_channels) || - (n_channels > DUMB_IT_N_CHANNELS)) - goto error_sd; + if (dumbfile_error(f) || (flags & 1) || (version != 1 && version != 0x10) || + (pver) || (sigdata->n_orders <= 0) || (sigdata->n_orders > 255) || + (n_orders > 255) || (n_orders < sigdata->n_orders) || + (sigdata->n_patterns > 255) || (sigdata->n_samples > 255) || + (sigdata->n_pchannels > DUMB_IT_N_CHANNELS) || + (sigdata->n_pchannels > n_channels) || + (n_channels > DUMB_IT_N_CHANNELS)) + goto error_sd; - sigdata->flags = IT_STEREO | IT_OLD_EFFECTS | IT_COMPATIBLE_GXX; + sigdata->flags = IT_STEREO | IT_OLD_EFFECTS | IT_COMPATIBLE_GXX; - sigdata->global_volume = 128; - sigdata->pan_separation = 128; + sigdata->global_volume = 128; + sigdata->pan_separation = 128; - sigdata->song_message = NULL; - sigdata->order = NULL; - sigdata->instrument = NULL; - sigdata->sample = NULL; - sigdata->pattern = NULL; - sigdata->midi = NULL; - sigdata->checkpoint = NULL; + sigdata->song_message = NULL; + sigdata->order = NULL; + sigdata->instrument = NULL; + sigdata->sample = NULL; + sigdata->pattern = NULL; + sigdata->midi = NULL; + sigdata->checkpoint = NULL; - sigdata->n_instruments = 0; + sigdata->n_instruments = 0; - sigdata->restart_position = 0; + sigdata->restart_position = 0; - sigdata->order = malloc(sigdata->n_orders); - if (!sigdata->order) goto error_usd; + sigdata->order = malloc(sigdata->n_orders); + if (!sigdata->order) + goto error_usd; - if (sigdata->n_samples) { - sigdata->sample = malloc(sigdata->n_samples * sizeof(*sigdata->sample)); - if (!sigdata->sample) goto error_usd; - for (n = 0; n < sigdata->n_samples; n++) - sigdata->sample[n].data = NULL; - } + if (sigdata->n_samples) { + sigdata->sample = malloc(sigdata->n_samples * sizeof(*sigdata->sample)); + if (!sigdata->sample) + goto error_usd; + for (n = 0; n < sigdata->n_samples; n++) + sigdata->sample[n].data = NULL; + } - if (sigdata->n_patterns) { - sigdata->pattern = malloc(sigdata->n_patterns * sizeof(*sigdata->pattern)); - if (!sigdata->pattern) goto error_usd; - for (n = 0; n < sigdata->n_patterns; n++) - sigdata->pattern[n].entry = NULL; - } + if (sigdata->n_patterns) { + sigdata->pattern = + malloc(sigdata->n_patterns * sizeof(*sigdata->pattern)); + if (!sigdata->pattern) + goto error_usd; + for (n = 0; n < sigdata->n_patterns; n++) + sigdata->pattern[n].entry = NULL; + } - component = malloc(5 * sizeof(*component)); - if (!component) goto error_usd; + component = malloc(5 * sizeof(*component)); + if (!component) + goto error_usd; - for (n = 0; n < 5; n++) { - component[n_components].offset = dumbfile_igetl(f); - if (component[n_components].offset) { - component[n_components].type = n; - n_components++; - } - } + for (n = 0; n < 5; n++) { + component[n_components].offset = dumbfile_igetl(f); + if (component[n_components].offset) { + component[n_components].type = n; + n_components++; + } + } - if (!n_components) goto error_fc; + if (!n_components) + goto error_fc; - total_pattern_size = (int)dumbfile_igetl(f); - if (!total_pattern_size) goto error_fc; + total_pattern_size = (int)dumbfile_igetl(f); + if (!total_pattern_size) + goto error_fc; - qsort(component, n_components, sizeof(PSM_COMPONENT), &psm_component_compare); + qsort(component, n_components, sizeof(PSM_COMPONENT), + &psm_component_compare); - memset(sigdata->channel_volume, 64, DUMB_IT_N_CHANNELS); + memset(sigdata->channel_volume, 64, DUMB_IT_N_CHANNELS); - for (n = 0; n < DUMB_IT_N_CHANNELS; n += 4) { - int sep = 32 * dumb_it_default_panning_separation / 100; - sigdata->channel_pan[n ] = 32 - sep; - sigdata->channel_pan[n+1] = 32 + sep; - sigdata->channel_pan[n+2] = 32 + sep; - sigdata->channel_pan[n+3] = 32 - sep; - } + for (n = 0; n < DUMB_IT_N_CHANNELS; n += 4) { + int sep = 32 * dumb_it_default_panning_separation / 100; + sigdata->channel_pan[n] = 32 - sep; + sigdata->channel_pan[n + 1] = 32 + sep; + sigdata->channel_pan[n + 2] = 32 + sep; + sigdata->channel_pan[n + 3] = 32 - sep; + } - for (n = 0; n < n_components; n++) - { - int o; + for (n = 0; n < n_components; n++) { + int o; - if ( dumbfile_seek(f, component[n].offset, DFS_SEEK_SET) ) goto error_fc; + if (dumbfile_seek(f, component[n].offset, DFS_SEEK_SET)) + goto error_fc; - switch (component[n].type) { + switch (component[n].type) { - case PSM_COMPONENT_ORDERS: - if (dumbfile_getnc((char *)sigdata->order, sigdata->n_orders, f) < sigdata->n_orders) goto error_fc; - if (n_orders > sigdata->n_orders) - if (dumbfile_skip(f, n_orders - sigdata->n_orders)) + case PSM_COMPONENT_ORDERS: + if (dumbfile_getnc((char *)sigdata->order, sigdata->n_orders, f) < + sigdata->n_orders) + goto error_fc; + if (n_orders > sigdata->n_orders) + if (dumbfile_skip(f, n_orders - sigdata->n_orders)) + goto error_fc; + if (dumbfile_igetw(f)) + goto error_fc; + break; + + case PSM_COMPONENT_PANPOS: + if (dumbfile_getnc((char *)sigdata->channel_pan, + sigdata->n_pchannels, f) < sigdata->n_pchannels) + goto error_fc; + for (o = 0; o < sigdata->n_pchannels; o++) { + sigdata->channel_pan[o] -= (sigdata->channel_pan[o] & 8) >> 3; + sigdata->channel_pan[o] = + ((int)sigdata->channel_pan[o] << 5) / 7; + } + break; + + case PSM_COMPONENT_PATTERNS: + if (it_old_psm_read_patterns( + sigdata->pattern, f, sigdata->n_patterns, + total_pattern_size, sigdata->n_pchannels)) + goto error_fc; + break; + + case PSM_COMPONENT_SAMPLE_HEADERS: + if (it_old_psm_read_samples(&sigdata->sample, f, + &sigdata->n_samples)) + goto error_fc; + break; + + case PSM_COMPONENT_COMMENTS: + if (dumbfile_mgetl(f) == DUMB_ID('T', 'E', 'X', 'T')) { + o = dumbfile_igetw(f); + if (o > 0) { + sigdata->song_message = malloc(o + 1); + if (dumbfile_getnc((char *)sigdata->song_message, o, f) < o) goto error_fc; - if (dumbfile_igetw(f)) goto error_fc; - break; + sigdata->song_message[o] = 0; + } + } + break; + } + } - case PSM_COMPONENT_PANPOS: - if (dumbfile_getnc((char *)sigdata->channel_pan, sigdata->n_pchannels, f) < sigdata->n_pchannels) goto error_fc; - for (o = 0; o < sigdata->n_pchannels; o++) { - sigdata->channel_pan[o] -= (sigdata->channel_pan[o] & 8) >> 3; - sigdata->channel_pan[o] = ((int)sigdata->channel_pan[o] << 5) / 7; - } - break; + _dumb_it_fix_invalid_orders(sigdata); - case PSM_COMPONENT_PATTERNS: - if (it_old_psm_read_patterns(sigdata->pattern, f, sigdata->n_patterns, total_pattern_size, sigdata->n_pchannels)) goto error_fc; - break; + free(component); - case PSM_COMPONENT_SAMPLE_HEADERS: - if (it_old_psm_read_samples(&sigdata->sample, f, &sigdata->n_samples)) goto error_fc; - break; - - case PSM_COMPONENT_COMMENTS: - if (dumbfile_mgetl(f) == DUMB_ID('T','E','X','T')) { - o = dumbfile_igetw(f); - if (o > 0) { - sigdata->song_message = malloc(o + 1); - if (dumbfile_getnc((char *)sigdata->song_message, o, f) < o) goto error_fc; - sigdata->song_message[o] = 0; - } - } - break; - } - } - - _dumb_it_fix_invalid_orders(sigdata); - - free(component); - - return sigdata; + return sigdata; error_fc: - free(component); + free(component); error_usd: - _dumb_it_unload_sigdata(sigdata); - return NULL; + _dumb_it_unload_sigdata(sigdata); + return NULL; error_sd: - free(sigdata); + free(sigdata); error: - return NULL; + return NULL; } -DUH *dumb_read_old_psm_quick(DUMBFILE *f) -{ - sigdata_t *sigdata; +DUH *dumb_read_old_psm_quick(DUMBFILE *f) { + sigdata_t *sigdata; - DUH_SIGTYPE_DESC *descptr = &_dumb_sigtype_it; + DUH_SIGTYPE_DESC *descptr = &_dumb_sigtype_it; - sigdata = it_old_psm_load_sigdata(f); + sigdata = it_old_psm_load_sigdata(f); - if (!sigdata) - return NULL; + if (!sigdata) + return NULL; - { - const char *tag[2][2]; - tag[0][0] = "TITLE"; + { + const char *tag[2][2]; + tag[0][0] = "TITLE"; tag[0][1] = (const char *)(((DUMB_IT_SIGDATA *)sigdata)->name); - tag[1][0] = "FORMAT"; - tag[1][1] = "PSM (old)"; - return make_duh(-1, 2, (const char *const (*)[2])tag, 1, &descptr, &sigdata); - } + tag[1][0] = "FORMAT"; + tag[1][1] = "PSM (old)"; + return make_duh(-1, 2, (const char *const(*)[2])tag, 1, &descptr, + &sigdata); + } } diff --git a/Frameworks/Dumb/dumb/src/it/readpsm.c b/Frameworks/Dumb/dumb/src/it/readpsm.c index 2fd9dfbb8..94efedfc4 100644 --- a/Frameworks/Dumb/dumb/src/it/readpsm.c +++ b/Frameworks/Dumb/dumb/src/it/readpsm.c @@ -34,1263 +34,1382 @@ #define PSMV_OLD 940730 #define PSMV_NEW 940902 -typedef struct _PSMCHUNK -{ - int id; - int len; - unsigned char * data; +typedef struct _PSMCHUNK { + int id; + size_t len; + unsigned char *data; } PSMCHUNK; -typedef struct _PSMEVENT -{ - int type; - unsigned char data[8]; +typedef struct _PSMEVENT { + int type; + unsigned char data[8]; } PSMEVENT; -#define PSM_EVENT_END 0 -#define PSM_EVENT_PLAY_PATTERN 1 -#define PSM_EVENT_JUMP_TO_LINE 4 -#define PSM_EVENT_SET_SPEED 7 -#define PSM_EVENT_SET_BPM 8 +#define PSM_EVENT_END 0 +#define PSM_EVENT_PLAY_PATTERN 1 +#define PSM_EVENT_JUMP_TO_LINE 4 +#define PSM_EVENT_SET_SPEED 7 +#define PSM_EVENT_SET_BPM 8 #define PSM_EVENT_SAMPLE_MAP_TABLE 12 -#define PSM_EVENT_CHANGE_PAN 13 -#define PSM_EVENT_CHANGE_VOL 14 +#define PSM_EVENT_CHANGE_PAN 13 +#define PSM_EVENT_CHANGE_VOL 14 -static int it_psm_process_sample(IT_SAMPLE * sample, const unsigned char * data, int len, int id, int version) { - int flags; - int insno; - int length; - int loopstart; - int loopend; - int panpos; - int defvol; - int samplerate; +static int it_psm_process_sample(IT_SAMPLE *sample, const unsigned char *data, + size_t len, int id, int version) { + int flags; + int insno; + size_t length; + int loopstart; + int loopend; + int panpos; + int defvol; + int samplerate; - if (len < 0x60) return -1; + if (len < 0x60) + return -1; - flags = data[0]; + flags = data[0]; - if (version == PSMV_OLD) { - memcpy(sample->name, data + 0x0D, 34); - sample->name[34] = 0; + if (version == PSMV_OLD) { + memcpy(sample->name, data + 0x0D, 34); + sample->name[34] = 0; - insno = data[0x34] | (data[0x35] << 8); - length = data[0x36] | (data[0x37] << 8) | (data[0x38] << 16) | (data[0x39] << 24); - loopstart = data[0x3A] | (data[0x3B] << 8) | (data[0x3C] << 16) | (data[0x3D] << 24); - loopend = data[0x3E] | (data[0x3F] << 8) | (data[0x40] << 16) | (data[0x41] << 24); - panpos = data[0x43]; - defvol = data[0x44]; - samplerate = data[0x49] | (data[0x4A] << 8) | (data[0x4B] << 16) | (data[0x4C] << 24); - } else /*if (version == PSMV_NEW)*/ { - memcpy(sample->name, data + 0x11, 34); - sample->name[34] = 0; + insno = data[0x34] | (data[0x35] << 8); + length = data[0x36] | (data[0x37] << 8) | (data[0x38] << 16) | + (data[0x39] << 24); + loopstart = data[0x3A] | (data[0x3B] << 8) | (data[0x3C] << 16) | + (data[0x3D] << 24); + loopend = data[0x3E] | (data[0x3F] << 8) | (data[0x40] << 16) | + (data[0x41] << 24); + panpos = data[0x43]; + defvol = data[0x44]; + samplerate = data[0x49] | (data[0x4A] << 8) | (data[0x4B] << 16) | + (data[0x4C] << 24); + } else /*if (version == PSMV_NEW)*/ { + memcpy(sample->name, data + 0x11, 34); + sample->name[34] = 0; - insno = data[0x38] | (data[0x39] << 8); - length = data[0x3A] | (data[0x3B] << 8) | (data[0x3C] << 16) | (data[0x3D] << 24); - loopstart = data[0x3E] | (data[0x3F] << 8) | (data[0x40] << 16) | (data[0x41] << 24); - loopend = data[0x42] | (data[0x43] << 8) | (data[0x44] << 16) | (data[0x45] << 24); - panpos = data[0x48]; - defvol = data[0x49]; - samplerate = data[0x4E] | (data[0x4F] << 8) | (data[0x50] << 16) | (data[0x51] << 24); - } + insno = data[0x38] | (data[0x39] << 8); + length = data[0x3A] | (data[0x3B] << 8) | (data[0x3C] << 16) | + (data[0x3D] << 24); + loopstart = data[0x3E] | (data[0x3F] << 8) | (data[0x40] << 16) | + (data[0x41] << 24); + loopend = data[0x42] | (data[0x43] << 8) | (data[0x44] << 16) | + (data[0x45] << 24); + panpos = data[0x48]; + defvol = data[0x49]; + samplerate = data[0x4E] | (data[0x4F] << 8) | (data[0x50] << 16) | + (data[0x51] << 24); + } - if (insno != id) return -1; + if (insno != id) + return -1; - if (length <= 0) { - sample->flags &= ~IT_SAMPLE_EXISTS; - return 0; - } - - if ((length > len - 0x60) || ((flags & 0x7F) != 0)) return -1; + if (length <= 0) { + sample->flags &= ~IT_SAMPLE_EXISTS; + return 0; + } - sample->flags = IT_SAMPLE_EXISTS; - sample->length = length; - sample->loop_start = loopstart; - sample->loop_end = loopend; - sample->C5_speed = samplerate; - sample->default_volume = defvol >> 1; - sample->default_pan = 0; - sample->filename[0] = 0; - sample->global_volume = 64; - sample->vibrato_speed = 0; - sample->vibrato_depth = 0; - sample->vibrato_rate = 0; - sample->vibrato_waveform = IT_VIBRATO_SINE; - sample->finetune = 0; - sample->max_resampling_quality = -1; + if ((length > len - 0x60) || ((flags & 0x7F) != 0)) + return -1; - if (flags & 0x80) { - if (((unsigned int)sample->loop_end <= (unsigned int)sample->length) && - ((unsigned int)sample->loop_start < (unsigned int)sample->loop_end)) { - sample->length = sample->loop_end; - sample->flags |= IT_SAMPLE_LOOP; - } - } + sample->flags = IT_SAMPLE_EXISTS; + sample->length = length; + sample->loop_start = loopstart; + sample->loop_end = loopend; + sample->C5_speed = samplerate; + sample->default_volume = defvol >> 1; + sample->default_pan = 0; + sample->filename[0] = 0; + sample->global_volume = 64; + sample->vibrato_speed = 0; + sample->vibrato_depth = 0; + sample->vibrato_rate = 0; + sample->vibrato_waveform = IT_VIBRATO_SINE; + sample->finetune = 0; + sample->max_resampling_quality = -1; - sample->data = malloc(sample->length); - if (!sample->data) - return -1; + if (flags & 0x80) { + if (((unsigned int)sample->loop_end <= (unsigned int)sample->length) && + ((unsigned int)sample->loop_start < + (unsigned int)sample->loop_end)) { + sample->length = sample->loop_end; + sample->flags |= IT_SAMPLE_LOOP; + } + } - flags = 0; - data += 0x60; + sample->data = malloc(sample->length); + if (!sample->data) + return -1; - for (insno = 0; insno < sample->length; insno++) { - flags += (signed char)(*data++); - ((signed char *)sample->data)[insno] = flags; - } + flags = 0; + data += 0x60; - return 0; + for (insno = 0; insno < sample->length; insno++) { + flags += (signed char)(*data++); + ((signed char *)sample->data)[insno] = flags; + } + + return 0; } -static int it_psm_process_pattern(IT_PATTERN * pattern, const unsigned char * data, int len, int speed, int bpm, const unsigned char * pan, const int * vol, int version) { - int length, nrows, row, rowlen, pos; - unsigned flags, chan; - IT_ENTRY * entry; +static int it_psm_process_pattern(IT_PATTERN *pattern, + const unsigned char *data, size_t len, + int speed, int bpm, const unsigned char *pan, + const int *vol, int version) { + size_t length, pos, rowlen; + int nrows, row; + unsigned flags, chan; + IT_ENTRY *entry; - length = data[0] | (data[1] << 8) | (data[2] << 16) | (data[3] << 24); - if (len > length) len = length; + length = data[0] | (data[1] << 8) | (data[2] << 16) | (data[3] << 24); + if (len > length) + len = length; - if (version == PSMV_OLD) { - if (len < 10) return -1; - data += 8; - len -= 8; - } else /*if (version == PSMV_NEW)*/ { - if (len < 14) return -1; - data += 12; - len -= 12; - } + if (version == PSMV_OLD) { + if (len < 10) + return -1; + data += 8; + len -= 8; + } else /*if (version == PSMV_NEW)*/ { + if (len < 14) + return -1; + data += 12; + len -= 12; + } - nrows = data[0] | (data[1] << 8); + nrows = data[0] | (data[1] << 8); - if (!nrows) { - pattern->n_rows = 0; - pattern->n_entries = 0; - pattern->entry = NULL; - return 0; - } + if (!nrows) { + pattern->n_rows = 0; + pattern->n_entries = 0; + pattern->entry = NULL; + return 0; + } - pattern->n_rows = nrows; + pattern->n_rows = nrows; - data += 2; - len -= 2; + data += 2; + len -= 2; - pattern->n_entries = 0; + pattern->n_entries = 0; - row = 0; - pos = 2; - rowlen = data[0] | (data[1] << 8); + row = 0; + pos = 2; + rowlen = data[0] | (data[1] << 8); - while ((row < nrows) && (pos < len)) { - if (pos >= rowlen) { - row++; - rowlen += data[pos] | (data[pos+1] << 8); - pos += 2; - continue; - } + while ((row < nrows) && (pos < len)) { + if (pos >= rowlen) { + row++; + rowlen += data[pos] | (data[pos + 1] << 8); + pos += 2; + continue; + } - flags = data[pos++]; - chan = data[pos++]; + flags = data[pos++]; + chan = data[pos++]; - if (chan > 63) return -1; + if (chan > 63) + return -1; - if (flags & 0xF0) { - pattern->n_entries++; - if (flags & 0x80) pos++; - if (flags & 0x40) pos++; - if (flags & 0x20) pos++; - if (flags & 0x10) { - switch (data[pos]) { - case 0x29: - pos++; - case 0x33: - pos++; - default: - pos += 2; - } - } - } - } + if (flags & 0xF0) { + pattern->n_entries++; + if (flags & 0x80) + pos++; + if (flags & 0x40) + pos++; + if (flags & 0x20) + pos++; + if (flags & 0x10) { + switch (data[pos]) { + case 0x29: + pos++; + case 0x33: + pos++; + default: + pos += 2; + } + } + } + } - if (!pattern->n_entries) return 0; + if (!pattern->n_entries) + return 0; - pattern->n_entries += nrows; - if (speed) pattern->n_entries++; - if (bpm >= 0x20) pattern->n_entries++; + pattern->n_entries += nrows; + if (speed) + pattern->n_entries++; + if (bpm >= 0x20) + pattern->n_entries++; - for (pos = 0; pos < 32; pos++) { - if (!(pan[pos*2+1] & 0xF9)) pattern->n_entries++; - if (vol[pos] != -1) pattern->n_entries++; - } + for (pos = 0; pos < 32; pos++) { + if (!(pan[pos * 2 + 1] & 0xF9)) + pattern->n_entries++; + if (vol[pos] != -1) + pattern->n_entries++; + } - pattern->entry = malloc(pattern->n_entries * sizeof(*pattern->entry)); - if (!pattern->entry) return -1; + pattern->entry = malloc(pattern->n_entries * sizeof(*pattern->entry)); + if (!pattern->entry) + return -1; - entry = pattern->entry; + entry = pattern->entry; - if (speed) { - entry->channel = 0; - entry->mask = IT_ENTRY_EFFECT; - entry->effect = IT_SET_SPEED; - entry->effectvalue = speed; - entry++; - } + if (speed) { + entry->channel = 0; + entry->mask = IT_ENTRY_EFFECT; + entry->effect = IT_SET_SPEED; + entry->effectvalue = speed; + entry++; + } - if (bpm >= 0x20) { - entry->channel = 0; - entry->mask = IT_ENTRY_EFFECT; - entry->effect = IT_SET_SONG_TEMPO; - entry->effectvalue = bpm; - entry++; - } + if (bpm >= 0x20) { + entry->channel = 0; + entry->mask = IT_ENTRY_EFFECT; + entry->effect = IT_SET_SONG_TEMPO; + entry->effectvalue = bpm; + entry++; + } - for (pos = 0; pos < 32; pos++) { - if (!(pan[pos*2+1] & 0xF9)) { - entry->channel = pos; - entry->mask = IT_ENTRY_EFFECT; - switch (pan[pos*2+1]) { - case 0: - entry->effect = IT_SET_PANNING; - entry->effectvalue = pan[pos*2] ^ 128; - break; - case 2: - entry->effect = IT_S; - entry->effectvalue = EFFECT_VALUE(IT_S_SET_SURROUND_SOUND,1); - break; - case 4: - entry->effect = IT_SET_PANNING; - entry->effectvalue = 128; - break; - } - entry++; - } - if (vol[pos] != -1) { - entry->channel = pos; - entry->mask = IT_ENTRY_EFFECT; - entry->effect = IT_SET_CHANNEL_VOLUME; - entry->effectvalue = (vol[pos] + 2) >> 2; - entry++; - } - } + for (pos = 0; pos < 32; pos++) { + if (!(pan[pos * 2 + 1] & 0xF9)) { + entry->channel = pos; + entry->mask = IT_ENTRY_EFFECT; + switch (pan[pos * 2 + 1]) { + case 0: + entry->effect = IT_SET_PANNING; + entry->effectvalue = pan[pos * 2] ^ 128; + break; + case 2: + entry->effect = IT_S; + entry->effectvalue = EFFECT_VALUE(IT_S_SET_SURROUND_SOUND, 1); + break; + case 4: + entry->effect = IT_SET_PANNING; + entry->effectvalue = 128; + break; + } + entry++; + } + if (vol[pos] != -1) { + entry->channel = pos; + entry->mask = IT_ENTRY_EFFECT; + entry->effect = IT_SET_CHANNEL_VOLUME; + entry->effectvalue = (vol[pos] + 2) >> 2; + entry++; + } + } - row = 0; - pos = 2; - rowlen = data[0] | (data[1] << 8); + row = 0; + pos = 2; + rowlen = data[0] | (data[1] << 8); - while ((row < nrows) && (pos < len)) { - if (pos >= rowlen) { - IT_SET_END_ROW(entry); - entry++; - row++; - rowlen += data[pos] | (data[pos+1] << 8); - pos += 2; - continue; - } + while ((row < nrows) && (pos < len)) { + if (pos >= rowlen) { + IT_SET_END_ROW(entry); + entry++; + row++; + rowlen += data[pos] | (data[pos + 1] << 8); + pos += 2; + continue; + } - flags = data[pos++]; - entry->channel = data[pos++]; - entry->mask = 0; + flags = data[pos++]; + entry->channel = data[pos++]; + entry->mask = 0; - if (flags & 0xF0) { - if (flags & 0x80) { - entry->mask |= IT_ENTRY_NOTE; - if (version == PSMV_OLD) { - if ((data[pos] < 0x80)) entry->note = (data[pos]>>4)*12+(data[pos]&0x0f)+12; - else entry->mask &= ~IT_ENTRY_NOTE; - } else /*if (version == PSMV_NEW)*/ { - if ((data[pos]) && (data[pos] < 84)) entry->note = data[pos] + 35; - else entry->mask &= ~IT_ENTRY_NOTE; - } - pos++; - } + if (flags & 0xF0) { + if (flags & 0x80) { + entry->mask |= IT_ENTRY_NOTE; + if (version == PSMV_OLD) { + if ((data[pos] < 0x80)) + entry->note = + (data[pos] >> 4) * 12 + (data[pos] & 0x0f) + 12; + else + entry->mask &= ~IT_ENTRY_NOTE; + } else /*if (version == PSMV_NEW)*/ { + if ((data[pos]) && (data[pos] < 84)) + entry->note = data[pos] + 35; + else + entry->mask &= ~IT_ENTRY_NOTE; + } + pos++; + } - if (flags & 0x40) { - entry->mask |= IT_ENTRY_INSTRUMENT; - entry->instrument = data[pos++] + 1; - } + if (flags & 0x40) { + entry->mask |= IT_ENTRY_INSTRUMENT; + entry->instrument = data[pos++] + 1; + } - if (flags & 0x20) { - entry->mask |= IT_ENTRY_VOLPAN; - entry->volpan = (data[pos++] + 1) >> 1; - } + if (flags & 0x20) { + entry->mask |= IT_ENTRY_VOLPAN; + entry->volpan = (data[pos++] + 1) >> 1; + } - if (flags & 0x10) { - entry->mask |= IT_ENTRY_EFFECT; - length = data[pos+1]; - switch (data[pos]) { - case 1: - entry->effect = IT_VOLUME_SLIDE; - if (version == PSMV_OLD) entry->effectvalue = ((length&0x1e)<<3) | 0xF; - else /*if (version == PSMV_NEW)*/ entry->effectvalue = (length<<4) | 0xF; - break; + if (flags & 0x10) { + entry->mask |= IT_ENTRY_EFFECT; + length = data[pos + 1]; + switch (data[pos]) { + case 1: + entry->effect = IT_VOLUME_SLIDE; + if (version == PSMV_OLD) + entry->effectvalue = ((length & 0x1e) << 3) | 0xF; + else /*if (version == PSMV_NEW)*/ + entry->effectvalue = (length << 4) | 0xF; + break; - case 2: - entry->effect = IT_VOLUME_SLIDE; - if (version == PSMV_OLD) entry->effectvalue = (length << 3) & 0xF0; - else /*if (version == PSMV_NEW)*/ entry->effectvalue = (length << 4) & 0xF0; - break; + case 2: + entry->effect = IT_VOLUME_SLIDE; + if (version == PSMV_OLD) + entry->effectvalue = (length << 3) & 0xF0; + else /*if (version == PSMV_NEW)*/ + entry->effectvalue = (length << 4) & 0xF0; + break; - case 3: - entry->effect = IT_VOLUME_SLIDE; - if (version == PSMV_OLD) entry->effectvalue = (length >> 1) | 0xF0; - else /*if (version == PSMV_NEW)*/ entry->effectvalue = length | 0xF0; - break; + case 3: + entry->effect = IT_VOLUME_SLIDE; + if (version == PSMV_OLD) + entry->effectvalue = (length >> 1) | 0xF0; + else /*if (version == PSMV_NEW)*/ + entry->effectvalue = length | 0xF0; + break; - case 4: - entry->effect = IT_VOLUME_SLIDE; - if (version == PSMV_OLD) entry->effectvalue = (length >> 1) & 0xF; - else /*if (version == PSMV_NEW)*/ entry->effectvalue = length & 0xF; - break; + case 4: + entry->effect = IT_VOLUME_SLIDE; + if (version == PSMV_OLD) + entry->effectvalue = (length >> 1) & 0xF; + else /*if (version == PSMV_NEW)*/ + entry->effectvalue = length & 0xF; + break; - case 12: - entry->effect = IT_PORTAMENTO_UP; - if (version == PSMV_OLD) { - if (length < 4) entry->effectvalue = length | 0xF0; - else entry->effectvalue = length >> 2; - } else /*if (version == PSMV_NEW)*/ { - entry->effectvalue = length; - } - break; + case 12: + entry->effect = IT_PORTAMENTO_UP; + if (version == PSMV_OLD) { + if (length < 4) + entry->effectvalue = length | 0xF0; + else + entry->effectvalue = length >> 2; + } else /*if (version == PSMV_NEW)*/ { + entry->effectvalue = length; + } + break; - case 14: - entry->effect = IT_PORTAMENTO_DOWN; - if (version == PSMV_OLD) { - if (length < 4) entry->effectvalue = length | 0xF0; - else entry->effectvalue = length >> 2; - } else /*if (version == PSMV_NEW)*/ { - entry->effectvalue = length; - } - break; + case 14: + entry->effect = IT_PORTAMENTO_DOWN; + if (version == PSMV_OLD) { + if (length < 4) + entry->effectvalue = length | 0xF0; + else + entry->effectvalue = length >> 2; + } else /*if (version == PSMV_NEW)*/ { + entry->effectvalue = length; + } + break; - case 15: - entry->effect = IT_TONE_PORTAMENTO; - if (version == PSMV_OLD) entry->effectvalue = length >> 2; - else /*if (version == PSMV_NEW)*/ entry->effectvalue = length; - break; + case 15: + entry->effect = IT_TONE_PORTAMENTO; + if (version == PSMV_OLD) + entry->effectvalue = length >> 2; + else /*if (version == PSMV_NEW)*/ + entry->effectvalue = length; + break; - case 0x15: - entry->effect = IT_VIBRATO; - entry->effectvalue = length; - break; + case 0x15: + entry->effect = IT_VIBRATO; + entry->effectvalue = length; + break; - case 0x18: - entry->effect = IT_VOLSLIDE_VIBRATO; - entry->effectvalue = length; - break; + case 0x18: + entry->effect = IT_VOLSLIDE_VIBRATO; + entry->effectvalue = length; + break; - case 0x29: - entry->effect = IT_SET_SAMPLE_OFFSET; - entry->effectvalue = data[pos+2]; - pos += 2; - break; + case 0x29: + entry->effect = IT_SET_SAMPLE_OFFSET; + entry->effectvalue = data[pos + 2]; + pos += 2; + break; - case 0x2A: - entry->effect = IT_RETRIGGER_NOTE; - entry->effectvalue = length; - break; + case 0x2A: + entry->effect = IT_RETRIGGER_NOTE; + entry->effectvalue = length; + break; - case 0x33: + case 0x33: #if 0 entry->effect = IT_POSITION_JUMP; entry->effectvalue = data[pos+2]; #else - entry->mask &= ~IT_ENTRY_EFFECT; + entry->mask &= ~IT_ENTRY_EFFECT; #endif - pos++; - break; + pos++; + break; - case 0x34: - entry->effect = IT_BREAK_TO_ROW; - entry->effectvalue = length; - break; + case 0x34: + entry->effect = IT_BREAK_TO_ROW; + entry->effectvalue = length; + break; - case 0x3D: - entry->effect = IT_SET_SPEED; - entry->effectvalue = length; - break; + case 0x3D: + entry->effect = IT_SET_SPEED; + entry->effectvalue = length; + break; - case 0x3E: - if (length >= 0x20) { - entry->effect = IT_SET_SONG_TEMPO; - entry->effectvalue = length; - } else { - entry->mask &= ~IT_ENTRY_EFFECT; - } - break; + case 0x3E: + if (length >= 0x20) { + entry->effect = IT_SET_SONG_TEMPO; + entry->effectvalue = length; + } else { + entry->mask &= ~IT_ENTRY_EFFECT; + } + break; - case 0x47: - entry->effect = IT_ARPEGGIO; - entry->effectvalue = length; - break; + case 0x47: + entry->effect = IT_ARPEGGIO; + entry->effectvalue = length; + break; - default: - return -1; - } - pos += 2; - } - if (entry->mask) entry++; - } - } + default: + return -1; + } + pos += 2; + } + if (entry->mask) + entry++; + } + } - while (row < nrows) { - IT_SET_END_ROW(entry); - entry++; - row++; - } + while (row < nrows) { + IT_SET_END_ROW(entry); + entry++; + row++; + } - pattern->n_entries = entry - pattern->entry; - if (!pattern->n_entries) return -1; + pattern->n_entries = (int)((long)entry - (long)pattern->entry); + if (!pattern->n_entries) + return -1; - return 0; + return 0; } +static void free_chunks(PSMCHUNK *chunk, int count) { + int n; -static void free_chunks(PSMCHUNK * chunk, int count) { - int n; + for (n = 0; n < count; n++) { + if (chunk[n].data) + free(chunk[n].data); + } - for (n = 0; n < count; n++) { - if (chunk[n].data) - free(chunk[n].data); - } - - free(chunk); + free(chunk); } -static void dumb_it_optimize_orders(DUMB_IT_SIGDATA * sigdata); +static void dumb_it_optimize_orders(DUMB_IT_SIGDATA *sigdata); -static int pattcmp( const unsigned char *, const unsigned char *, size_t ); +static int pattcmp(const unsigned char *, const unsigned char *, size_t); -static DUMB_IT_SIGDATA *it_psm_load_sigdata(DUMBFILE *f, int * ver, int subsong) -{ - DUMB_IT_SIGDATA *sigdata; +static DUMB_IT_SIGDATA *it_psm_load_sigdata(DUMBFILE *f, int *ver, + int subsong) { + DUMB_IT_SIGDATA *sigdata; - PSMCHUNK *chunk; - int n_chunks = 0; + PSMCHUNK *chunk; + int n_chunks = 0; - PSMCHUNK *songchunk = 0; - int n_song_chunks = 0; + PSMCHUNK *songchunk = 0; + int n_song_chunks = 0; - PSMEVENT *event = 0; - int n_events = 0; + PSMEVENT *event = 0; + int n_events = 0; - unsigned char * ptr; + unsigned char *ptr; - int n, length, o; + int n, length; + int o; - int found; + int found; - int n_patterns = 0; + int n_patterns = 0; - int first_pattern_line = -1; - int first_pattern; + long first_pattern_line = -1; + int first_pattern; - int speed, bpm; - unsigned char pan[64]; - int vol[32]; + int speed, bpm; + unsigned char pan[64]; + int vol[32]; - if (dumbfile_mgetl(f) != DUMB_ID('P','S','M',' ')) goto error; + if (dumbfile_mgetl(f) != DUMB_ID('P', 'S', 'M', ' ')) + goto error; - length = dumbfile_igetl(f); + length = (int)dumbfile_igetl(f); - if (dumbfile_mgetl(f) != DUMB_ID('F','I','L','E')) goto error; + if (dumbfile_mgetl(f) != DUMB_ID('F', 'I', 'L', 'E')) + goto error; - chunk = calloc(768, sizeof(*chunk)); + chunk = calloc(768, sizeof(*chunk)); - while (length >= 8) { - if (n_chunks >= 768) goto error_fc; - chunk[n_chunks].id = dumbfile_mgetl(f); - n = dumbfile_igetl(f); - length -= 8; - if (n < 0 || n > length) - goto error_fc; - chunk[n_chunks].len = n; - if (n) { - ptr = malloc(n); - if (!ptr) goto error_fc; - if (dumbfile_getnc((char *)ptr, n, f) < n) - { - free(ptr); - goto error_fc; - } - chunk[n_chunks].data = ptr; - } - n_chunks++; - length -= n; - } + while (length >= 8) { + if (n_chunks >= 768) + goto error_fc; + chunk[n_chunks].id = (unsigned int)dumbfile_mgetl(f); + n = (int)dumbfile_igetl(f); + length -= 8; + if ((signed int)n <= 0 || n > length) + goto error_fc; + chunk[n_chunks].len = n; + if (n) { + ptr = malloc(n); + if (!ptr) + goto error_fc; + if (dumbfile_getnc((char *)ptr, n, f) < n) { + free(ptr); + goto error_fc; + } + chunk[n_chunks].data = ptr; + } + n_chunks++; + length -= n; + } - if (!n_chunks) goto error_fc; - - sigdata = malloc(sizeof(*sigdata)); - if (!sigdata) goto error_fc; + if (!n_chunks) + goto error_fc; - sigdata->n_patterns = 0; - sigdata->n_samples = 0; - sigdata->name[0] = 0; + sigdata = malloc(sizeof(*sigdata)); + if (!sigdata) + goto error_fc; - found = 0; + sigdata->n_patterns = 0; + sigdata->n_samples = 0; + sigdata->name[0] = 0; - for (n = 0; n < n_chunks; n++) { - PSMCHUNK * c = &chunk[n]; - switch(c->id) { - case DUMB_ID('S','D','F','T'): - /* song data format? */ - if ((found & 1) || (c->len != 8) || memcmp(c->data, "MAINSONG", 8)) goto error_sd; - found |= 1; - break; + found = 0; - case DUMB_ID('S','O','N','G'): - if (/*(found & 2) ||*/ (c->len < 11) /*|| memcmp(c->data, "MAINSONG", 8)*/) goto error_sd; - found |= 2; - break; + for (n = 0; n < n_chunks; n++) { + PSMCHUNK *c = &chunk[n]; + switch (c->id) { + case DUMB_ID('S', 'D', 'F', 'T'): + /* song data format? */ + if ((found & 1) || (c->len != 8) || memcmp(c->data, "MAINSONG", 8)) + goto error_sd; + found |= 1; + break; - case DUMB_ID('D','S','M','P'): - sigdata->n_samples++; - break; + case DUMB_ID('S', 'O', 'N', 'G'): + if (/*(found & 2) ||*/ (c->len < + 11) /*|| memcmp(c->data, "MAINSONG", 8)*/) + goto error_sd; + found |= 2; + break; - case DUMB_ID('T','I','T','L'): + case DUMB_ID('D', 'S', 'M', 'P'): + sigdata->n_samples++; + break; + + case DUMB_ID('T', 'I', 'T', 'L'): length = min(sizeof(sigdata->name) - 1, (unsigned)c->len); - memcpy(sigdata->name, c->data, length); - sigdata->name[length] = 0; - } - } + memcpy(sigdata->name, c->data, length); + sigdata->name[length] = 0; + } + } - if (found != 3 || !sigdata->n_samples) goto error_sd; + if (found != 3 || !sigdata->n_samples) + goto error_sd; - sigdata->song_message = NULL; - sigdata->order = NULL; - sigdata->instrument = NULL; - sigdata->sample = NULL; - sigdata->pattern = NULL; - sigdata->midi = NULL; - sigdata->checkpoint = NULL; + sigdata->song_message = NULL; + sigdata->order = NULL; + sigdata->instrument = NULL; + sigdata->sample = NULL; + sigdata->pattern = NULL; + sigdata->midi = NULL; + sigdata->checkpoint = NULL; - sigdata->n_instruments = 0; - sigdata->n_orders = 0; + sigdata->n_instruments = 0; + sigdata->n_orders = 0; - for (n = 0; n < n_chunks; n++) { - PSMCHUNK * c = &chunk[n]; - if (c->id == DUMB_ID('S','O','N','G')) { - if (subsong == 0) break; - subsong--; - } - } + for (n = 0; n < n_chunks; n++) { + PSMCHUNK *c = &chunk[n]; + if (c->id == DUMB_ID('S', 'O', 'N', 'G')) { + if (subsong == 0) + break; + subsong--; + } + } - if (n == n_chunks) return NULL; - subsong = n; + if (n == n_chunks) + return NULL; + subsong = (int)n; - /*for (n = 0; n < n_chunks; n++) { - PSMCHUNK * c = &chunk[n]; - if (c->id == DUMB_ID('S','O','N','G')) {*/ - { - PSMCHUNK * c = &chunk[subsong]; - { - ptr = c->data; - if (ptr[10] > 32) goto error_usd; - sigdata->n_pchannels = ptr[10]; - length = c->len - 11; - ptr += 11; - songchunk = 0; - if (length >= 8) { - songchunk = malloc(256 * sizeof(*songchunk)); - if (!songchunk) goto error_usd; - while (length >= 8) { - if (n_song_chunks >= 256) goto error_sc; - songchunk[n_song_chunks].id = DUMB_ID(ptr[0], ptr[1], ptr[2], ptr[3]); - n = ptr[4] | (ptr[5] << 8) | (ptr[6] << 16) | (ptr[7] << 24); - length -= 8; - if (n < 0 || n > length) goto error_sc; - songchunk[n_song_chunks].len = n; - songchunk[n_song_chunks].data = ptr + 8; - n_song_chunks++; - length -= n; - ptr += 8 + n; - } - } - /*break;*/ - } - } + /*for (n = 0; n < n_chunks; n++) { + PSMCHUNK * c = &chunk[n]; + if (c->id == DUMB_ID('S','O','N','G')) {*/ + { + PSMCHUNK *c = &chunk[subsong]; + { + ptr = c->data; + if (ptr[10] > 32) + goto error_usd; + sigdata->n_pchannels = ptr[10]; + length = (int)(c->len - 11); + ptr += 11; + songchunk = 0; + if (length >= 8) { + songchunk = malloc(256 * sizeof(*songchunk)); + if (!songchunk) + goto error_usd; + while (length >= 8) { + if (n_song_chunks >= 256) + goto error_sc; + songchunk[n_song_chunks].id = + DUMB_ID(ptr[0], ptr[1], ptr[2], ptr[3]); + n = ptr[4] | (ptr[5] << 8) | (ptr[6] << 16) | + (ptr[7] << 24); + length -= 8; + if ((signed int)n < 0 || n > length) + goto error_sc; + songchunk[n_song_chunks].len = n; + songchunk[n_song_chunks].data = ptr + 8; + n_song_chunks++; + length -= n; + ptr += 8 + n; + } + } + /*break;*/ + } + } - if (!n_song_chunks) goto error_sc; + if (!n_song_chunks) + goto error_sc; - found = 0; + found = 0; - for (n = 0; n < n_song_chunks; n++) { - PSMCHUNK * c = &songchunk[n]; + for (n = 0; n < n_song_chunks; n++) { + PSMCHUNK *c = &songchunk[n]; - if (c->id == DUMB_ID('D','A','T','E')) { - /* date of the library build / format spec */ - if (c->len == 6) { - length = c->len; - ptr = c->data; - while (length > 0) { - if (*ptr >= '0' && *ptr <= '9') { - found = (found * 10) + (*ptr - '0'); - } else { - found = 0; - break; - } - ptr++; - length--; - } - } - break; - } - } + if (c->id == DUMB_ID('D', 'A', 'T', 'E')) { + /* date of the library build / format spec */ + if (c->len == 6) { + length = (int)c->len; + ptr = c->data; + while (length > 0) { + if (*ptr >= '0' && *ptr <= '9') { + found = (found * 10) + (*ptr - '0'); + } else { + found = 0; + break; + } + ptr++; + length--; + } + } + break; + } + } - /* - if (found != 940506 && - found != 940509 && - found != 940510 && - found != 940530 && - found != 940629 && - found != PSMV_OLD && - found != 941011 && - found != PSMV_NEW && - found != 940906 && - found != 940903 && - found != 940914 && - found != 941213 && - found != 800211) WTF? - goto error_sc; - */ + /* + if (found != 940506 && + found != 940509 && + found != 940510 && + found != 940530 && + found != 940629 && + found != PSMV_OLD && + found != 941011 && + found != PSMV_NEW && + found != 940906 && + found != 940903 && + found != 940914 && + found != 941213 && + found != 800211) WTF? + goto error_sc; + */ - *ver = found; + *ver = found; - if (found == 800211 || - found == PSMV_NEW || - found == 940903 || - found == 940906 || - found == 940914 || - found == 941213) found = PSMV_NEW; - else found = PSMV_OLD; + if (found == 800211 || found == PSMV_NEW || found == 940903 || + found == 940906 || found == 940914 || found == 941213) + found = PSMV_NEW; + else + found = PSMV_OLD; - memset(sigdata->channel_volume, 64, DUMB_IT_N_CHANNELS); + memset(sigdata->channel_volume, 64, DUMB_IT_N_CHANNELS); - for (n = 0; n < DUMB_IT_N_CHANNELS; n += 4) { - int sep = 32 * dumb_it_default_panning_separation / 100; - sigdata->channel_pan[n ] = 32 - sep; - sigdata->channel_pan[n+1] = 32 + sep; - sigdata->channel_pan[n+2] = 32 + sep; - sigdata->channel_pan[n+3] = 32 - sep; - } + for (n = 0; n < DUMB_IT_N_CHANNELS; n += 4) { + int sep = 32 * dumb_it_default_panning_separation / 100; + sigdata->channel_pan[n] = 32 - sep; + sigdata->channel_pan[n + 1] = 32 + sep; + sigdata->channel_pan[n + 2] = 32 + sep; + sigdata->channel_pan[n + 3] = 32 - sep; + } - for (n = 0; n < n_song_chunks; n++) { - PSMCHUNK * c = &songchunk[n]; + for (n = 0; n < n_song_chunks; n++) { + PSMCHUNK *c = &songchunk[n]; - switch (c->id) { - case DUMB_ID('O','P','L','H'): - if (c->len < 2) goto error_sc; - ptr = c->data; - o = ptr[0] | (ptr[1] << 8); - if (!o) goto error_sc; - event = malloc(o * sizeof(*event)); - if (!event) goto error_sc; - length = c->len - 2; - ptr += 2; - while ((length > 0) && (n_events < o)) { - event[n_events].type = *ptr; - switch (*ptr) { - case PSM_EVENT_END: - ptr++; - length--; - break; + switch (c->id) { + case DUMB_ID('O', 'P', 'L', 'H'): + if (c->len < 2) + goto error_sc; + ptr = c->data; + o = ptr[0] | (ptr[1] << 8); + if (!o) + goto error_sc; + event = malloc(o * sizeof(*event)); + if (!event) + goto error_sc; + length = (int)(c->len - 2); + ptr += 2; + while ((length > 0) && (n_events < o)) { + event[n_events].type = *ptr; + switch (*ptr) { + case PSM_EVENT_END: + ptr++; + length--; + break; - case PSM_EVENT_PLAY_PATTERN: - if (found == PSMV_OLD) { - if (length < 5) goto error_ev; - memcpy(event[n_events].data, ptr + 1, 4); - ptr += 5; - length -= 5; - } else /*if (found == PSMV_NEW)*/ { - if (length < 9) goto error_ev; - memcpy(event[n_events].data, ptr + 1, 8); - ptr += 9; - length -= 9; - } - break; + case PSM_EVENT_PLAY_PATTERN: + if (found == PSMV_OLD) { + if (length < 5) + goto error_ev; + memcpy(event[n_events].data, ptr + 1, 4); + ptr += 5; + length -= 5; + } else /*if (found == PSMV_NEW)*/ { + if (length < 9) + goto error_ev; + memcpy(event[n_events].data, ptr + 1, 8); + ptr += 9; + length -= 9; + } + break; - case PSM_EVENT_SET_SPEED: - case PSM_EVENT_SET_BPM: - if (length < 2) goto error_ev; - event[n_events].data[0] = ptr[1]; - ptr += 2; - length -= 2; - break; + case PSM_EVENT_SET_SPEED: + case PSM_EVENT_SET_BPM: + if (length < 2) + goto error_ev; + event[n_events].data[0] = ptr[1]; + ptr += 2; + length -= 2; + break; - case PSM_EVENT_JUMP_TO_LINE: - case PSM_EVENT_CHANGE_VOL: - if (length < 3) goto error_ev; - memcpy(event[n_events].data, ptr + 1, 2); - ptr += 3; - length -= 3; - break; + case PSM_EVENT_JUMP_TO_LINE: + case PSM_EVENT_CHANGE_VOL: + if (length < 3) + goto error_ev; + memcpy(event[n_events].data, ptr + 1, 2); + ptr += 3; + length -= 3; + break; - case PSM_EVENT_SAMPLE_MAP_TABLE: - if (length < 7) goto error_ev; - memcpy(event[n_events].data, ptr + 1, 6); - ptr += 7; - length -= 7; - break; + case PSM_EVENT_SAMPLE_MAP_TABLE: + if (length < 7) + goto error_ev; + memcpy(event[n_events].data, ptr + 1, 6); + ptr += 7; + length -= 7; + break; - case PSM_EVENT_CHANGE_PAN: - if (length < 4) goto error_ev; - memcpy(event[n_events].data, ptr + 1, 3); - ptr += 4; - length -= 4; - break; + case PSM_EVENT_CHANGE_PAN: + if (length < 4) + goto error_ev; + memcpy(event[n_events].data, ptr + 1, 3); + ptr += 4; + length -= 4; + break; - default: - goto error_ev; - } - n_events++; - } - break; + default: + goto error_ev; + } + n_events++; + } + break; - case DUMB_ID('P','P','A','N'): - length = c->len; - if (length & 1) goto error_ev; - ptr = c->data; - o = 0; - while (length > 0) { - switch (ptr[0]) { - case 0: - sigdata->channel_pan[o] = ((((int)(signed char)ptr[1]) * 32) / 127) + 32; - break; - case 2: - sigdata->channel_pan[o] = IT_SURROUND; - break; - case 4: - sigdata->channel_pan[o] = 32; - break; - } - ptr += 2; - length -= 2; - if (++o >= DUMB_IT_N_CHANNELS) break; - } - break; + case DUMB_ID('P', 'P', 'A', 'N'): + length = (int)c->len; + if (length & 1) + goto error_ev; + ptr = c->data; + o = 0; + while (length > 0) { + switch (ptr[0]) { + case 0: + sigdata->channel_pan[o] = + ((((int)(signed char)ptr[1]) * 32) / 127) + 32; + break; + case 2: + sigdata->channel_pan[o] = IT_SURROUND; + break; + case 4: + sigdata->channel_pan[o] = 32; + break; + } + ptr += 2; + length -= 2; + if (++o >= DUMB_IT_N_CHANNELS) + break; + } + break; - /* - case DUMB_ID('P','A','T','T'): - case DUMB_ID('D','S','A','M'): - */ - } - } + /* + case DUMB_ID('P','A','T','T'): + case DUMB_ID('D','S','A','M'): + */ + } + } - sigdata->flags = IT_STEREO | IT_OLD_EFFECTS | IT_COMPATIBLE_GXX; + sigdata->flags = IT_STEREO | IT_OLD_EFFECTS | IT_COMPATIBLE_GXX; - sigdata->global_volume = 128; - sigdata->speed = 6; - sigdata->tempo = 125; - sigdata->mixing_volume = 48; - sigdata->pan_separation = 128; + sigdata->global_volume = 128; + sigdata->speed = 6; + sigdata->tempo = 125; + sigdata->mixing_volume = 48; + sigdata->pan_separation = 128; - speed = 0; - bpm = 0; - memset(pan, 255, sizeof(pan)); - memset(vol, 255, sizeof(vol)); + speed = 0; + bpm = 0; + memset(pan, 255, sizeof(pan)); + memset(vol, 255, sizeof(vol)); - sigdata->n_patterns = n_events; - sigdata->pattern = malloc(sigdata->n_patterns * sizeof(*sigdata->pattern)); - if (!sigdata->pattern) goto error_ev; - for (n = 0; n < sigdata->n_patterns; n++) - sigdata->pattern[n].entry = NULL; + sigdata->n_patterns = n_events; + sigdata->pattern = malloc(sigdata->n_patterns * sizeof(*sigdata->pattern)); + if (!sigdata->pattern) + goto error_ev; + for (n = 0; n < sigdata->n_patterns; n++) + sigdata->pattern[n].entry = NULL; - for (n = 0; n < n_events; n++) { - PSMEVENT * e = &event[n]; - switch (e->type) { - case PSM_EVENT_END: - n = n_events; - break; + for (n = 0; n < n_events; n++) { + PSMEVENT *e = &event[n]; + switch (e->type) { + case PSM_EVENT_END: + n = n_events; + break; - case PSM_EVENT_PLAY_PATTERN: - for (o = 0; o < n_chunks; o++) { - PSMCHUNK * c = &chunk[o]; - if (c->id == DUMB_ID('P','B','O','D')) { - ptr = c->data; - length = c->len; - if (found == PSMV_OLD) { - if (length < 8) goto error_ev; - if (!pattcmp(ptr + 4, e->data, 4)) { - if (it_psm_process_pattern(&sigdata->pattern[n_patterns], ptr, length, speed, bpm, pan, vol, found)) goto error_ev; - if (first_pattern_line < 0) { - first_pattern_line = n; - first_pattern = o; - } - e->data[0] = n_patterns; - e->data[1] = n_patterns >> 8; - n_patterns++; - break; - } - } else /*if (found == PSMV_NEW)*/ { - if (length < 12) goto error_ev; - if (!pattcmp(ptr + 4, e->data, 8)) { - if (it_psm_process_pattern(&sigdata->pattern[n_patterns], ptr, length, speed, bpm, pan, vol, found)) goto error_ev; - if (first_pattern_line < 0) { - first_pattern_line = n; - first_pattern = o; - } - e->data[0] = n_patterns; - e->data[1] = n_patterns >> 8; - n_patterns++; - break; - } - } - } - } - if (o == n_chunks) goto error_ev; + case PSM_EVENT_PLAY_PATTERN: + for (o = 0; o < n_chunks; o++) { + PSMCHUNK *c = &chunk[o]; + if (c->id == DUMB_ID('P', 'B', 'O', 'D')) { + ptr = c->data; + length = (int)c->len; + if (found == PSMV_OLD) { + if (length < 8) + goto error_ev; + if (!pattcmp(ptr + 4, e->data, 4)) { + if (it_psm_process_pattern( + &sigdata->pattern[n_patterns], ptr, length, + speed, bpm, pan, vol, found)) + goto error_ev; + if (first_pattern_line < 0) { + first_pattern_line = n; + first_pattern = o; + } + e->data[0] = n_patterns; + e->data[1] = n_patterns >> 8; + n_patterns++; + break; + } + } else /*if (found == PSMV_NEW)*/ { + if (length < 12) + goto error_ev; + if (!pattcmp(ptr + 4, e->data, 8)) { + if (it_psm_process_pattern( + &sigdata->pattern[n_patterns], ptr, length, + speed, bpm, pan, vol, found)) + goto error_ev; + if (first_pattern_line < 0) { + first_pattern_line = n; + first_pattern = o; + } + e->data[0] = n_patterns; + e->data[1] = n_patterns >> 8; + n_patterns++; + break; + } + } + } + } + if (o == n_chunks) + goto error_ev; - speed = 0; - bpm = 0; - memset(pan, 255, sizeof(pan)); - memset(vol, 255, sizeof(vol)); + speed = 0; + bpm = 0; + memset(pan, 255, sizeof(pan)); + memset(vol, 255, sizeof(vol)); - e->type = PSM_EVENT_END; - break; + e->type = PSM_EVENT_END; + break; - case PSM_EVENT_JUMP_TO_LINE: - o = e->data[0] | (e->data[1] << 8); - if (o >= n_events) goto error_ev; - if (o == 0) { - /* whew! easy case! */ - sigdata->restart_position = 0; - n = n_events; - } else if (o == n) { - /* freeze */ - n = n_events; - } else if (o > n) { - /* jump ahead, setting played event numbers to zero will prevent endless looping */ - n = o - 1; - } else if (o >= first_pattern_line) { - /* another semi-easy case */ - sigdata->restart_position = event[o].data[0] | (event[o].data[1] << 8); - n = n_events; - } else { - /* crud, try to simulate rerunning all of the commands from the indicated - * line up to the first pattern, then dupe the first pattern again. - */ - /* - PSMCHUNK * c = &chunk[first_pattern]; + case PSM_EVENT_JUMP_TO_LINE: + o = e->data[0] | (e->data[1] << 8); + if (o >= n_events) + goto error_ev; + if (o == 0) { + /* whew! easy case! */ + sigdata->restart_position = 0; + n = n_events; + } else if (o == n) { + /* freeze */ + n = n_events; + } else if (o > n) { + /* jump ahead, setting played event numbers to zero will prevent + * endless looping */ + n = o - 1; + } else if (o >= first_pattern_line) { + /* another semi-easy case */ + sigdata->restart_position = + event[o].data[0] | (event[o].data[1] << 8); + n = n_events; + } else { + /* crud, try to simulate rerunning all of the commands from the + * indicated line up to the first pattern, then dupe the first + * pattern again. + */ + /* + PSMCHUNK * c = &chunk[first_pattern]; - for (; o < first_pattern_line; o++) { - PSMEVENT * ev = &event[o]; - switch (ev->type) { - case PSM_EVENT_SET_SPEED: - speed = ev->data[0]; - break; - case PSM_EVENT_SET_BPM: - bpm = ev->data[0]; - break; - case PSM_EVENT_CHANGE_PAN: - if (ev->data[0] > 31) goto error_ev; - pan[ev->data[0] * 2] = ev->data[1]; - pan[ev->data[0] * 2 + 1] = ev->data[2]; - break; - case PSM_EVENT_CHANGE_VOL: - if (ev->data[0] > 31) goto error_ev; - vol[ev->data[0]] = ev->data[1]; - break; - } - } + for (; o < first_pattern_line; o++) { + PSMEVENT * ev = &event[o]; + switch (ev->type) { + case PSM_EVENT_SET_SPEED: + speed = ev->data[0]; + break; + case PSM_EVENT_SET_BPM: + bpm = ev->data[0]; + break; + case PSM_EVENT_CHANGE_PAN: + if (ev->data[0] > 31) goto error_ev; + pan[ev->data[0] * 2] = ev->data[1]; + pan[ev->data[0] * 2 + 1] = ev->data[2]; + break; + case PSM_EVENT_CHANGE_VOL: + if (ev->data[0] > 31) goto error_ev; + vol[ev->data[0]] = ev->data[1]; + break; + } + } - if (it_psm_process_pattern(&sigdata->pattern[n_patterns], c->data, c->len, speed, bpm, pan, vol, found)) goto error_ev; - n_patterns++; - sigdata->restart_position = 1; - n = n_events; + if (it_psm_process_pattern(&sigdata->pattern[n_patterns], + c->data, c->len, speed, bpm, pan, vol, found)) goto error_ev; + n_patterns++; + sigdata->restart_position = 1; + n = n_events; - Eh, what the hell? PSM has no panning commands anyway. - */ - sigdata->restart_position = 0; - n = n_events; - } - e->type = PSM_EVENT_END; - break; + Eh, what the hell? PSM has no panning commands anyway. + */ + sigdata->restart_position = 0; + n = n_events; + } + e->type = PSM_EVENT_END; + break; - case PSM_EVENT_SET_SPEED: - speed = e->data[0]; - break; + case PSM_EVENT_SET_SPEED: + speed = e->data[0]; + break; - case PSM_EVENT_SET_BPM: - bpm = e->data[0]; - break; + case PSM_EVENT_SET_BPM: + bpm = e->data[0]; + break; - case PSM_EVENT_CHANGE_PAN: - o = e->data[0]; - if (o > 31) goto error_ev; - pan[o * 2] = e->data[1]; - pan[o * 2 + 1] = e->data[2]; - break; + case PSM_EVENT_CHANGE_PAN: + o = e->data[0]; + if (o > 31) + goto error_ev; + pan[o * 2] = e->data[1]; + pan[o * 2 + 1] = e->data[2]; + break; - case PSM_EVENT_CHANGE_VOL: - o = e->data[0]; - if (o > 31) goto error_ev; - vol[o] = e->data[1]; - break; + case PSM_EVENT_CHANGE_VOL: + o = e->data[0]; + if (o > 31) + goto error_ev; + vol[o] = e->data[1]; + break; - case PSM_EVENT_SAMPLE_MAP_TABLE: - if (e->data[0] != 0 || e->data[1] != 0xFF || - e->data[2] != 0 || e->data[3] != 0 || - e->data[4] != 1 || e->data[5] != 0) - goto error_ev; - break; - } - } + case PSM_EVENT_SAMPLE_MAP_TABLE: + if (e->data[0] != 0 || e->data[1] != 0xFF || e->data[2] != 0 || + e->data[3] != 0 || e->data[4] != 1 || e->data[5] != 0) + goto error_ev; + break; + } + } - if (n_patterns > 256) goto error_ev; + if (n_patterns > 256) + goto error_ev; - sigdata->sample = malloc(sigdata->n_samples * sizeof(*sigdata->sample)); - if (!sigdata->sample) goto error_ev; - for (n = 0; n < sigdata->n_samples; n++) { - sigdata->sample[n].data = NULL; - sigdata->sample[n].flags = 0; - } + sigdata->sample = malloc(sigdata->n_samples * sizeof(*sigdata->sample)); + if (!sigdata->sample) + goto error_ev; + for (n = 0; n < sigdata->n_samples; n++) { + sigdata->sample[n].data = NULL; + sigdata->sample[n].flags = 0; + } - o = 0; - for (n = 0; n < n_chunks; n++) { - PSMCHUNK * c = &chunk[n]; - if (c->id == DUMB_ID('D','S','M','P')) { - if (it_psm_process_sample(&sigdata->sample[o], c->data, c->len, o, found)) goto error_ev; - o++; - } - } + o = 0; + for (n = 0; n < n_chunks; n++) { + PSMCHUNK *c = &chunk[n]; + if (c->id == DUMB_ID('D', 'S', 'M', 'P')) { + if (it_psm_process_sample(&sigdata->sample[o], c->data, c->len, o, + found)) + goto error_ev; + o++; + } + } - sigdata->n_orders = n_patterns; - sigdata->n_patterns = n_patterns; + sigdata->n_orders = n_patterns; + sigdata->n_patterns = n_patterns; - sigdata->order = malloc(n_patterns); + sigdata->order = malloc(n_patterns); - for (n = 0; n < n_patterns; n++) { - sigdata->order[n] = n; - } + for (n = 0; n < n_patterns; n++) { + sigdata->order[n] = n; + } - free(event); - free(songchunk); - free_chunks(chunk, n_chunks); + free(event); + free(songchunk); + free_chunks(chunk, n_chunks); - _dumb_it_fix_invalid_orders(sigdata); + _dumb_it_fix_invalid_orders(sigdata); - dumb_it_optimize_orders(sigdata); + dumb_it_optimize_orders(sigdata); - return sigdata; + return sigdata; error_ev: - free(event); + free(event); error_sc: - if (songchunk) free(songchunk); + if (songchunk) + free(songchunk); error_usd: - _dumb_it_unload_sigdata(sigdata); - goto error_fc; + _dumb_it_unload_sigdata(sigdata); + goto error_fc; error_sd: - free(sigdata); + free(sigdata); error_fc: - free_chunks(chunk, n_chunks); + free_chunks(chunk, n_chunks); error: - return NULL; + return NULL; } static int it_order_compare(const void *e1, const void *e2) { - if (*((const char *)e1) < *((const char *)e2)) - return -1; + if (*((const char *)e1) < *((const char *)e2)) + return -1; - if (*((const char *)e1) > *((const char *)e2)) - return 1; + if (*((const char *)e1) > *((const char *)e2)) + return 1; - return 0; + return 0; } /* static int it_optimize_compare(const void *e1, const void *e2) { - if (((const IT_ENTRY *)e1)->channel < ((const IT_ENTRY *)e2)->channel) - return -1; + if (((const IT_ENTRY *)e1)->channel < ((const IT_ENTRY *)e2)->channel) + return -1; - if (((const IT_ENTRY *)e1)->channel > ((const IT_ENTRY *)e2)->channel) - return 1; + if (((const IT_ENTRY *)e1)->channel > ((const IT_ENTRY *)e2)->channel) + return 1; - return 0; + return 0; } */ -static int it_entry_compare(const IT_ENTRY * e1, const IT_ENTRY * e2) { - if (IT_IS_END_ROW(e1) && IT_IS_END_ROW(e2)) return 1; - if (e1->channel != e2->channel) return 0; - if (e1->mask != e2->mask) return 0; - if ((e1->mask & IT_ENTRY_NOTE) && (e1->note != e2->note)) return 0; - if ((e1->mask & IT_ENTRY_INSTRUMENT) && (e1->instrument != e2->instrument)) return 0; - if ((e1->mask & IT_ENTRY_VOLPAN) && (e1->volpan != e2->volpan)) return 0; - if ((e1->mask & IT_ENTRY_EFFECT) && ((e1->effect != e2->effect) || (e1->effectvalue != e2->effectvalue))) return 0; - return 1; +static int it_entry_compare(const IT_ENTRY *e1, const IT_ENTRY *e2) { + if (IT_IS_END_ROW(e1) && IT_IS_END_ROW(e2)) + return 1; + if (e1->channel != e2->channel) + return 0; + if (e1->mask != e2->mask) + return 0; + if ((e1->mask & IT_ENTRY_NOTE) && (e1->note != e2->note)) + return 0; + if ((e1->mask & IT_ENTRY_INSTRUMENT) && (e1->instrument != e2->instrument)) + return 0; + if ((e1->mask & IT_ENTRY_VOLPAN) && (e1->volpan != e2->volpan)) + return 0; + if ((e1->mask & IT_ENTRY_EFFECT) && + ((e1->effect != e2->effect) || (e1->effectvalue != e2->effectvalue))) + return 0; + return 1; } /* static void dumb_it_optimize_pattern(IT_PATTERN * pattern) { - IT_ENTRY * entry, * end; - IT_ENTRY * rowstart, * rowend; - IT_ENTRY * current; + IT_ENTRY * entry, * end; + IT_ENTRY * rowstart, * rowend; + IT_ENTRY * current; - if (!pattern->n_entries || !pattern->entry) return; + if (!pattern->n_entries || !pattern->entry) return; - current = entry = pattern->entry; - end = entry + pattern->n_entries; + current = entry = pattern->entry; + end = entry + pattern->n_entries; - while (entry < end) { - rowstart = entry; - while (!IT_IS_END_ROW(entry)) entry++; - rowend = entry; - if (rowend > rowstart + 1) - qsort(rowstart, rowend - rowstart, sizeof(IT_ENTRY), &it_optimize_compare); - entry = rowstart; - while (entry < rowend) { - if (!(entry->mask)) {} - else if (it_entry_compare(entry, current)) {} - else if (!(current->mask) || - ((entry->channel == current->channel) && - ((entry->mask | current->mask) == (entry->mask ^ current->mask)))) { - current->mask |= entry->mask; - if (entry->mask & IT_ENTRY_NOTE) current->note = entry->note; - if (entry->mask & IT_ENTRY_INSTRUMENT) current->instrument = entry->instrument; - if (entry->mask & IT_ENTRY_VOLPAN) current->volpan = entry->volpan; - if (entry->mask & IT_ENTRY_EFFECT) { - current->effect = entry->effect; - current->effectvalue = entry->effectvalue; - } - } else { - if (++current < entry) *current = *entry; - } - entry++; - } - if (++current < entry) *current = *entry; - entry++; - } + while (entry < end) { + rowstart = entry; + while (!IT_IS_END_ROW(entry)) entry++; + rowend = entry; + if (rowend > rowstart + 1) + qsort(rowstart, rowend - rowstart, sizeof(IT_ENTRY), +&it_optimize_compare); entry = rowstart; while (entry < rowend) { if +(!(entry->mask)) {} else if (it_entry_compare(entry, current)) {} else if +(!(current->mask) || + ((entry->channel == current->channel) +&& + ((entry->mask | current->mask) == +(entry->mask ^ current->mask)))) { current->mask |= entry->mask; if (entry->mask +& IT_ENTRY_NOTE) current->note = entry->note; if (entry->mask & +IT_ENTRY_INSTRUMENT) current->instrument = entry->instrument; if (entry->mask & +IT_ENTRY_VOLPAN) current->volpan = entry->volpan; if (entry->mask & +IT_ENTRY_EFFECT) { current->effect = entry->effect; current->effectvalue = +entry->effectvalue; + } + } else { + if (++current < entry) *current = *entry; + } + entry++; + } + if (++current < entry) *current = *entry; + entry++; + } - current++; + current++; - if (current < end) { - IT_ENTRY * opt; - pattern->n_entries = current - pattern->entry; - opt = realloc(pattern->entry, pattern->n_entries * sizeof(*pattern->entry)); - if (opt) pattern->entry = opt; - } + if (current < end) { + IT_ENTRY * opt; + pattern->n_entries = current - pattern->entry; + opt = realloc(pattern->entry, pattern->n_entries * +sizeof(*pattern->entry)); if (opt) pattern->entry = opt; + } } */ -static int it_pattern_compare(const IT_PATTERN * p1, const IT_PATTERN * p2) { - IT_ENTRY * e1, * end; - IT_ENTRY * e2; +static int it_pattern_compare(const IT_PATTERN *p1, const IT_PATTERN *p2) { + IT_ENTRY *e1, *end; + IT_ENTRY *e2; - if (p1 == p2) return 1; - if (p1->n_entries != p2->n_entries) return 0; - - e1 = p1->entry; end = e1 + p1->n_entries; - e2 = p2->entry; + if (p1 == p2) + return 1; + if (p1->n_entries != p2->n_entries) + return 0; - while (e1 < end) { - if (!it_entry_compare(e1, e2)) return 0; - e1++; e2++; - } + e1 = p1->entry; + end = e1 + p1->n_entries; + e2 = p2->entry; - return 1; + while (e1 < end) { + if (!it_entry_compare(e1, e2)) + return 0; + e1++; + e2++; + } + + return 1; } -static void dumb_it_optimize_orders(DUMB_IT_SIGDATA * sigdata) { - int n, o, p; +static void dumb_it_optimize_orders(DUMB_IT_SIGDATA *sigdata) { + int n, o, p; /*int last_invalid = (sigdata->flags & IT_WAS_AN_XM) ? 255 : 253;*/ - unsigned char * order_list; - int n_patterns; + unsigned char *order_list; + int n_patterns; - IT_PATTERN * pattern; + IT_PATTERN *pattern; - if (!sigdata->n_orders || !sigdata->n_patterns) return; + if (!sigdata->n_orders || !sigdata->n_patterns) + return; - n_patterns = 0; - order_list = malloc(sigdata->n_orders); + n_patterns = 0; + order_list = malloc(sigdata->n_orders); - if (!order_list) return; + if (!order_list) + return; - for (n = 0; n < sigdata->n_orders; n++) { - if (sigdata->order[n] < sigdata->n_patterns) { - for (o = 0; o < n_patterns; o++) { - if (sigdata->order[n] == order_list[o]) break; - } - if (o == n_patterns) { - order_list[n_patterns++] = sigdata->order[n]; - } - } - } + for (n = 0; n < sigdata->n_orders; n++) { + if (sigdata->order[n] < sigdata->n_patterns) { + for (o = 0; o < n_patterns; o++) { + if (sigdata->order[n] == order_list[o]) + break; + } + if (o == n_patterns) { + order_list[n_patterns++] = sigdata->order[n]; + } + } + } - if (!n_patterns) { - free(order_list); - return; - } + if (!n_patterns) { + free(order_list); + return; + } - /*for (n = 0; n < n_patterns; n++) { - dumb_it_optimize_pattern(&sigdata->pattern[order_list[n]]); - }*/ + /*for (n = 0; n < n_patterns; n++) { + dumb_it_optimize_pattern(&sigdata->pattern[order_list[n]]); + }*/ - for (n = 0; n < n_patterns; n++) { - for (o = n + 1; o < n_patterns; o++) { - if ((order_list[n] != order_list[o]) && - it_pattern_compare(&sigdata->pattern[order_list[n]], &sigdata->pattern[order_list[o]])) { - for (p = 0; p < sigdata->n_orders; p++) { - if (sigdata->order[p] == order_list[o]) { - sigdata->order[p] = order_list[n]; - } - } - for (p = o + 1; p < n_patterns; p++) { - if (order_list[p] == order_list[o]) { - order_list[p] = order_list[n]; - } - } - order_list[o] = order_list[n]; - } - } - } + for (n = 0; n < n_patterns; n++) { + for (o = n + 1; o < n_patterns; o++) { + if ((order_list[n] != order_list[o]) && + it_pattern_compare(&sigdata->pattern[order_list[n]], + &sigdata->pattern[order_list[o]])) { + for (p = 0; p < sigdata->n_orders; p++) { + if (sigdata->order[p] == order_list[o]) { + sigdata->order[p] = order_list[n]; + } + } + for (p = o + 1; p < n_patterns; p++) { + if (order_list[p] == order_list[o]) { + order_list[p] = order_list[n]; + } + } + order_list[o] = order_list[n]; + } + } + } - qsort(order_list, n_patterns, sizeof(*order_list), &it_order_compare); + qsort(order_list, n_patterns, sizeof(*order_list), &it_order_compare); - for (n = 0, o = 0; n < n_patterns; n++) { - if (order_list[n] != order_list[o]) { - if (++o < n) order_list[o] = order_list[n]; - } - } + for (n = 0, o = 0; n < n_patterns; n++) { + if (order_list[n] != order_list[o]) { + if (++o < n) + order_list[o] = order_list[n]; + } + } - n_patterns = o + 1; + n_patterns = o + 1; - pattern = malloc(n_patterns * sizeof(*pattern)); - if (!pattern) { - free(order_list); - return; - } + pattern = malloc(n_patterns * sizeof(*pattern)); + if (!pattern) { + free(order_list); + return; + } - for (n = 0; n < n_patterns; n++) { - pattern[n] = sigdata->pattern[order_list[n]]; - } + for (n = 0; n < n_patterns; n++) { + pattern[n] = sigdata->pattern[order_list[n]]; + } - for (n = 0; n < sigdata->n_patterns; n++) { - for (o = 0; o < n_patterns; o++) { - if (order_list[o] == n) break; - } - if (o == n_patterns) { - if (sigdata->pattern[n].entry) - free(sigdata->pattern[n].entry); - } - } + for (n = 0; n < sigdata->n_patterns; n++) { + for (o = 0; o < n_patterns; o++) { + if (order_list[o] == n) + break; + } + if (o == n_patterns) { + if (sigdata->pattern[n].entry) + free(sigdata->pattern[n].entry); + } + } - free(sigdata->pattern); - sigdata->pattern = pattern; - sigdata->n_patterns = n_patterns; + free(sigdata->pattern); + sigdata->pattern = pattern; + sigdata->n_patterns = n_patterns; - for (n = 0; n < sigdata->n_orders; n++) { - for (o = 0; o < n_patterns; o++) { - if (sigdata->order[n] == order_list[o]) { - sigdata->order[n] = o; - break; - } - } - } + for (n = 0; n < sigdata->n_orders; n++) { + for (o = 0; o < n_patterns; o++) { + if (sigdata->order[n] == order_list[o]) { + sigdata->order[n] = o; + break; + } + } + } - free(order_list); + free(order_list); } int dumb_get_psm_subsong_count(DUMBFILE *f) { - int length, subsongs; - long l; - - if (dumbfile_mgetl(f) != DUMB_ID('P','S','M',' ')) return 0; + size_t length; + int subsongs; + long l; - length = dumbfile_igetl(f); + if (dumbfile_mgetl(f) != DUMB_ID('P', 'S', 'M', ' ')) + return 0; - if (dumbfile_mgetl(f) != DUMB_ID('F','I','L','E')) return 0; + length = dumbfile_igetl(f); - subsongs = 0; + if (dumbfile_mgetl(f) != DUMB_ID('F', 'I', 'L', 'E')) + return 0; - while (length >= 8 && !dumbfile_error(f)) { - if (dumbfile_mgetl(f) == DUMB_ID('S','O','N','G')) subsongs++; - l = dumbfile_igetl(f); - dumbfile_skip(f, l); - length -= l + 8; - } + subsongs = 0; - if (dumbfile_error(f)) return 0; + while (length >= 8 && !dumbfile_error(f)) { + if (dumbfile_mgetl(f) == DUMB_ID('S', 'O', 'N', 'G')) + subsongs++; + l = dumbfile_igetl(f); + dumbfile_skip(f, l); + length -= l + 8; + } - return subsongs; + if (dumbfile_error(f)) + return 0; + + return subsongs; } - - /* Eww */ -int pattcmp( const unsigned char * a, const unsigned char * b, size_t l ) -{ - size_t i, j, na, nb; - char * p; +int pattcmp(const unsigned char *a, const unsigned char *b, size_t l) { + long i, j; + unsigned long na, nb; + char *p; - na = nb = 0; + na = nb = 0; - i = memcmp( a, b, l ); - if ( !i ) return i; + i = memcmp(a, b, l); + if (!i) + return 0; - /* damnit */ + /* damnit */ - for ( i = 0; i < l; ++i ) - { - if ( a [i] >= '0' && a [i] <= '9' ) break; - } + for (i = 0; i < l; ++i) { + if (a[i] >= '0' && a[i] <= '9') + break; + } - if ( i < l ) - { - na = strtoul( (const char *)a + i, &p, 10 ); - if ( (const unsigned char *)p == a + i ) return 1; - } + if (i < l) { + na = strtoul((const char *)a + i, &p, 10); + if ((const unsigned char *)p == a + i) + return 1; + } - for ( j = 0; j < l; ++j ) - { - if ( b [j] >= '0' && b [j] <= '9' ) break; - } + for (j = 0; j < l; ++j) { + if (b[j] >= '0' && b[j] <= '9') + break; + } - if ( j < l ) - { - nb = strtoul( (const char *)b + j, &p, 10 ); - if ( (const unsigned char *)p == b + j ) return -1; - } + if (j < l) { + nb = strtoul((const char *)b + j, &p, 10); + if ((const unsigned char *)p == b + j) + return -1; + } - if ( i < j ) return -1; - else if ( i > j ) return 1; + if (i < j) + return -1; + else if (i > j) + return 1; - i = memcmp( a, b, j ); - if ( i ) return i; + i = memcmp(a, b, j); + if (i) + return (int)i; - return na - nb; + return (int)(((long)na) - ((long)nb)); } +DUH *dumb_read_psm_quick(DUMBFILE *f, int subsong) { + sigdata_t *sigdata; + int ver; + DUH_SIGTYPE_DESC *descptr = &_dumb_sigtype_it; -DUH *dumb_read_psm_quick(DUMBFILE *f, int subsong) -{ - sigdata_t *sigdata; - int ver; + sigdata = it_psm_load_sigdata(f, &ver, subsong); - DUH_SIGTYPE_DESC *descptr = &_dumb_sigtype_it; + if (!sigdata) + return NULL; - sigdata = it_psm_load_sigdata(f, &ver, subsong); - - if (!sigdata) - return NULL; - - { - int n_tags = 2; - char version[16]; - const char *tag[3][2]; - tag[0][0] = "TITLE"; + { + int n_tags = 2; + char version[16]; + const char *tag[3][2]; + tag[0][0] = "TITLE"; tag[0][1] = (const char *)(((DUMB_IT_SIGDATA *)sigdata)->name); - tag[1][0] = "FORMAT"; - tag[1][1] = "PSM"; - if ( ver ) - { - tag[2][0] = "FORMATVERSION"; - snprintf( version, 15, "%d", ver ); + tag[1][0] = "FORMAT"; + tag[1][1] = "PSM"; + if (ver) { + tag[2][0] = "FORMATVERSION"; + snprintf(version, 15, "%d", ver); version[15] = 0; - tag[2][1] = (const char *) &version; - ++n_tags; - } - return make_duh(-1, n_tags, (const char *const (*)[2])tag, 1, &descptr, &sigdata); - } + tag[2][1] = (const char *)&version; + ++n_tags; + } + return make_duh(-1, n_tags, (const char *const(*)[2])tag, 1, &descptr, + &sigdata); + } } diff --git a/Frameworks/Dumb/dumb/src/it/readptm.c b/Frameworks/Dumb/dumb/src/it/readptm.c index ec52b5ac9..9ac6b7352 100644 --- a/Frameworks/Dumb/dumb/src/it/readptm.c +++ b/Frameworks/Dumb/dumb/src/it/readptm.c @@ -24,531 +24,538 @@ #include "dumb.h" #include "internal/it.h" +static int it_ptm_read_sample_header(IT_SAMPLE *sample, long *offset, + DUMBFILE *f) { + int flags; - -static int it_ptm_read_sample_header(IT_SAMPLE *sample, long *offset, DUMBFILE *f) -{ - int flags; - - flags = dumbfile_getc(f); + flags = dumbfile_getc(f); dumbfile_getnc((char *)sample->filename, 12, f); - sample->filename[12] = 0; + sample->filename[12] = 0; - sample->default_volume = dumbfile_getc(f); + sample->default_volume = dumbfile_getc(f); - sample->C5_speed = dumbfile_igetw(f) << 1; + sample->C5_speed = dumbfile_igetw(f) << 1; - dumbfile_skip(f, 2); /* segment */ + dumbfile_skip(f, 2); /* segment */ - *offset = dumbfile_igetl(f); + *offset = dumbfile_igetl(f); - sample->length = dumbfile_igetl(f); - sample->loop_start = dumbfile_igetl(f); - sample->loop_end = dumbfile_igetl(f); + sample->length = dumbfile_igetl(f); + sample->loop_start = dumbfile_igetl(f); + sample->loop_end = dumbfile_igetl(f); - /* GUSBegin, GUSLStart, GUSLEnd, GUSLoop, reserverd */ - dumbfile_skip(f, 4+4+4+1+1); + /* GUSBegin, GUSLStart, GUSLEnd, GUSLoop, reserverd */ + dumbfile_skip(f, 4 + 4 + 4 + 1 + 1); dumbfile_getnc((char *)sample->name, 28, f); - sample->name[28] = 0; + sample->name[28] = 0; - /* - if (dumbfile_mgetl(f) != DUMB_ID('P','T','M','S')) - return -1; - */ + /* + if (dumbfile_mgetl(f) != DUMB_ID('P','T','M','S')) + return -1; + */ - /* BLAH! Shit likes to have broken or missing sample IDs */ - dumbfile_skip(f, 4); + /* BLAH! Shit likes to have broken or missing sample IDs */ + dumbfile_skip(f, 4); - if ((flags & 3) == 0) { - /* Looks like no sample */ - sample->flags &= ~IT_SAMPLE_EXISTS; - return dumbfile_error(f); - } + if ((flags & 3) == 0) { + /* Looks like no sample */ + sample->flags &= ~IT_SAMPLE_EXISTS; + return dumbfile_error(f); + } - sample->global_volume = 64; + sample->global_volume = 64; - sample->flags = IT_SAMPLE_EXISTS; - if (flags & 4) sample->flags |= IT_SAMPLE_LOOP; - if (flags & 8) sample->flags |= IT_SAMPLE_PINGPONG_LOOP; + sample->flags = IT_SAMPLE_EXISTS; + if (flags & 4) + sample->flags |= IT_SAMPLE_LOOP; + if (flags & 8) + sample->flags |= IT_SAMPLE_PINGPONG_LOOP; - if (flags & 16) { - sample->flags |= IT_SAMPLE_16BIT; + if (flags & 16) { + sample->flags |= IT_SAMPLE_16BIT; - sample->length >>= 1; - sample->loop_start >>= 1; - sample->loop_end >>= 1; - } + sample->length >>= 1; + sample->loop_start >>= 1; + sample->loop_end >>= 1; + } - if (sample->loop_end) sample->loop_end--; + if (sample->loop_end) + sample->loop_end--; - sample->default_pan = 0; // 0 = don't use, or 160 = centre? + sample->default_pan = 0; // 0 = don't use, or 160 = centre? - if (sample->length <= 0) - sample->flags &= ~IT_SAMPLE_EXISTS; - else if (sample->flags & IT_SAMPLE_LOOP) { - if ((unsigned int)sample->loop_end > (unsigned int)sample->length) - sample->flags &= ~IT_SAMPLE_LOOP; - else if ((unsigned int)sample->loop_start >= (unsigned int)sample->loop_end) - sample->flags &= ~IT_SAMPLE_LOOP; - else - sample->length = sample->loop_end; - } + if (sample->length <= 0) + sample->flags &= ~IT_SAMPLE_EXISTS; + else if (sample->flags & IT_SAMPLE_LOOP) { + if ((unsigned int)sample->loop_end > (unsigned int)sample->length) + sample->flags &= ~IT_SAMPLE_LOOP; + else if ((unsigned int)sample->loop_start >= + (unsigned int)sample->loop_end) + sample->flags &= ~IT_SAMPLE_LOOP; + else + sample->length = sample->loop_end; + } + // Do we need to set all these? + sample->vibrato_speed = 0; + sample->vibrato_depth = 0; + sample->vibrato_rate = 0; + sample->vibrato_waveform = IT_VIBRATO_SINE; + sample->finetune = 0; + sample->max_resampling_quality = -1; - //Do we need to set all these? - sample->vibrato_speed = 0; - sample->vibrato_depth = 0; - sample->vibrato_rate = 0; - sample->vibrato_waveform = IT_VIBRATO_SINE; - sample->finetune = 0; - sample->max_resampling_quality = -1; - - return dumbfile_error(f); + return dumbfile_error(f); } - -static int it_ptm_read_byte(DUMBFILE *f) -{ - int meh = dumbfile_getc(f); - if (meh < 0) return 0; - return meh; +static int it_ptm_read_byte(DUMBFILE *f) { + int meh = dumbfile_getc(f); + if (meh < 0) + return 0; + return meh; } -static int it_ptm_read_sample_data(IT_SAMPLE *sample, int last, DUMBFILE *f) -{ - long n; - int s; +static int it_ptm_read_sample_data(IT_SAMPLE *sample, int last, DUMBFILE *f) { + long n; + int s; - sample->data = malloc(sample->length * (sample->flags & IT_SAMPLE_16BIT ? 2 : 1)); - if (!sample->data) - return -1; + sample->data = + malloc(sample->length * (sample->flags & IT_SAMPLE_16BIT ? 2 : 1)); + if (!sample->data) + return -1; - s = 0; + s = 0; - if (sample->flags & IT_SAMPLE_16BIT) { - unsigned char a, b; - for (n = 0; n < sample->length; n++) { - a = s += (signed char) it_ptm_read_byte(f); - b = s += (signed char) it_ptm_read_byte(f); - ((short *)sample->data)[n] = a | (b << 8); - } - } else { - for (n = 0; n < sample->length; n++) { - s += (signed char) it_ptm_read_byte(f); - ((signed char *)sample->data)[n] = s; - } - } + if (sample->flags & IT_SAMPLE_16BIT) { + unsigned char a, b; + for (n = 0; n < sample->length; n++) { + a = s += (signed char)it_ptm_read_byte(f); + b = s += (signed char)it_ptm_read_byte(f); + ((short *)sample->data)[n] = a | (b << 8); + } + } else { + for (n = 0; n < sample->length; n++) { + s += (signed char)it_ptm_read_byte(f); + ((signed char *)sample->data)[n] = s; + } + } - if (dumbfile_error(f) && !last) - return -1; + if (dumbfile_error(f) && !last) + return -1; - return 0; + return 0; } +static int it_ptm_read_pattern(IT_PATTERN *pattern, DUMBFILE *f, + unsigned char *buffer, size_t length) { + int buflen = 0; + int bufpos = 0; + int effect, effectvalue; + IT_ENTRY *entry; -static int it_ptm_read_pattern(IT_PATTERN *pattern, DUMBFILE *f, unsigned char *buffer, int length) -{ - int buflen = 0; - int bufpos = 0; - int effect, effectvalue; + unsigned char channel; - IT_ENTRY *entry; + if (!length) + return -1; - unsigned char channel; + pattern->n_rows = 0; + pattern->n_entries = 0; - if (!length) - return -1; - - pattern->n_rows = 0; - pattern->n_entries = 0; - - /* Read in the pattern data, little by little, and work out how many - * entries we need room for. Sorry, but this is just so funny... - */ - for (;;) { - unsigned char b = buffer[buflen++] = dumbfile_getc(f); + /* Read in the pattern data, little by little, and work out how many + * entries we need room for. Sorry, but this is just so funny... + */ + for (;;) { + unsigned char b = buffer[buflen++] = dumbfile_getc(f); #if 1 - static const unsigned char used[8] = {0, 2, 2, 4, 1, 3, 3, 5}; - channel = b & 31; - b >>= 5; - pattern->n_entries++; - if (b) { - if (buflen + used[b] >= 65536) return -1; + static const unsigned char used[8] = {0, 2, 2, 4, 1, 3, 3, 5}; + channel = b & 31; + b >>= 5; + pattern->n_entries++; + if (b) { + if (buflen + used[b] >= 65536) + return -1; dumbfile_getnc((char *)buffer + buflen, used[b], f); - buflen += used[b]; - } else { - /* End of row */ - if (++pattern->n_rows == 64) break; - if (buflen >= 65536) return -1; - } + buflen += used[b]; + } else { + /* End of row */ + if (++pattern->n_rows == 64) + break; + if (buflen >= 65536) + return -1; + } #else - if (b == 0) { - /* End of row */ - pattern->n_entries++; - if (++pattern->n_rows == 64) break; - if (buflen >= 65536) return -1; - } else { - static const unsigned char used[8] = {0, 2, 2, 4, 1, 3, 3, 5}; - channel = b & 31; - b >>= 5; - if (b) { - pattern->n_entries++; - if (buflen + used[b] >= 65536) return -1; - dumbfile_getnc(buffer + buflen, used[b], f); - buflen += used[b]; - } - } + if (b == 0) { + /* End of row */ + pattern->n_entries++; + if (++pattern->n_rows == 64) + break; + if (buflen >= 65536) + return -1; + } else { + static const unsigned char used[8] = {0, 2, 2, 4, 1, 3, 3, 5}; + channel = b & 31; + b >>= 5; + if (b) { + pattern->n_entries++; + if (buflen + used[b] >= 65536) + return -1; + dumbfile_getnc(buffer + buflen, used[b], f); + buflen += used[b]; + } + } #endif - /* We have ensured that buflen < 65536 at this point, so it is safe - * to iterate and read at least one more byte without checking. - * However, now would be a good time to check for errors reading from - * the file. - */ + /* We have ensured that buflen < 65536 at this point, so it is safe + * to iterate and read at least one more byte without checking. + * However, now would be a good time to check for errors reading from + * the file. + */ - if (dumbfile_error(f)) - return -1; + if (dumbfile_error(f)) + return -1; - /* Great. We ran out of data, but there should be data for more rows. - * Fill the rest with null data... - */ - if (buflen >= length && pattern->n_rows < 64) - { - while (pattern->n_rows < 64) - { - if (buflen >= 65536) return -1; - buffer[buflen++] = 0; - pattern->n_entries++; - pattern->n_rows++; - } - break; - } - } + /* Great. We ran out of data, but there should be data for more rows. + * Fill the rest with null data... + */ + if (buflen >= (dumb_ssize_t)length && pattern->n_rows < 64) { + while (pattern->n_rows < 64) { + if (buflen >= 65536) + return -1; + buffer[buflen++] = 0; + pattern->n_entries++; + pattern->n_rows++; + } + break; + } + } - pattern->entry = malloc(pattern->n_entries * sizeof(*pattern->entry)); + pattern->entry = malloc(pattern->n_entries * sizeof(*pattern->entry)); - if (!pattern->entry) - return -1; + if (!pattern->entry) + return -1; - entry = pattern->entry; + entry = pattern->entry; - while (bufpos < buflen) { - unsigned char b = buffer[bufpos++]; + while (bufpos < buflen) { + unsigned char b = buffer[bufpos++]; - if (b == 0) - { - /* End of row */ - IT_SET_END_ROW(entry); - entry++; - continue; - } + if (b == 0) { + /* End of row */ + IT_SET_END_ROW(entry); + entry++; + continue; + } - channel = b & 31; + channel = b & 31; - if (b & 224) { - entry->mask = 0; - entry->channel = channel; + if (b & 224) { + entry->mask = 0; + entry->channel = channel; - if (b & 32) { - unsigned char n = buffer[bufpos++]; - if (n == 254 || (n >= 1 && n <= 120)) { - if (n == 254) - entry->note = IT_NOTE_CUT; - else - entry->note = n - 1; - entry->mask |= IT_ENTRY_NOTE; - } + if (b & 32) { + unsigned char n = buffer[bufpos++]; + if (n == 254 || (n >= 1 && n <= 120)) { + if (n == 254) + entry->note = IT_NOTE_CUT; + else + entry->note = n - 1; + entry->mask |= IT_ENTRY_NOTE; + } - entry->instrument = buffer[bufpos++]; - if (entry->instrument) - entry->mask |= IT_ENTRY_INSTRUMENT; - } + entry->instrument = buffer[bufpos++]; + if (entry->instrument) + entry->mask |= IT_ENTRY_INSTRUMENT; + } - if (b & 64) { - effect = buffer[bufpos++]; - effectvalue = buffer[bufpos++]; - _dumb_it_ptm_convert_effect(effect, effectvalue, entry); - } + if (b & 64) { + effect = buffer[bufpos++]; + effectvalue = buffer[bufpos++]; + _dumb_it_ptm_convert_effect(effect, effectvalue, entry); + } - if (b & 128) { - entry->volpan = buffer[bufpos++]; - if (entry->volpan <= 64) - entry->mask |= IT_ENTRY_VOLPAN; - } + if (b & 128) { + entry->volpan = buffer[bufpos++]; + if (entry->volpan <= 64) + entry->mask |= IT_ENTRY_VOLPAN; + } - entry++; - } - } + entry++; + } + } - ASSERT(entry == pattern->entry + pattern->n_entries); + ASSERT(entry == pattern->entry + pattern->n_entries); - return 0; + return 0; } - - -/** WARNING: this is duplicated in itread.c - also bad practice to use the same struct name unless they are unified in a header */ +/** WARNING: this is duplicated in itread.c - also bad practice to use the same + * struct name unless they are unified in a header */ /* Currently we assume the sample data are stored after the sample headers in * module files. This assumption may be unjustified; let me know if you have * trouble. */ #define PTM_COMPONENT_INSTRUMENT 1 -#define PTM_COMPONENT_PATTERN 2 -#define PTM_COMPONENT_SAMPLE 3 +#define PTM_COMPONENT_PATTERN 2 +#define PTM_COMPONENT_SAMPLE 3 -typedef struct PTM_COMPONENT -{ - unsigned char type; - unsigned char n; - long offset; -} -PTM_COMPONENT; +typedef struct PTM_COMPONENT { + unsigned char type; + unsigned char n; + long offset; +} PTM_COMPONENT; - - -static int ptm_component_compare(const void *e1, const void *e2) -{ - return ((const PTM_COMPONENT *)e1)->offset - - ((const PTM_COMPONENT *)e2)->offset; +static int ptm_component_compare(const void *e1, const void *e2) { + return (int)(((const PTM_COMPONENT *)e1)->offset - + ((const PTM_COMPONENT *)e2)->offset); } +static DUMB_IT_SIGDATA *it_ptm_load_sigdata(DUMBFILE *f) { + DUMB_IT_SIGDATA *sigdata; + PTM_COMPONENT *component; + int n_components = 0; -static DUMB_IT_SIGDATA *it_ptm_load_sigdata(DUMBFILE *f) -{ - DUMB_IT_SIGDATA *sigdata; + int n; - PTM_COMPONENT *component; - int n_components = 0; + unsigned char *buffer; - int n; + sigdata = malloc(sizeof(*sigdata)); + if (!sigdata) + return NULL; - unsigned char *buffer; - - sigdata = malloc(sizeof(*sigdata)); - if (!sigdata) return NULL; - - /* Skip song name. */ + /* Skip song name. */ dumbfile_getnc((char *)sigdata->name, 28, f); - sigdata->name[28] = 0; + sigdata->name[28] = 0; - if (dumbfile_getc(f) != 0x1A || dumbfile_igetw(f) != 0x203) { - free(sigdata); - return NULL; - } + if (dumbfile_getc(f) != 0x1A || dumbfile_igetw(f) != 0x203) { + free(sigdata); + return NULL; + } - dumbfile_skip(f, 1); + dumbfile_skip(f, 1); - sigdata->song_message = NULL; - sigdata->order = NULL; - sigdata->instrument = NULL; - sigdata->sample = NULL; - sigdata->pattern = NULL; - sigdata->midi = NULL; - sigdata->checkpoint = NULL; + sigdata->song_message = NULL; + sigdata->order = NULL; + sigdata->instrument = NULL; + sigdata->sample = NULL; + sigdata->pattern = NULL; + sigdata->midi = NULL; + sigdata->checkpoint = NULL; - sigdata->n_orders = dumbfile_igetw(f); - sigdata->n_instruments = 0; - sigdata->n_samples = dumbfile_igetw(f); - sigdata->n_patterns = dumbfile_igetw(f); + sigdata->n_orders = dumbfile_igetw(f); + sigdata->n_instruments = 0; + sigdata->n_samples = dumbfile_igetw(f); + sigdata->n_patterns = dumbfile_igetw(f); - if (dumbfile_error(f) || sigdata->n_orders <= 0 || sigdata->n_samples > 255 || sigdata->n_patterns > 128) { - _dumb_it_unload_sigdata(sigdata); - return NULL; - } + if (dumbfile_error(f) || sigdata->n_orders <= 0 || + sigdata->n_samples > 255 || sigdata->n_patterns > 128) { + _dumb_it_unload_sigdata(sigdata); + return NULL; + } - sigdata->n_pchannels = dumbfile_igetw(f); + sigdata->n_pchannels = dumbfile_igetw(f); - if (dumbfile_igetw(f) != 0) { - _dumb_it_unload_sigdata(sigdata); - return NULL; - } + if (dumbfile_igetw(f) != 0) { + _dumb_it_unload_sigdata(sigdata); + return NULL; + } - dumbfile_skip(f, 2); + dumbfile_skip(f, 2); - if (dumbfile_mgetl(f) != DUMB_ID('P','T','M','F')) { - _dumb_it_unload_sigdata(sigdata); - return NULL; - } + if (dumbfile_mgetl(f) != DUMB_ID('P', 'T', 'M', 'F')) { + _dumb_it_unload_sigdata(sigdata); + return NULL; + } - dumbfile_skip(f, 16); + dumbfile_skip(f, 16); - sigdata->order = malloc(sigdata->n_orders); - if (!sigdata->order) { - _dumb_it_unload_sigdata(sigdata); - return NULL; - } + sigdata->order = malloc(sigdata->n_orders); + if (!sigdata->order) { + _dumb_it_unload_sigdata(sigdata); + return NULL; + } - if (sigdata->n_samples) { - sigdata->sample = malloc(sigdata->n_samples * sizeof(*sigdata->sample)); - if (!sigdata->sample) { - _dumb_it_unload_sigdata(sigdata); - return NULL; - } - for (n = 0; n < sigdata->n_samples; n++) - sigdata->sample[n].data = NULL; - } + if (sigdata->n_samples) { + sigdata->sample = malloc(sigdata->n_samples * sizeof(*sigdata->sample)); + if (!sigdata->sample) { + _dumb_it_unload_sigdata(sigdata); + return NULL; + } + for (n = 0; n < sigdata->n_samples; n++) + sigdata->sample[n].data = NULL; + } - if (sigdata->n_patterns) { - sigdata->pattern = malloc(sigdata->n_patterns * sizeof(*sigdata->pattern)); - if (!sigdata->pattern) { - _dumb_it_unload_sigdata(sigdata); - return NULL; - } - for (n = 0; n < sigdata->n_patterns; n++) - sigdata->pattern[n].entry = NULL; - } + if (sigdata->n_patterns) { + sigdata->pattern = + malloc(sigdata->n_patterns * sizeof(*sigdata->pattern)); + if (!sigdata->pattern) { + _dumb_it_unload_sigdata(sigdata); + return NULL; + } + for (n = 0; n < sigdata->n_patterns; n++) + sigdata->pattern[n].entry = NULL; + } - /** WARNING: which ones? */ - sigdata->flags = IT_STEREO | IT_OLD_EFFECTS | IT_COMPATIBLE_GXX | IT_WAS_A_PTM; + /** WARNING: which ones? */ + sigdata->flags = + IT_STEREO | IT_OLD_EFFECTS | IT_COMPATIBLE_GXX | IT_WAS_A_PTM; - sigdata->global_volume = 128; - sigdata->speed = 6; - sigdata->tempo = 125; - sigdata->mixing_volume = 48; + sigdata->global_volume = 128; + sigdata->speed = 6; + sigdata->tempo = 125; + sigdata->mixing_volume = 48; - /* Panning positions for 32 channels */ - { - int i; - for (i = 0; i < 32; i++) { - int c = dumbfile_getc(f); - if (c <= 15) { - sigdata->channel_volume[i] = 64; - sigdata->channel_pan[i] = c; - } else { - /** WARNING: this could be improved if we support channel muting... */ - sigdata->channel_volume[i] = 0; - sigdata->channel_pan[i] = 7; - } - } - } + /* Panning positions for 32 channels */ + { + int i; + for (i = 0; i < 32; i++) { + int c = dumbfile_getc(f); + if (c <= 15) { + sigdata->channel_volume[i] = 64; + sigdata->channel_pan[i] = c; + } else { + /** WARNING: this could be improved if we support channel + * muting... */ + sigdata->channel_volume[i] = 0; + sigdata->channel_pan[i] = 7; + } + } + } - /* Orders, byte each, length = sigdata->n_orders (should be even) */ + /* Orders, byte each, length = sigdata->n_orders (should be even) */ dumbfile_getnc((char *)sigdata->order, sigdata->n_orders, f); - sigdata->restart_position = 0; + sigdata->restart_position = 0; - component = malloc(768*sizeof(*component)); - if (!component) { - _dumb_it_unload_sigdata(sigdata); - return NULL; - } + component = malloc(768 * sizeof(*component)); + if (!component) { + _dumb_it_unload_sigdata(sigdata); + return NULL; + } if (dumbfile_seek(f, 352, DFS_SEEK_SET)) { - free(component); - _dumb_it_unload_sigdata(sigdata); - return NULL; - } + free(component); + _dumb_it_unload_sigdata(sigdata); + return NULL; + } - for (n = 0; n < sigdata->n_patterns; n++) { - component[n_components].type = PTM_COMPONENT_PATTERN; - component[n_components].n = n; - component[n_components].offset = dumbfile_igetw(f) << 4; - n_components++; - } + for (n = 0; n < sigdata->n_patterns; n++) { + component[n_components].type = PTM_COMPONENT_PATTERN; + component[n_components].n = n; + component[n_components].offset = dumbfile_igetw(f) << 4; + n_components++; + } if (dumbfile_seek(f, 608, DFS_SEEK_SET)) { - free(component); - _dumb_it_unload_sigdata(sigdata); - return NULL; - } + free(component); + _dumb_it_unload_sigdata(sigdata); + return NULL; + } - for (n = 0; n < sigdata->n_samples; n++) { - if (it_ptm_read_sample_header(&sigdata->sample[n], &component[n_components].offset, f)) { - free(component); - _dumb_it_unload_sigdata(sigdata); - return NULL; - } - if (!(sigdata->sample[n].flags & IT_SAMPLE_EXISTS)) continue; - component[n_components].type = PTM_COMPONENT_SAMPLE; - component[n_components].n = n; - n_components++; - } + for (n = 0; n < sigdata->n_samples; n++) { + if (it_ptm_read_sample_header(&sigdata->sample[n], + &component[n_components].offset, f)) { + free(component); + _dumb_it_unload_sigdata(sigdata); + return NULL; + } + if (!(sigdata->sample[n].flags & IT_SAMPLE_EXISTS)) + continue; + component[n_components].type = PTM_COMPONENT_SAMPLE; + component[n_components].n = n; + n_components++; + } - qsort(component, n_components, sizeof(PTM_COMPONENT), &ptm_component_compare); + qsort(component, n_components, sizeof(PTM_COMPONENT), + &ptm_component_compare); - { - int i; - for (i = 0; i < 32; i++) { - sigdata->channel_pan[i] -= (sigdata->channel_pan[i] & 8) >> 3; - sigdata->channel_pan[i] = ((int)sigdata->channel_pan[i] << 5) / 7; - if (sigdata->channel_pan[i] > 64) sigdata->channel_pan[i] = 64; - } - } + { + int i; + for (i = 0; i < 32; i++) { + sigdata->channel_pan[i] -= (sigdata->channel_pan[i] & 8) >> 3; + sigdata->channel_pan[i] = ((int)sigdata->channel_pan[i] << 5) / 7; + if (sigdata->channel_pan[i] > 64) + sigdata->channel_pan[i] = 64; + } + } - sigdata->pan_separation = 128; + sigdata->pan_separation = 128; - if (dumbfile_error(f)) { - free(component); - _dumb_it_unload_sigdata(sigdata); - return NULL; - } + if (dumbfile_error(f)) { + free(component); + _dumb_it_unload_sigdata(sigdata); + return NULL; + } - buffer = malloc(65536); - if (!buffer) { - free(component); - _dumb_it_unload_sigdata(sigdata); - return NULL; - } + buffer = malloc(65536); + if (!buffer) { + free(component); + _dumb_it_unload_sigdata(sigdata); + return NULL; + } - for (n = 0; n < n_components; n++) { + for (n = 0; n < n_components; n++) { if (dumbfile_seek(f, component[n].offset, DFS_SEEK_SET)) { - free(buffer); - free(component); - _dumb_it_unload_sigdata(sigdata); - return NULL; - } + free(buffer); + free(component); + _dumb_it_unload_sigdata(sigdata); + return NULL; + } - switch (component[n].type) { + switch (component[n].type) { - case PTM_COMPONENT_PATTERN: - if (it_ptm_read_pattern(&sigdata->pattern[component[n].n], f, buffer, (n + 1 < n_components) ? (component[n+1].offset - component[n].offset) : 0)) { - free(buffer); - free(component); - _dumb_it_unload_sigdata(sigdata); - return NULL; - } - break; + case PTM_COMPONENT_PATTERN: + if (it_ptm_read_pattern( + &sigdata->pattern[component[n].n], f, buffer, + (n + 1 < n_components) + ? (component[n + 1].offset - component[n].offset) + : 0)) { + free(buffer); + free(component); + _dumb_it_unload_sigdata(sigdata); + return NULL; + } + break; - case PTM_COMPONENT_SAMPLE: - if (it_ptm_read_sample_data(&sigdata->sample[component[n].n], (n + 1 == n_components), f)) { - free(buffer); - free(component); - _dumb_it_unload_sigdata(sigdata); - return NULL; - } - } - } + case PTM_COMPONENT_SAMPLE: + if (it_ptm_read_sample_data(&sigdata->sample[component[n].n], + (n + 1 == n_components), f)) { + free(buffer); + free(component); + _dumb_it_unload_sigdata(sigdata); + return NULL; + } + } + } - free(buffer); - free(component); + free(buffer); + free(component); - _dumb_it_fix_invalid_orders(sigdata); + _dumb_it_fix_invalid_orders(sigdata); - return sigdata; + return sigdata; } -DUH *dumb_read_ptm_quick(DUMBFILE *f) -{ - sigdata_t *sigdata; +DUH *dumb_read_ptm_quick(DUMBFILE *f) { + sigdata_t *sigdata; - DUH_SIGTYPE_DESC *descptr = &_dumb_sigtype_it; + DUH_SIGTYPE_DESC *descptr = &_dumb_sigtype_it; - sigdata = it_ptm_load_sigdata(f); + sigdata = it_ptm_load_sigdata(f); - if (!sigdata) - return NULL; + if (!sigdata) + return NULL; - { - const char *tag[2][2]; - tag[0][0] = "TITLE"; + { + const char *tag[2][2]; + tag[0][0] = "TITLE"; tag[0][1] = (const char *)(((DUMB_IT_SIGDATA *)sigdata)->name); - tag[1][0] = "FORMAT"; - tag[1][1] = "PTM"; - return make_duh(-1, 2, (const char *const (*)[2])tag, 1, &descptr, &sigdata); - } + tag[1][0] = "FORMAT"; + tag[1][1] = "PTM"; + return make_duh(-1, 2, (const char *const(*)[2])tag, 1, &descptr, + &sigdata); + } } diff --git a/Frameworks/Dumb/dumb/src/it/readriff.c b/Frameworks/Dumb/dumb/src/it/readriff.c index 1dd852d76..4e4ab7a29 100644 --- a/Frameworks/Dumb/dumb/src/it/readriff.c +++ b/Frameworks/Dumb/dumb/src/it/readriff.c @@ -21,37 +21,38 @@ #include "internal/it.h" #include "internal/riff.h" - -DUH *dumb_read_riff_amff( DUMBFILE * f, struct riff * stream ); -DUH *dumb_read_riff_am( DUMBFILE * f, struct riff * stream ); -DUH *dumb_read_riff_dsmf( DUMBFILE * f, struct riff * stream ); +DUH *dumb_read_riff_amff(DUMBFILE *f, struct riff *stream); +DUH *dumb_read_riff_am(DUMBFILE *f, struct riff *stream); +DUH *dumb_read_riff_dsmf(DUMBFILE *f, struct riff *stream); /* dumb_read_riff_quick(): reads a RIFF file into a DUH struct, returning a * pointer to the DUH struct. When you have finished with it, you must pass * the pointer to unload_duh() so that the memory can be freed. */ -DUH *dumb_read_riff_quick( DUMBFILE * f ) -{ - DUH * duh; - struct riff * stream; +DUH *dumb_read_riff_quick(DUMBFILE *f) { + DUH *duh; + struct riff *stream; long size; size = dumbfile_get_size(f); - stream = riff_parse( f, 0, size, 1 ); - if ( ! stream ) stream = riff_parse( f, 0, size, 0 ); + stream = riff_parse(f, 0, size, 1); + if (!stream) + stream = riff_parse(f, 0, size, 0); - if ( ! stream ) return 0; + if (!stream) + return 0; - if ( stream->type == DUMB_ID( 'A', 'M', ' ', ' ' ) ) - duh = dumb_read_riff_am( f, stream ); - else if ( stream->type == DUMB_ID( 'A', 'M', 'F', 'F' ) ) - duh = dumb_read_riff_amff( f, stream ); - else if ( stream->type == DUMB_ID( 'D', 'S', 'M', 'F' ) ) - duh = dumb_read_riff_dsmf( f, stream ); - else duh = 0; + if (stream->type == DUMB_ID('A', 'M', ' ', ' ')) + duh = dumb_read_riff_am(f, stream); + else if (stream->type == DUMB_ID('A', 'M', 'F', 'F')) + duh = dumb_read_riff_amff(f, stream); + else if (stream->type == DUMB_ID('D', 'S', 'M', 'F')) + duh = dumb_read_riff_dsmf(f, stream); + else + duh = 0; - riff_free( stream ); + riff_free(stream); - return duh; + return duh; } diff --git a/Frameworks/Dumb/dumb/src/it/reads3m.c b/Frameworks/Dumb/dumb/src/it/reads3m.c index a1b1f7f68..82bb0daac 100644 --- a/Frameworks/Dumb/dumb/src/it/reads3m.c +++ b/Frameworks/Dumb/dumb/src/it/reads3m.c @@ -24,743 +24,753 @@ #include "dumb.h" #include "internal/it.h" -static int it_s3m_read_sample_header(IT_SAMPLE *sample, long *offset, unsigned char *pack, int cwtv, DUMBFILE *f) -{ - unsigned char type; - int flags; +static int it_s3m_read_sample_header(IT_SAMPLE *sample, long *offset, + unsigned char *pack, int cwtv, + DUMBFILE *f) { + unsigned char type; + int flags; - type = dumbfile_getc(f); + type = dumbfile_getc(f); dumbfile_getnc((char *)sample->filename, 12, f); - sample->filename[12] = 0; + sample->filename[12] = 0; - if (type > 1) { - /** WARNING: no adlib support */ - dumbfile_skip(f, 3 + 12 + 1 + 1 + 2 + 2 + 2 + 12); + if (type > 1) { + /** WARNING: no adlib support */ + dumbfile_skip(f, 3 + 12 + 1 + 1 + 2 + 2 + 2 + 12); dumbfile_getnc((char *)sample->name, 28, f); - sample->name[28] = 0; - dumbfile_skip(f, 4); - sample->flags &= ~IT_SAMPLE_EXISTS; - return dumbfile_error(f); - } + sample->name[28] = 0; + dumbfile_skip(f, 4); + sample->flags &= ~IT_SAMPLE_EXISTS; + return dumbfile_error(f); + } - *offset = dumbfile_getc(f) << 20; - *offset += dumbfile_igetw(f) << 4; + *offset = dumbfile_getc(f) << 20; + *offset += dumbfile_igetw(f) << 4; - sample->length = dumbfile_igetl(f); - sample->loop_start = dumbfile_igetl(f); - sample->loop_end = dumbfile_igetl(f); + sample->length = dumbfile_igetl(f); + sample->loop_start = dumbfile_igetl(f); + sample->loop_end = dumbfile_igetl(f); - sample->default_volume = dumbfile_getc(f); + sample->default_volume = dumbfile_getc(f); - dumbfile_skip(f, 1); + dumbfile_skip(f, 1); - flags = dumbfile_getc(f); + flags = dumbfile_getc(f); - if (flags < 0 || (flags != 0 && flags != 4)) - /* Sample is packed apparently (or error reading from file). We don't - * know how to read packed samples. - */ - return -1; + if (flags < 0 || (flags != 0 && flags != 4)) + /* Sample is packed apparently (or error reading from file). We don't + * know how to read packed samples. + */ + return -1; - *pack = flags; + *pack = flags; - flags = dumbfile_getc(f); + flags = dumbfile_getc(f); - sample->C5_speed = dumbfile_igetl(f) << 1; + sample->C5_speed = dumbfile_igetl(f) << 1; - /* Skip four unused bytes and three internal variables. */ - dumbfile_skip(f, 4+2+2+4); + /* Skip four unused bytes and three internal variables. */ + dumbfile_skip(f, 4 + 2 + 2 + 4); dumbfile_getnc((char *)sample->name, 28, f); - sample->name[28] = 0; + sample->name[28] = 0; - if (type == 0 || sample->length <= 0) { - /* Looks like no-existy. Anyway, there's for sure no 'SCRS' ... */ - sample->flags &= ~IT_SAMPLE_EXISTS; - return dumbfile_error(f); - } + if (type == 0 || sample->length <= 0) { + /* Looks like no-existy. Anyway, there's for sure no 'SCRS' ... */ + sample->flags &= ~IT_SAMPLE_EXISTS; + return dumbfile_error(f); + } - if (dumbfile_mgetl(f) != DUMB_ID('S','C','R','S')) - return -1; + if (dumbfile_mgetl(f) != DUMB_ID('S', 'C', 'R', 'S')) + return -1; - sample->global_volume = 64; + sample->global_volume = 64; - sample->flags = IT_SAMPLE_EXISTS; - if (flags & 1) sample->flags |= IT_SAMPLE_LOOP; + sample->flags = IT_SAMPLE_EXISTS; + if (flags & 1) + sample->flags |= IT_SAMPLE_LOOP; - /* The ST3 TECH.DOC is unclear on this, but IMAGO Orpheus is not. Piece of crap. */ + /* The ST3 TECH.DOC is unclear on this, but IMAGO Orpheus is not. Piece of + * crap. */ - if (flags & 2) { - sample->flags |= IT_SAMPLE_STEREO; + if (flags & 2) { + sample->flags |= IT_SAMPLE_STEREO; - if ((cwtv & 0xF000) == 0x2000) { - sample->length >>= 1; - sample->loop_start >>= 1; - sample->loop_end >>= 1; - } - } + if ((cwtv & 0xF000) == 0x2000) { + sample->length >>= 1; + sample->loop_start >>= 1; + sample->loop_end >>= 1; + } + } - if (flags & 4) { - sample->flags |= IT_SAMPLE_16BIT; + if (flags & 4) { + sample->flags |= IT_SAMPLE_16BIT; - if ((cwtv & 0xF000) == 0x2000) { - sample->length >>= 1; - sample->loop_start >>= 1; - sample->loop_end >>= 1; - } - } + if ((cwtv & 0xF000) == 0x2000) { + sample->length >>= 1; + sample->loop_start >>= 1; + sample->loop_end >>= 1; + } + } - sample->default_pan = 0; // 0 = don't use, or 160 = centre? + sample->default_pan = 0; // 0 = don't use, or 160 = centre? - if (sample->flags & IT_SAMPLE_LOOP) { - if ((unsigned int)sample->loop_end > (unsigned int)sample->length) - /*sample->flags &= ~IT_SAMPLE_LOOP;*/ - sample->loop_end = sample->length; - else if ((unsigned int)sample->loop_start >= (unsigned int)sample->loop_end) - sample->flags &= ~IT_SAMPLE_LOOP; - else - /* ScreamTracker seems not to save what comes after the loop end - * point, but rather to assume it is a duplicate of what comes at - * the loop start point. I am not completely sure of this though. - * It is easy to evade; simply truncate the sample. - */ - sample->length = sample->loop_end; - } + if (sample->flags & IT_SAMPLE_LOOP) { + if ((unsigned int)sample->loop_end > (unsigned int)sample->length) + /*sample->flags &= ~IT_SAMPLE_LOOP;*/ + sample->loop_end = sample->length; + else if ((unsigned int)sample->loop_start >= + (unsigned int)sample->loop_end) + sample->flags &= ~IT_SAMPLE_LOOP; + else + /* ScreamTracker seems not to save what comes after the loop end + * point, but rather to assume it is a duplicate of what comes at + * the loop start point. I am not completely sure of this though. + * It is easy to evade; simply truncate the sample. + */ + sample->length = sample->loop_end; + } + // Do we need to set all these? + sample->vibrato_speed = 0; + sample->vibrato_depth = 0; + sample->vibrato_rate = 0; + sample->vibrato_waveform = IT_VIBRATO_SINE; + sample->finetune = 0; + sample->max_resampling_quality = -1; - //Do we need to set all these? - sample->vibrato_speed = 0; - sample->vibrato_depth = 0; - sample->vibrato_rate = 0; - sample->vibrato_waveform = IT_VIBRATO_SINE; - sample->finetune = 0; - sample->max_resampling_quality = -1; - - return dumbfile_error(f); + return dumbfile_error(f); } +static int it_s3m_read_sample_data(IT_SAMPLE *sample, int ffi, + unsigned char pack, DUMBFILE *f) { + long n; + long datasize = sample->length; + if (sample->flags & IT_SAMPLE_STEREO) + datasize <<= 1; -static int it_s3m_read_sample_data(IT_SAMPLE *sample, int ffi, unsigned char pack, DUMBFILE *f) -{ - long n; + sample->data = malloc(datasize * (sample->flags & IT_SAMPLE_16BIT ? 2 : 1)); + if (!sample->data) + return -1; - long datasize = sample->length; - if (sample->flags & IT_SAMPLE_STEREO) datasize <<= 1; + if (pack == 4) { + if (_dumb_it_read_sample_data_adpcm4(sample, f) < 0) + return -1; + } else if (sample->flags & IT_SAMPLE_STEREO) { + if (sample->flags & IT_SAMPLE_16BIT) { + for (n = 0; n < datasize; n += 2) + ((short *)sample->data)[n] = dumbfile_igetw(f); + for (n = 1; n < datasize; n += 2) + ((short *)sample->data)[n] = dumbfile_igetw(f); + } else { + for (n = 0; n < datasize; n += 2) + ((signed char *)sample->data)[n] = dumbfile_getc(f); + for (n = 1; n < datasize; n += 2) + ((signed char *)sample->data)[n] = dumbfile_getc(f); + } + } else if (sample->flags & IT_SAMPLE_16BIT) + for (n = 0; n < sample->length; n++) + ((short *)sample->data)[n] = dumbfile_igetw(f); + else + for (n = 0; n < sample->length; n++) + ((signed char *)sample->data)[n] = dumbfile_getc(f); - sample->data = malloc(datasize * (sample->flags & IT_SAMPLE_16BIT ? 2 : 1)); - if (!sample->data) - return -1; + if (dumbfile_error(f)) + return -1; - if (pack == 4) { - if (_dumb_it_read_sample_data_adpcm4(sample, f) < 0) - return -1; - } - else if (sample->flags & IT_SAMPLE_STEREO) { - if (sample->flags & IT_SAMPLE_16BIT) { - for (n = 0; n < datasize; n += 2) - ((short *)sample->data)[n] = dumbfile_igetw(f); - for (n = 1; n < datasize; n += 2) - ((short *)sample->data)[n] = dumbfile_igetw(f); - } else { - for (n = 0; n < datasize; n += 2) - ((signed char *)sample->data)[n] = dumbfile_getc(f); - for (n = 1; n < datasize; n += 2) - ((signed char *)sample->data)[n] = dumbfile_getc(f); - } - } else if (sample->flags & IT_SAMPLE_16BIT) - for (n = 0; n < sample->length; n++) - ((short *)sample->data)[n] = dumbfile_igetw(f); - else - for (n = 0; n < sample->length; n++) - ((signed char *)sample->data)[n] = dumbfile_getc(f); + if (ffi != 1) { + /* Convert to signed. */ + if (sample->flags & IT_SAMPLE_16BIT) + for (n = 0; n < datasize; n++) + ((short *)sample->data)[n] ^= 0x8000; + else + for (n = 0; n < datasize; n++) + ((signed char *)sample->data)[n] ^= 0x80; + } - if (dumbfile_error(f)) - return -1; - - if (ffi != 1) { - /* Convert to signed. */ - if (sample->flags & IT_SAMPLE_16BIT) - for (n = 0; n < datasize; n++) - ((short *)sample->data)[n] ^= 0x8000; - else - for (n = 0; n < datasize; n++) - ((signed char *)sample->data)[n] ^= 0x80; - } - - return 0; + return 0; } +static int it_s3m_read_pattern(IT_PATTERN *pattern, DUMBFILE *f, + unsigned char *buffer) { + int length; + int buflen = 0; + int bufpos = 0; + IT_ENTRY *entry; -static int it_s3m_read_pattern(IT_PATTERN *pattern, DUMBFILE *f, unsigned char *buffer) -{ - int length; - int buflen = 0; - int bufpos = 0; + unsigned char channel; - IT_ENTRY *entry; - - unsigned char channel; - - /* Haha, this is hilarious! - * - * Well, after some experimentation, it seems that different S3M writers - * define the format in different ways. The S3M docs say that the first - * two bytes hold the "length of [the] packed pattern", and the packed - * pattern data follow. Judging by the contents of ARMANI.S3M, packaged - * with ScreamTracker itself, the measure of length _includes_ the two - * bytes used to store the length; in other words, we should read - * (length - 2) more bytes. However, aryx.s3m, packaged with ModPlug - * Tracker, excludes these two bytes, so (length) more bytes must be - * read. - * - * Call me crazy, but I just find it insanely funny that the format was - * misunderstood in this way :D - * - * Now we can't just risk reading two extra bytes, because then we - * overshoot, and DUMBFILEs don't support backward seeking (for a good - * reason). Luckily, there is a way. We can read the data little by - * little, and stop when we have 64 rows in memory. Provided we protect - * against buffer overflow, this method should work with all sensibly - * written S3M files. If you find one for which it does not work, please - * let me know at entheh@users.sf.net so I can look at it. + /* Haha, this is hilarious! + * + * Well, after some experimentation, it seems that different S3M writers + * define the format in different ways. The S3M docs say that the first + * two bytes hold the "length of [the] packed pattern", and the packed + * pattern data follow. Judging by the contents of ARMANI.S3M, packaged + * with ScreamTracker itself, the measure of length _includes_ the two + * bytes used to store the length; in other words, we should read + * (length - 2) more bytes. However, aryx.s3m, packaged with ModPlug + * Tracker, excludes these two bytes, so (length) more bytes must be + * read. + * + * Call me crazy, but I just find it insanely funny that the format was + * misunderstood in this way :D + * + * Now we can't just risk reading two extra bytes, because then we + * overshoot, and DUMBFILEs don't support backward seeking (for a good + * reason). Luckily, there is a way. We can read the data little by + * little, and stop when we have 64 rows in memory. Provided we protect + * against buffer overflow, this method should work with all sensibly + * written S3M files. If you find one for which it does not work, please + * let me know at entheh@users.sf.net so I can look at it. * * "for a good reason" ? What's this nonsense? -kode54 * - */ + */ - length = dumbfile_igetw(f); - - if (dumbfile_error(f) || !length) - return -1; + length = dumbfile_igetw(f); - pattern->n_rows = 0; - pattern->n_entries = 0; + if (dumbfile_error(f) || !length) + return -1; - /* Read in the pattern data, little by little, and work out how many - * entries we need room for. Sorry, but this is just so funny... - */ - for (;;) { - unsigned char b = buffer[buflen++] = dumbfile_getc(f); + pattern->n_rows = 0; + pattern->n_entries = 0; + + /* Read in the pattern data, little by little, and work out how many + * entries we need room for. Sorry, but this is just so funny... + */ + for (;;) { + unsigned char b = buffer[buflen++] = dumbfile_getc(f); #if 1 - static const unsigned char used[8] = {0, 2, 1, 3, 2, 4, 3, 5}; - channel = b & 31; - b >>= 5; - pattern->n_entries++; - if (b) { - if (buflen + used[b] >= 65536) return -1; - if (buflen + used[b] <= length) + static const unsigned char used[8] = {0, 2, 1, 3, 2, 4, 3, 5}; + channel = b & 31; + b >>= 5; + pattern->n_entries++; + if (b) { + if (buflen + used[b] >= 65536) + return -1; + if (buflen + used[b] <= length) dumbfile_getnc((char *)buffer + buflen, used[b], f); - else - memset(buffer + buflen, 0, used[b]); - buflen += used[b]; - } else { - /* End of row */ - if (++pattern->n_rows == 64) break; - if (buflen >= 65536) return -1; - } + else + memset(buffer + buflen, 0, used[b]); + buflen += used[b]; + } else { + /* End of row */ + if (++pattern->n_rows == 64) + break; + if (buflen >= 65536) + return -1; + } #else - if (b == 0) { - /* End of row */ - pattern->n_entries++; - if (++pattern->n_rows == 64) break; - if (buflen >= 65536) return -1; - } else { - static const unsigned char used[8] = {0, 2, 1, 3, 2, 4, 3, 5}; - channel = b & 31; - b >>= 5; - if (b) { - pattern->n_entries++; - if (buflen + used[b] >= 65536) return -1; - dumbfile_getnc(buffer + buflen, used[b], f); - buflen += used[b]; - } - } + if (b == 0) { + /* End of row */ + pattern->n_entries++; + if (++pattern->n_rows == 64) + break; + if (buflen >= 65536) + return -1; + } else { + static const unsigned char used[8] = {0, 2, 1, 3, 2, 4, 3, 5}; + channel = b & 31; + b >>= 5; + if (b) { + pattern->n_entries++; + if (buflen + used[b] >= 65536) + return -1; + dumbfile_getnc(buffer + buflen, used[b], f); + buflen += used[b]; + } + } #endif - /* We have ensured that buflen < 65536 at this point, so it is safe - * to iterate and read at least one more byte without checking. - * However, now would be a good time to check for errors reading from - * the file. - */ + /* We have ensured that buflen < 65536 at this point, so it is safe + * to iterate and read at least one more byte without checking. + * However, now would be a good time to check for errors reading from + * the file. + */ - if (dumbfile_error(f)) - return -1; + if (dumbfile_error(f)) + return -1; - /* Great. We ran out of data, but there should be data for more rows. - * Fill the rest with null data... - */ - if (buflen >= length && pattern->n_rows < 64) - { - while (pattern->n_rows < 64) - { - if (buflen >= 65536) return -1; - buffer[buflen++] = 0; - pattern->n_entries++; - pattern->n_rows++; - } - break; - } - } + /* Great. We ran out of data, but there should be data for more rows. + * Fill the rest with null data... + */ + if (buflen >= length && pattern->n_rows < 64) { + while (pattern->n_rows < 64) { + if (buflen >= 65536) + return -1; + buffer[buflen++] = 0; + pattern->n_entries++; + pattern->n_rows++; + } + break; + } + } - pattern->entry = malloc(pattern->n_entries * sizeof(*pattern->entry)); + pattern->entry = malloc(pattern->n_entries * sizeof(*pattern->entry)); - if (!pattern->entry) - return -1; + if (!pattern->entry) + return -1; - entry = pattern->entry; + entry = pattern->entry; - while (bufpos < buflen) { - unsigned char b = buffer[bufpos++]; + while (bufpos < buflen) { + unsigned char b = buffer[bufpos++]; #if 1 - if (!(b & ~31)) + if (!(b & ~31)) #else - if (b == 0) + if (b == 0) #endif - { - /* End of row */ - IT_SET_END_ROW(entry); - entry++; - continue; - } + { + /* End of row */ + IT_SET_END_ROW(entry); + entry++; + continue; + } - channel = b & 31; + channel = b & 31; - if (b & 224) { - entry->mask = 0; - entry->channel = channel; + if (b & 224) { + entry->mask = 0; + entry->channel = channel; - if (b & 32) { - unsigned char n = buffer[bufpos++]; - if (n != 255) { - if (n == 254) - entry->note = IT_NOTE_CUT; - else - entry->note = (n >> 4) * 12 + (n & 15); - entry->mask |= IT_ENTRY_NOTE; - } + if (b & 32) { + unsigned char n = buffer[bufpos++]; + if (n != 255) { + if (n == 254) + entry->note = IT_NOTE_CUT; + else + entry->note = (n >> 4) * 12 + (n & 15); + entry->mask |= IT_ENTRY_NOTE; + } - entry->instrument = buffer[bufpos++]; - if (entry->instrument) - entry->mask |= IT_ENTRY_INSTRUMENT; - } + entry->instrument = buffer[bufpos++]; + if (entry->instrument) + entry->mask |= IT_ENTRY_INSTRUMENT; + } - if (b & 64) { - entry->volpan = buffer[bufpos++]; - if (entry->volpan != 255) - entry->mask |= IT_ENTRY_VOLPAN; - } + if (b & 64) { + entry->volpan = buffer[bufpos++]; + if (entry->volpan != 255) + entry->mask |= IT_ENTRY_VOLPAN; + } - if (b & 128) { - entry->effect = buffer[bufpos++]; - entry->effectvalue = buffer[bufpos++]; - // XXX woot - if (entry->effect && entry->effect < IT_MIDI_MACRO /*!= 255*/) { - entry->mask |= IT_ENTRY_EFFECT; - switch (entry->effect) { - case IT_BREAK_TO_ROW: - entry->effectvalue -= (entry->effectvalue >> 4) * 6; - break; + if (b & 128) { + entry->effect = buffer[bufpos++]; + entry->effectvalue = buffer[bufpos++]; + // XXX woot + if (entry->effect && entry->effect < IT_MIDI_MACRO /*!= 255*/) { + entry->mask |= IT_ENTRY_EFFECT; + switch (entry->effect) { + case IT_BREAK_TO_ROW: + entry->effectvalue -= (entry->effectvalue >> 4) * 6; + break; - case IT_SET_CHANNEL_VOLUME: - case IT_CHANNEL_VOLUME_SLIDE: - case IT_PANNING_SLIDE: - case IT_GLOBAL_VOLUME_SLIDE: - case IT_PANBRELLO: - case IT_MIDI_MACRO: - entry->mask &= ~IT_ENTRY_EFFECT; - break; + case IT_SET_CHANNEL_VOLUME: + case IT_CHANNEL_VOLUME_SLIDE: + case IT_PANNING_SLIDE: + case IT_GLOBAL_VOLUME_SLIDE: + case IT_PANBRELLO: + case IT_MIDI_MACRO: + entry->mask &= ~IT_ENTRY_EFFECT; + break; - case IT_S: - switch (entry->effectvalue >> 4) { - case IT_S_SET_PANBRELLO_WAVEFORM: - case IT_S_FINE_PATTERN_DELAY: - case IT_S7: - case IT_S_SET_SURROUND_SOUND: - case IT_S_SET_MIDI_MACRO: - entry->mask &= ~IT_ENTRY_EFFECT; - break; - } - break; - } - } - /** WARNING: ARGH! CONVERT TEH EFFECTS!@~ */ - } + case IT_S: + switch (entry->effectvalue >> 4) { + case IT_S_SET_PANBRELLO_WAVEFORM: + case IT_S_FINE_PATTERN_DELAY: + case IT_S7: + case IT_S_SET_SURROUND_SOUND: + case IT_S_SET_MIDI_MACRO: + entry->mask &= ~IT_ENTRY_EFFECT; + break; + } + break; + } + } + /** WARNING: ARGH! CONVERT TEH EFFECTS!@~ */ + } - entry++; - } - } + entry++; + } + } - ASSERT(entry == pattern->entry + pattern->n_entries); + ASSERT(entry == pattern->entry + pattern->n_entries); - return 0; + return 0; } - - -/** WARNING: this is duplicated in itread.c - also bad practice to use the same struct name unless they are unified in a header */ +/** WARNING: this is duplicated in itread.c - also bad practice to use the same + * struct name unless they are unified in a header */ /* Currently we assume the sample data are stored after the sample headers in * module files. This assumption may be unjustified; let me know if you have * trouble. */ #define S3M_COMPONENT_INSTRUMENT 1 -#define S3M_COMPONENT_PATTERN 2 -#define S3M_COMPONENT_SAMPLE 3 +#define S3M_COMPONENT_PATTERN 2 +#define S3M_COMPONENT_SAMPLE 3 -typedef struct S3M_COMPONENT -{ - unsigned char type; - unsigned char n; - long offset; - short sampfirst; /* component[sampfirst] = first sample data after this */ - short sampnext; /* sampnext is used to create linked lists of sample data */ -} -S3M_COMPONENT; +typedef struct S3M_COMPONENT { + unsigned char type; + unsigned char n; + long offset; + short sampfirst; /* component[sampfirst] = first sample data after this */ + short sampnext; /* sampnext is used to create linked lists of sample data */ +} S3M_COMPONENT; - - -static int s3m_component_compare(const void *e1, const void *e2) -{ - return ((const S3M_COMPONENT *)e1)->offset - - ((const S3M_COMPONENT *)e2)->offset; +static int s3m_component_compare(const void *e1, const void *e2) { + return (int)(((const S3M_COMPONENT *)e1)->offset - + ((const S3M_COMPONENT *)e2)->offset); } +static DUMB_IT_SIGDATA *it_s3m_load_sigdata(DUMBFILE *f, int *cwtv) { + DUMB_IT_SIGDATA *sigdata; + int flags, ffi; + int default_pan_present; -static DUMB_IT_SIGDATA *it_s3m_load_sigdata(DUMBFILE *f, int * cwtv) -{ - DUMB_IT_SIGDATA *sigdata; + int master_volume; - int flags, ffi; - int default_pan_present; + unsigned char sample_pack[256]; - int master_volume; + S3M_COMPONENT *component; + int n_components = 0; - unsigned char sample_pack[256]; + int n; - S3M_COMPONENT *component; - int n_components = 0; + unsigned char *buffer; - int n; - - unsigned char *buffer; - - sigdata = malloc(sizeof(*sigdata)); - if (!sigdata) return NULL; + sigdata = malloc(sizeof(*sigdata)); + if (!sigdata) + return NULL; dumbfile_getnc((char *)sigdata->name, 28, f); - sigdata->name[28] = 0; + sigdata->name[28] = 0; - n = dumbfile_getc(f); + n = dumbfile_getc(f); - if (n != 0x1A && n != 0) { - free(sigdata); - return NULL; - } + if (n != 0x1A && n != 0) { + free(sigdata); + return NULL; + } - if (dumbfile_getc(f) != 16) { - free(sigdata); - return NULL; - } + if (dumbfile_getc(f) != 16) { + free(sigdata); + return NULL; + } - dumbfile_skip(f, 2); + dumbfile_skip(f, 2); - sigdata->song_message = NULL; - sigdata->order = NULL; - sigdata->instrument = NULL; - sigdata->sample = NULL; - sigdata->pattern = NULL; - sigdata->midi = NULL; - sigdata->checkpoint = NULL; + sigdata->song_message = NULL; + sigdata->order = NULL; + sigdata->instrument = NULL; + sigdata->sample = NULL; + sigdata->pattern = NULL; + sigdata->midi = NULL; + sigdata->checkpoint = NULL; - sigdata->n_orders = dumbfile_igetw(f); - sigdata->n_instruments = 0; - sigdata->n_samples = dumbfile_igetw(f); - sigdata->n_patterns = dumbfile_igetw(f); + sigdata->n_orders = dumbfile_igetw(f); + sigdata->n_instruments = 0; + sigdata->n_samples = dumbfile_igetw(f); + sigdata->n_patterns = dumbfile_igetw(f); - if (dumbfile_error(f) || sigdata->n_orders <= 0 || sigdata->n_samples > 256 || sigdata->n_patterns > 256) { - _dumb_it_unload_sigdata(sigdata); - return NULL; - } + if (dumbfile_error(f) || sigdata->n_orders <= 0 || + sigdata->n_samples > 256 || sigdata->n_patterns > 256) { + _dumb_it_unload_sigdata(sigdata); + return NULL; + } - sigdata->order = malloc(sigdata->n_orders); - if (!sigdata->order) { - _dumb_it_unload_sigdata(sigdata); - return NULL; - } + sigdata->order = malloc(sigdata->n_orders); + if (!sigdata->order) { + _dumb_it_unload_sigdata(sigdata); + return NULL; + } - if (sigdata->n_samples) { - sigdata->sample = malloc(sigdata->n_samples * sizeof(*sigdata->sample)); - if (!sigdata->sample) { - _dumb_it_unload_sigdata(sigdata); - return NULL; - } - for (n = 0; n < sigdata->n_samples; n++) - sigdata->sample[n].data = NULL; - } + if (sigdata->n_samples) { + sigdata->sample = malloc(sigdata->n_samples * sizeof(*sigdata->sample)); + if (!sigdata->sample) { + _dumb_it_unload_sigdata(sigdata); + return NULL; + } + for (n = 0; n < sigdata->n_samples; n++) + sigdata->sample[n].data = NULL; + } - if (sigdata->n_patterns) { - sigdata->pattern = malloc(sigdata->n_patterns * sizeof(*sigdata->pattern)); - if (!sigdata->pattern) { - _dumb_it_unload_sigdata(sigdata); - return NULL; - } - for (n = 0; n < sigdata->n_patterns; n++) - sigdata->pattern[n].entry = NULL; - } + if (sigdata->n_patterns) { + sigdata->pattern = + malloc(sigdata->n_patterns * sizeof(*sigdata->pattern)); + if (!sigdata->pattern) { + _dumb_it_unload_sigdata(sigdata); + return NULL; + } + for (n = 0; n < sigdata->n_patterns; n++) + sigdata->pattern[n].entry = NULL; + } - flags = dumbfile_igetw(f); + flags = dumbfile_igetw(f); - *cwtv = dumbfile_igetw(f); + *cwtv = dumbfile_igetw(f); - if (*cwtv == 0x1300) { - /** WARNING: volume slides on every frame */ - } + if (*cwtv == 0x1300) { + /** WARNING: volume slides on every frame */ + } - ffi = dumbfile_igetw(f); + ffi = dumbfile_igetw(f); - /** WARNING: which ones? */ - sigdata->flags = IT_OLD_EFFECTS | IT_COMPATIBLE_GXX | IT_WAS_AN_S3M; + /** WARNING: which ones? */ + sigdata->flags = IT_OLD_EFFECTS | IT_COMPATIBLE_GXX | IT_WAS_AN_S3M; - if (dumbfile_mgetl(f) != DUMB_ID('S','C','R','M')) { - _dumb_it_unload_sigdata(sigdata); - return NULL; - } + if (dumbfile_mgetl(f) != DUMB_ID('S', 'C', 'R', 'M')) { + _dumb_it_unload_sigdata(sigdata); + return NULL; + } - sigdata->global_volume = dumbfile_getc(f); - if ( !sigdata->global_volume || sigdata->global_volume > 64 ) sigdata->global_volume = 64; - sigdata->speed = dumbfile_getc(f); - if (sigdata->speed == 0) sigdata->speed = 6; // Should we? What about tempo? - sigdata->tempo = dumbfile_getc(f); - master_volume = dumbfile_getc(f); // 7 bits; +128 for stereo - sigdata->mixing_volume = master_volume & 127; + sigdata->global_volume = dumbfile_getc(f); + if (!sigdata->global_volume || sigdata->global_volume > 64) + sigdata->global_volume = 64; + sigdata->speed = dumbfile_getc(f); + if (sigdata->speed == 0) + sigdata->speed = 6; // Should we? What about tempo? + sigdata->tempo = dumbfile_getc(f); + master_volume = dumbfile_getc(f); // 7 bits; +128 for stereo + sigdata->mixing_volume = master_volume & 127; - if (master_volume & 128) sigdata->flags |= IT_STEREO; + if (master_volume & 128) + sigdata->flags |= IT_STEREO; - /* Skip GUS Ultra Click Removal byte. */ - dumbfile_getc(f); + /* Skip GUS Ultra Click Removal byte. */ + dumbfile_getc(f); - default_pan_present = dumbfile_getc(f); + default_pan_present = dumbfile_getc(f); - dumbfile_skip(f, 8); + dumbfile_skip(f, 8); - /* Skip Special Custom Data Pointer. */ - /** WARNING: investigate this? */ - dumbfile_igetw(f); + /* Skip Special Custom Data Pointer. */ + /** WARNING: investigate this? */ + dumbfile_igetw(f); - sigdata->n_pchannels = 0; - /* Channel settings for 32 channels, 255=unused, +128=disabled */ - { - int i; - int sep = (7 * dumb_it_default_panning_separation + 50) / 100; - for (i = 0; i < 32; i++) { - int c = dumbfile_getc(f); - if (!(c & (128 | 16))) { /* +128=disabled, +16=Adlib */ - if (sigdata->n_pchannels < i + 1) sigdata->n_pchannels = i + 1; - sigdata->channel_volume[i] = 64; - sigdata->channel_pan[i] = c & 8 ? 7 + sep : 7 - sep; - /** WARNING: ah, but it should be 7 for mono... */ - } else { - /** WARNING: this could be improved if we support channel muting... */ - sigdata->channel_volume[i] = 0; - sigdata->channel_pan[i] = 7; - } - } - } + sigdata->n_pchannels = 0; + /* Channel settings for 32 channels, 255=unused, +128=disabled */ + { + int i; + int sep = (7 * dumb_it_default_panning_separation + 50) / 100; + for (i = 0; i < 32; i++) { + int c = dumbfile_getc(f); + if (!(c & (128 | 16))) { /* +128=disabled, +16=Adlib */ + if (sigdata->n_pchannels < i + 1) + sigdata->n_pchannels = i + 1; + sigdata->channel_volume[i] = 64; + sigdata->channel_pan[i] = c & 8 ? 7 + sep : 7 - sep; + /** WARNING: ah, but it should be 7 for mono... */ + } else { + /** WARNING: this could be improved if we support channel + * muting... */ + sigdata->channel_volume[i] = 0; + sigdata->channel_pan[i] = 7; + } + } + } - /* Orders, byte each, length = sigdata->n_orders (should be even) */ + /* Orders, byte each, length = sigdata->n_orders (should be even) */ dumbfile_getnc((char *)sigdata->order, sigdata->n_orders, f); - sigdata->restart_position = 0; + sigdata->restart_position = 0; - component = malloc(768*sizeof(*component)); - if (!component) { - _dumb_it_unload_sigdata(sigdata); - return NULL; - } + component = malloc(768 * sizeof(*component)); + if (!component) { + _dumb_it_unload_sigdata(sigdata); + return NULL; + } - for (n = 0; n < sigdata->n_samples; n++) { - component[n_components].type = S3M_COMPONENT_SAMPLE; - component[n_components].n = n; - component[n_components].offset = dumbfile_igetw(f) << 4; - component[n_components].sampfirst = -1; - n_components++; - } + for (n = 0; n < sigdata->n_samples; n++) { + component[n_components].type = S3M_COMPONENT_SAMPLE; + component[n_components].n = n; + component[n_components].offset = dumbfile_igetw(f) << 4; + component[n_components].sampfirst = -1; + n_components++; + } - for (n = 0; n < sigdata->n_patterns; n++) { - long offset = dumbfile_igetw(f) << 4; - if (offset) { - component[n_components].type = S3M_COMPONENT_PATTERN; - component[n_components].n = n; - component[n_components].offset = offset; - component[n_components].sampfirst = -1; - n_components++; - } else { - /** WARNING: Empty 64-row pattern ... ? (this does happen!) */ - sigdata->pattern[n].n_rows = 64; - sigdata->pattern[n].n_entries = 0; - } - } + for (n = 0; n < sigdata->n_patterns; n++) { + long offset = dumbfile_igetw(f) << 4; + if (offset) { + component[n_components].type = S3M_COMPONENT_PATTERN; + component[n_components].n = n; + component[n_components].offset = offset; + component[n_components].sampfirst = -1; + n_components++; + } else { + /** WARNING: Empty 64-row pattern ... ? (this does happen!) */ + sigdata->pattern[n].n_rows = 64; + sigdata->pattern[n].n_entries = 0; + } + } - qsort(component, n_components, sizeof(S3M_COMPONENT), &s3m_component_compare); + qsort(component, n_components, sizeof(S3M_COMPONENT), + &s3m_component_compare); - /* I found a really dumb S3M file that claimed to contain default pan - * data but didn't contain any. Programs would load it by reading part of - * the first instrument header, assuming the data to be default pan - * positions, and then rereading the instrument module. We cannot do this - * without obfuscating the file input model, so we insert an extra check - * here that we won't overrun the start of the first component. - */ - if (default_pan_present == 252 && component[0].offset >= dumbfile_pos(f) + 32) { - /* Channel default pan positions */ - int i; - for (i = 0; i < 32; i++) { - int c = dumbfile_getc(f); - if (c & 32) - sigdata->channel_pan[i] = c & 15; - } - } + /* I found a really dumb S3M file that claimed to contain default pan + * data but didn't contain any. Programs would load it by reading part of + * the first instrument header, assuming the data to be default pan + * positions, and then rereading the instrument module. We cannot do this + * without obfuscating the file input model, so we insert an extra check + * here that we won't overrun the start of the first component. + */ + if (default_pan_present == 252 && + component[0].offset >= dumbfile_pos(f) + 32) { + /* Channel default pan positions */ + int i; + for (i = 0; i < 32; i++) { + int c = dumbfile_getc(f); + if (c & 32) + sigdata->channel_pan[i] = c & 15; + } + } - { - int i; - for (i = 0; i < 32; i++) { - sigdata->channel_pan[i] -= (sigdata->channel_pan[i] & 8) >> 3; - sigdata->channel_pan[i] = ((int)sigdata->channel_pan[i] << 5) / 7; - } - } + { + int i; + for (i = 0; i < 32; i++) { + sigdata->channel_pan[i] -= (sigdata->channel_pan[i] & 8) >> 3; + sigdata->channel_pan[i] = ((int)sigdata->channel_pan[i] << 5) / 7; + } + } - sigdata->pan_separation = 128; + sigdata->pan_separation = 128; - if (dumbfile_error(f)) { - free(component); - _dumb_it_unload_sigdata(sigdata); - return NULL; - } + if (dumbfile_error(f)) { + free(component); + _dumb_it_unload_sigdata(sigdata); + return NULL; + } - buffer = malloc(65536); - if (!buffer) { - free(component); - _dumb_it_unload_sigdata(sigdata); - return NULL; - } + buffer = malloc(65536); + if (!buffer) { + free(component); + _dumb_it_unload_sigdata(sigdata); + return NULL; + } - for (n = 0; n < n_components; n++) { - long offset; - int m; + for (n = 0; n < n_components; n++) { + long offset; + int m; - offset = 0; + offset = 0; if (dumbfile_seek(f, component[n].offset, DFS_SEEK_SET)) { - free(buffer); - free(component); - _dumb_it_unload_sigdata(sigdata); - return NULL; - } + free(buffer); + free(component); + _dumb_it_unload_sigdata(sigdata); + return NULL; + } - switch (component[n].type) { + switch (component[n].type) { - case S3M_COMPONENT_PATTERN: - if (it_s3m_read_pattern(&sigdata->pattern[component[n].n], f, buffer)) { - free(buffer); - free(component); - _dumb_it_unload_sigdata(sigdata); - return NULL; - } - break; + case S3M_COMPONENT_PATTERN: + if (it_s3m_read_pattern(&sigdata->pattern[component[n].n], f, + buffer)) { + free(buffer); + free(component); + _dumb_it_unload_sigdata(sigdata); + return NULL; + } + break; - case S3M_COMPONENT_SAMPLE: - if (it_s3m_read_sample_header(&sigdata->sample[component[n].n], &offset, &sample_pack[component[n].n], *cwtv, f)) { - free(buffer); - free(component); - _dumb_it_unload_sigdata(sigdata); - return NULL; - } + case S3M_COMPONENT_SAMPLE: + if (it_s3m_read_sample_header(&sigdata->sample[component[n].n], + &offset, &sample_pack[component[n].n], + *cwtv, f)) { + free(buffer); + free(component); + _dumb_it_unload_sigdata(sigdata); + return NULL; + } - if (sigdata->sample[component[n].n].flags & IT_SAMPLE_EXISTS) { - short *sample; + if (sigdata->sample[component[n].n].flags & IT_SAMPLE_EXISTS) { + short *sample; - for (m = n + 1; m < n_components; m++) - if (component[m].offset > offset) - break; - m--; + for (m = n + 1; m < n_components; m++) + if (component[m].offset > offset) + break; + m--; - sample = &component[m].sampfirst; + sample = &component[m].sampfirst; - while (*sample >= 0 && component[*sample].offset <= offset) - sample = &component[*sample].sampnext; + while (*sample >= 0 && component[*sample].offset <= offset) + sample = &component[*sample].sampnext; - component[n].sampnext = *sample; - *sample = n; + component[n].sampnext = *sample; + *sample = n; - component[n].offset = offset; - } - } + component[n].offset = offset; + } + } - m = component[n].sampfirst; + m = component[n].sampfirst; - while (m >= 0) { - // XXX - if (dumbfile_seek(f, component[m].offset, DFS_SEEK_SET)) { - free(buffer); - free(component); - _dumb_it_unload_sigdata(sigdata); - return NULL; - } + while (m >= 0) { + // XXX + if (dumbfile_seek(f, component[m].offset, DFS_SEEK_SET)) { + free(buffer); + free(component); + _dumb_it_unload_sigdata(sigdata); + return NULL; + } - if (it_s3m_read_sample_data(&sigdata->sample[component[m].n], ffi, sample_pack[component[m].n], f)) { - free(buffer); - free(component); - _dumb_it_unload_sigdata(sigdata); - return NULL; - } + if (it_s3m_read_sample_data(&sigdata->sample[component[m].n], ffi, + sample_pack[component[m].n], f)) { + free(buffer); + free(component); + _dumb_it_unload_sigdata(sigdata); + return NULL; + } - m = component[m].sampnext; - } - } + m = component[m].sampnext; + } + } - free(buffer); - free(component); + free(buffer); + free(component); - _dumb_it_fix_invalid_orders(sigdata); + _dumb_it_fix_invalid_orders(sigdata); - return sigdata; + return sigdata; } -static char hexdigit(int in) -{ - if (in < 10) return in + '0'; - else return in + 'A' - 10; +static char hexdigit(int in) { + if (in < 10) + return in + '0'; + else + return in + 'A' - 10; } -DUH *dumb_read_s3m_quick(DUMBFILE *f) -{ - sigdata_t *sigdata; - int cwtv; +DUH *dumb_read_s3m_quick(DUMBFILE *f) { + sigdata_t *sigdata; + int cwtv; - DUH_SIGTYPE_DESC *descptr = &_dumb_sigtype_it; + DUH_SIGTYPE_DESC *descptr = &_dumb_sigtype_it; - sigdata = it_s3m_load_sigdata(f, &cwtv); + sigdata = it_s3m_load_sigdata(f, &cwtv); - if (!sigdata) - return NULL; + if (!sigdata) + return NULL; - { - char version[8]; - const char *tag[3][2]; - tag[0][0] = "TITLE"; + { + char version[8]; + const char *tag[3][2]; + tag[0][0] = "TITLE"; tag[0][1] = (const char *)(((DUMB_IT_SIGDATA *)sigdata)->name); - tag[1][0] = "FORMAT"; - tag[1][1] = "S3M"; - tag[2][0] = "TRACKERVERSION"; - version[0] = hexdigit((cwtv >> 8) & 15); - version[1] = '.'; - version[2] = hexdigit((cwtv >> 4) & 15); - version[3] = hexdigit(cwtv & 15); - version[4] = 0; - tag[2][1] = (const char *) &version; - return make_duh(-1, 3, (const char *const (*)[2])tag, 1, &descptr, &sigdata); - } + tag[1][0] = "FORMAT"; + tag[1][1] = "S3M"; + tag[2][0] = "TRACKERVERSION"; + version[0] = hexdigit((cwtv >> 8) & 15); + version[1] = '.'; + version[2] = hexdigit((cwtv >> 4) & 15); + version[3] = hexdigit(cwtv & 15); + version[4] = 0; + tag[2][1] = (const char *)&version; + return make_duh(-1, 3, (const char *const(*)[2])tag, 1, &descptr, + &sigdata); + } } diff --git a/Frameworks/Dumb/dumb/src/it/reads3m2.c b/Frameworks/Dumb/dumb/src/it/reads3m2.c index 0499eecde..5d4e600b2 100644 --- a/Frameworks/Dumb/dumb/src/it/reads3m2.c +++ b/Frameworks/Dumb/dumb/src/it/reads3m2.c @@ -19,11 +19,8 @@ #include "dumb.h" - - -DUH *dumb_read_s3m(DUMBFILE *f) -{ - DUH *duh = dumb_read_s3m_quick(f); - dumb_it_do_initial_runthrough(duh); - return duh; +DUH *dumb_read_s3m(DUMBFILE *f) { + DUH *duh = dumb_read_s3m_quick(f); + dumb_it_do_initial_runthrough(duh); + return duh; } diff --git a/Frameworks/Dumb/dumb/src/it/readstm.c b/Frameworks/Dumb/dumb/src/it/readstm.c index 689f0755e..0257276d7 100644 --- a/Frameworks/Dumb/dumb/src/it/readstm.c +++ b/Frameworks/Dumb/dumb/src/it/readstm.c @@ -26,372 +26,376 @@ #include "internal/it.h" #ifdef _MSC_VER - #define strnicmp _strnicmp +#define strnicmp _strnicmp #else - #if defined(unix) || defined(__unix__) || defined(__unix) - #include - #endif - #define strnicmp strncasecmp +#if defined(unix) || defined(__unix__) || defined(__unix) +#include +#endif +#define strnicmp strncasecmp #endif -static int it_stm_read_sample_header( IT_SAMPLE *sample, DUMBFILE *f, unsigned short *offset ) -{ - dumbfile_getnc( (char *) sample->filename, 12, f ); - sample->filename[12] = 0; +static int it_stm_read_sample_header(IT_SAMPLE *sample, DUMBFILE *f, + unsigned short *offset) { + dumbfile_getnc((char *)sample->filename, 12, f); + sample->filename[12] = 0; - memcpy( sample->name, sample->filename, 13 ); + memcpy(sample->name, sample->filename, 13); - dumbfile_skip( f, 2 ); + dumbfile_skip(f, 2); - *offset = dumbfile_igetw( f ); + *offset = dumbfile_igetw(f); - sample->length = dumbfile_igetw( f ); - sample->loop_start = dumbfile_igetw( f ); - sample->loop_end = dumbfile_igetw( f ); + sample->length = dumbfile_igetw(f); + sample->loop_start = dumbfile_igetw(f); + sample->loop_end = dumbfile_igetw(f); - sample->default_volume = dumbfile_getc( f ); + sample->default_volume = dumbfile_getc(f); - dumbfile_skip( f, 1 ); + dumbfile_skip(f, 1); - sample->C5_speed = dumbfile_igetw( f ) << 3; + sample->C5_speed = dumbfile_igetw(f) << 3; - dumbfile_skip( f, 6 ); + dumbfile_skip(f, 6); - if ( sample->length < 4 || !sample->default_volume ) { - /* Looks like no-existy. */ - sample->flags &= ~IT_SAMPLE_EXISTS; - sample->length = 0; - *offset = 0; - return dumbfile_error( f ); - } + if (sample->length < 4 || !sample->default_volume) { + /* Looks like no-existy. */ + sample->flags &= ~IT_SAMPLE_EXISTS; + sample->length = 0; + *offset = 0; + return dumbfile_error(f); + } - sample->flags = IT_SAMPLE_EXISTS; - sample->global_volume = 64; - sample->default_pan = 0; // 0 = don't use, or 160 = centre? + sample->flags = IT_SAMPLE_EXISTS; + sample->global_volume = 64; + sample->default_pan = 0; // 0 = don't use, or 160 = centre? - if ( ( sample->loop_start < sample->length ) && - ( sample->loop_end > sample->loop_start ) && - ( sample->loop_end != 0xFFFF ) ) { - sample->flags |= IT_SAMPLE_LOOP; - if ( sample->loop_end > sample->length ) sample->loop_end = sample->length; - } + if ((sample->loop_start < sample->length) && + (sample->loop_end > sample->loop_start) && + (sample->loop_end != 0xFFFF)) { + sample->flags |= IT_SAMPLE_LOOP; + if (sample->loop_end > sample->length) + sample->loop_end = sample->length; + } - //Do we need to set all these? - sample->vibrato_speed = 0; - sample->vibrato_depth = 0; - sample->vibrato_rate = 0; - sample->vibrato_waveform = IT_VIBRATO_SINE; - sample->finetune = 0; - sample->max_resampling_quality = -1; + // Do we need to set all these? + sample->vibrato_speed = 0; + sample->vibrato_depth = 0; + sample->vibrato_rate = 0; + sample->vibrato_waveform = IT_VIBRATO_SINE; + sample->finetune = 0; + sample->max_resampling_quality = -1; - return dumbfile_error(f); + return dumbfile_error(f); } -static int it_stm_read_sample_data( IT_SAMPLE *sample, DUMBFILE * f ) -{ - if ( ! sample->length ) return 0; +static int it_stm_read_sample_data(IT_SAMPLE *sample, DUMBFILE *f) { + if (!sample->length) + return 0; - sample->data = malloc( sample->length ); - if (!sample->data) - return -1; + sample->data = malloc(sample->length); + if (!sample->data) + return -1; - dumbfile_getnc( sample->data, sample->length, f ); + dumbfile_getnc(sample->data, sample->length, f); - return dumbfile_error( f ); + return dumbfile_error(f); } -static int it_stm_read_pattern( IT_PATTERN *pattern, DUMBFILE *f, unsigned char *buffer ) -{ - int pos; - int channel; - int row; - IT_ENTRY *entry; +static int it_stm_read_pattern(IT_PATTERN *pattern, DUMBFILE *f, + unsigned char *buffer) { + int pos; + int channel; + int row; + IT_ENTRY *entry; - pattern->n_rows = 64; + pattern->n_rows = 64; - if ( dumbfile_getnc( (char *) buffer, 64 * 4 * 4, f ) != 64 * 4 * 4 ) - return -1; + if (dumbfile_getnc((char *)buffer, 64 * 4 * 4, f) != 64 * 4 * 4) + return -1; - pattern->n_entries = 64; - pos = 0; - for ( row = 0; row < 64; ++row ) { - for ( channel = 0; channel < 4; ++channel ) { - if ( buffer[ pos + 0 ] | buffer[ pos + 1 ] | buffer[ pos + 2 ] | buffer[ pos + 3 ] ) - ++pattern->n_entries; - pos += 4; - } - } - - pattern->entry = malloc( pattern->n_entries * sizeof( *pattern->entry ) ); - if ( !pattern->entry ) - return -1; - - entry = pattern->entry; - pos = 0; - for ( row = 0; row < 64; ++row ) { - for ( channel = 0; channel < 4; ++channel ) { - if ( buffer[ pos + 0 ] | buffer[ pos + 1 ] | buffer[ pos + 2 ] | buffer[ pos + 3 ] ) { - unsigned note; - note = buffer[ pos + 0 ]; - entry->channel = channel; - entry->mask = 0; - entry->instrument = buffer[ pos + 1 ] >> 3; - entry->volpan = ( buffer[ pos + 1 ] & 0x07 ) + ( buffer[ pos + 2 ] >> 1 ); - entry->effect = buffer[ pos + 2 ] & 0x0F; - entry->effectvalue = buffer[ pos + 3 ]; - if ( entry->instrument && entry->instrument < 32 ) - entry->mask |= IT_ENTRY_INSTRUMENT; - if ( note < 251 ) { - entry->mask |= IT_ENTRY_NOTE; - entry->note = ( note >> 4 ) * 12 + ( note & 0x0F ); - } - if ( entry->volpan <= 64 ) - entry->mask |= IT_ENTRY_VOLPAN; - entry->mask |= IT_ENTRY_EFFECT; - switch ( entry->effect ) { - case IT_SET_SPEED: - /* taken care of in the renderer */ - break; - - case IT_BREAK_TO_ROW: - entry->effectvalue -= (entry->effectvalue >> 4) * 6; - break; - - case IT_JUMP_TO_ORDER: - case IT_VOLUME_SLIDE: - case IT_PORTAMENTO_DOWN: - case IT_PORTAMENTO_UP: - case IT_TONE_PORTAMENTO: - case IT_VIBRATO: - case IT_TREMOR: - case IT_ARPEGGIO: - case IT_VOLSLIDE_VIBRATO: - case IT_VOLSLIDE_TONEPORTA: - break; - - default: - entry->mask &= ~IT_ENTRY_EFFECT; - break; - } - if ( entry->mask ) ++entry; - } - pos += 4; - } - IT_SET_END_ROW(entry); - ++entry; - } - - pattern->n_entries = (int)(entry - pattern->entry); - - return 0; -} - - - -static DUMB_IT_SIGDATA *it_stm_load_sigdata(DUMBFILE *f, int * version) -{ - DUMB_IT_SIGDATA *sigdata; - - char tracker_name[ 8 ]; - - unsigned short sample_offset[ 31 ]; - - int n; - - sigdata = malloc(sizeof(*sigdata)); - if (!sigdata) return NULL; - - /* Skip song name. */ - dumbfile_getnc((char *)sigdata->name, 20, f); - sigdata->name[20] = 0; - - dumbfile_getnc(tracker_name, 8, f); - n = dumbfile_getc(f); - if ( n != 0x02 && n != 0x1A && n != 0x1B ) - { - free( sigdata ); - return NULL; - } - if ( dumbfile_getc(f) != 2 ) /* only support modules */ - { - free( sigdata ); - return NULL; - } - if ( strnicmp( tracker_name, "!Scream!", 8 ) && - strnicmp( tracker_name, "BMOD2STM", 8 ) && - strnicmp( tracker_name, "WUZAMOD!", 8 ) ) - { - free( sigdata ); - return NULL; - } - - *version = dumbfile_mgetw(f); - - sigdata->song_message = NULL; - sigdata->order = NULL; - sigdata->instrument = NULL; - sigdata->sample = NULL; - sigdata->pattern = NULL; - sigdata->midi = NULL; - sigdata->checkpoint = NULL; - - sigdata->n_instruments = 0; - sigdata->n_samples = 31; - sigdata->n_pchannels = 4; - - sigdata->tempo = 125; - sigdata->mixing_volume = 48; - sigdata->pan_separation = 128; - - /** WARNING: which ones? */ - sigdata->flags = IT_OLD_EFFECTS | IT_COMPATIBLE_GXX | IT_WAS_AN_S3M | IT_WAS_AN_STM | IT_STEREO; - - n = dumbfile_getc(f); - if ( n < 32 ) n = 32; - sigdata->speed = n; - sigdata->n_patterns = dumbfile_getc(f); - sigdata->global_volume = dumbfile_getc(f) << 1; - if ( sigdata->global_volume > 128 ) sigdata->global_volume = 128; - - dumbfile_skip(f, 13); - - if ( dumbfile_error(f) || sigdata->n_patterns < 1 || sigdata->n_patterns > 99 ) { - _dumb_it_unload_sigdata(sigdata); - return NULL; - } - - sigdata->sample = malloc(sigdata->n_samples * sizeof(*sigdata->sample)); - if (!sigdata->sample) { - _dumb_it_unload_sigdata(sigdata); - return NULL; - } - for (n = 0; n < sigdata->n_samples; n++) - sigdata->sample[n].data = NULL; - - if (sigdata->n_patterns) { - sigdata->pattern = malloc(sigdata->n_patterns * sizeof(*sigdata->pattern)); - if (!sigdata->pattern) { - _dumb_it_unload_sigdata(sigdata); - return NULL; - } - for (n = 0; n < sigdata->n_patterns; n++) - sigdata->pattern[n].entry = NULL; - } - - memset( sigdata->channel_volume, 64, 4 ); - n = 32 * dumb_it_default_panning_separation / 100; - sigdata->channel_pan[ 0 ] = 32 + n; - sigdata->channel_pan[ 1 ] = 32 - n; - sigdata->channel_pan[ 2 ] = 32 + n; - sigdata->channel_pan[ 3 ] = 32 - n; - - for ( n = 0; n < sigdata->n_samples; ++n ) { - if ( it_stm_read_sample_header( &sigdata->sample[ n ], f, &sample_offset[ n ] ) ) { - _dumb_it_unload_sigdata( sigdata ); - return NULL; - } - } - - sigdata->order = malloc( 128 ); - if ( !sigdata->order ) { - _dumb_it_unload_sigdata( sigdata ); - return NULL; - } - - /* Orders, byte each, length = sigdata->n_orders (should be even) */ - dumbfile_getnc( (char *) sigdata->order, *version >= 0x200 ? 128 : 64, f ); - if (*version < 0x200) memset( sigdata->order + 64, 0xFF, 64 ); - sigdata->restart_position = 0; - - for ( n = 127; n >= 0; --n ) { - if ( sigdata->order[ n ] < sigdata->n_patterns ) break; - } - if ( n < 0 ) { - _dumb_it_unload_sigdata( sigdata ); - return NULL; - } - sigdata->n_orders = n + 1; - - for ( n = 0; n < 128; ++n ) { - if ( sigdata->order[ n ] >= 99 ) sigdata->order[ n ] = 0xFF; - } - - if ( sigdata->n_patterns ) { - unsigned char * buffer = malloc( 64 * 4 * 4 ); - if ( ! buffer ) { - _dumb_it_unload_sigdata( sigdata ); - return NULL; - } - for ( n = 0; n < sigdata->n_patterns; ++n ) { - if ( it_stm_read_pattern( &sigdata->pattern[ n ], f, buffer ) ) { - free( buffer ); - _dumb_it_unload_sigdata( sigdata ); - return NULL; - } - } - free( buffer ); - } - - for ( n = 0; n < sigdata->n_samples; ++n ) { - if ( sample_offset[ n ] ) - { - if ( dumbfile_seek( f, sample_offset[ n ] * 16, DFS_SEEK_SET ) || - it_stm_read_sample_data( &sigdata->sample[ n ], f ) ) { - _dumb_it_unload_sigdata( sigdata ); - return NULL; - } - } - else - { - sigdata->sample[ n ].flags = 0; - sigdata->sample[ n ].length = 0; + pattern->n_entries = 64; + pos = 0; + for (row = 0; row < 64; ++row) { + for (channel = 0; channel < 4; ++channel) { + if (buffer[pos + 0] | buffer[pos + 1] | buffer[pos + 2] | + buffer[pos + 3]) + ++pattern->n_entries; + pos += 4; } } - _dumb_it_fix_invalid_orders(sigdata); + pattern->entry = malloc(pattern->n_entries * sizeof(*pattern->entry)); + if (!pattern->entry) + return -1; - return sigdata; + entry = pattern->entry; + pos = 0; + for (row = 0; row < 64; ++row) { + for (channel = 0; channel < 4; ++channel) { + if (buffer[pos + 0] | buffer[pos + 1] | buffer[pos + 2] | + buffer[pos + 3]) { + unsigned note; + note = buffer[pos + 0]; + entry->channel = channel; + entry->mask = 0; + entry->instrument = buffer[pos + 1] >> 3; + entry->volpan = + (buffer[pos + 1] & 0x07) + (buffer[pos + 2] >> 1); + entry->effect = buffer[pos + 2] & 0x0F; + entry->effectvalue = buffer[pos + 3]; + if (entry->instrument && entry->instrument < 32) + entry->mask |= IT_ENTRY_INSTRUMENT; + if (note < 251) { + entry->mask |= IT_ENTRY_NOTE; + entry->note = (note >> 4) * 12 + (note & 0x0F); + } + if (entry->volpan <= 64) + entry->mask |= IT_ENTRY_VOLPAN; + entry->mask |= IT_ENTRY_EFFECT; + switch (entry->effect) { + case IT_SET_SPEED: + /* taken care of in the renderer */ + break; + + case IT_BREAK_TO_ROW: + entry->effectvalue -= (entry->effectvalue >> 4) * 6; + break; + + case IT_JUMP_TO_ORDER: + case IT_VOLUME_SLIDE: + case IT_PORTAMENTO_DOWN: + case IT_PORTAMENTO_UP: + case IT_TONE_PORTAMENTO: + case IT_VIBRATO: + case IT_TREMOR: + case IT_ARPEGGIO: + case IT_VOLSLIDE_VIBRATO: + case IT_VOLSLIDE_TONEPORTA: + break; + + default: + entry->mask &= ~IT_ENTRY_EFFECT; + break; + } + if (entry->mask) + ++entry; + } + pos += 4; + } + IT_SET_END_ROW(entry); + ++entry; + } + + pattern->n_entries = (int)(entry - pattern->entry); + + return 0; } -DUH *dumb_read_stm_quick(DUMBFILE *f) -{ - sigdata_t *sigdata; - int ver; +static DUMB_IT_SIGDATA *it_stm_load_sigdata(DUMBFILE *f, int *version) { + DUMB_IT_SIGDATA *sigdata; - DUH_SIGTYPE_DESC *descptr = &_dumb_sigtype_it; + char tracker_name[8]; - sigdata = it_stm_load_sigdata(f , &ver); + unsigned short sample_offset[31]; - if (!sigdata) - return NULL; + int n; - { - char version[16]; - const char *tag[2][2]; - tag[0][0] = "TITLE"; + sigdata = malloc(sizeof(*sigdata)); + if (!sigdata) + return NULL; + + /* Skip song name. */ + dumbfile_getnc((char *)sigdata->name, 20, f); + sigdata->name[20] = 0; + + dumbfile_getnc(tracker_name, 8, f); + n = dumbfile_getc(f); + if (n != 0x02 && n != 0x1A && n != 0x1B) { + free(sigdata); + return NULL; + } + if (dumbfile_getc(f) != 2) /* only support modules */ + { + free(sigdata); + return NULL; + } + if (strnicmp(tracker_name, "!Scream!", 8) && + strnicmp(tracker_name, "BMOD2STM", 8) && + strnicmp(tracker_name, "WUZAMOD!", 8)) { + free(sigdata); + return NULL; + } + + *version = dumbfile_mgetw(f); + + sigdata->song_message = NULL; + sigdata->order = NULL; + sigdata->instrument = NULL; + sigdata->sample = NULL; + sigdata->pattern = NULL; + sigdata->midi = NULL; + sigdata->checkpoint = NULL; + + sigdata->n_instruments = 0; + sigdata->n_samples = 31; + sigdata->n_pchannels = 4; + + sigdata->tempo = 125; + sigdata->mixing_volume = 48; + sigdata->pan_separation = 128; + + /** WARNING: which ones? */ + sigdata->flags = IT_OLD_EFFECTS | IT_COMPATIBLE_GXX | IT_WAS_AN_S3M | + IT_WAS_AN_STM | IT_STEREO; + + n = dumbfile_getc(f); + if (n < 32) + n = 32; + sigdata->speed = n; + sigdata->n_patterns = dumbfile_getc(f); + sigdata->global_volume = dumbfile_getc(f) << 1; + if (sigdata->global_volume > 128) + sigdata->global_volume = 128; + + dumbfile_skip(f, 13); + + if (dumbfile_error(f) || sigdata->n_patterns < 1 || + sigdata->n_patterns > 99) { + _dumb_it_unload_sigdata(sigdata); + return NULL; + } + + sigdata->sample = malloc(sigdata->n_samples * sizeof(*sigdata->sample)); + if (!sigdata->sample) { + _dumb_it_unload_sigdata(sigdata); + return NULL; + } + for (n = 0; n < sigdata->n_samples; n++) + sigdata->sample[n].data = NULL; + + if (sigdata->n_patterns) { + sigdata->pattern = + malloc(sigdata->n_patterns * sizeof(*sigdata->pattern)); + if (!sigdata->pattern) { + _dumb_it_unload_sigdata(sigdata); + return NULL; + } + for (n = 0; n < sigdata->n_patterns; n++) + sigdata->pattern[n].entry = NULL; + } + + memset(sigdata->channel_volume, 64, 4); + n = 32 * dumb_it_default_panning_separation / 100; + sigdata->channel_pan[0] = 32 + n; + sigdata->channel_pan[1] = 32 - n; + sigdata->channel_pan[2] = 32 + n; + sigdata->channel_pan[3] = 32 - n; + + for (n = 0; n < sigdata->n_samples; ++n) { + if (it_stm_read_sample_header(&sigdata->sample[n], f, + &sample_offset[n])) { + _dumb_it_unload_sigdata(sigdata); + return NULL; + } + } + + sigdata->order = malloc(128); + if (!sigdata->order) { + _dumb_it_unload_sigdata(sigdata); + return NULL; + } + + /* Orders, byte each, length = sigdata->n_orders (should be even) */ + dumbfile_getnc((char *)sigdata->order, *version >= 0x200 ? 128 : 64, f); + if (*version < 0x200) + memset(sigdata->order + 64, 0xFF, 64); + sigdata->restart_position = 0; + + for (n = 127; n >= 0; --n) { + if (sigdata->order[n] < sigdata->n_patterns) + break; + } + if (n < 0) { + _dumb_it_unload_sigdata(sigdata); + return NULL; + } + sigdata->n_orders = n + 1; + + for (n = 0; n < 128; ++n) { + if (sigdata->order[n] >= 99) + sigdata->order[n] = 0xFF; + } + + if (sigdata->n_patterns) { + unsigned char *buffer = malloc(64 * 4 * 4); + if (!buffer) { + _dumb_it_unload_sigdata(sigdata); + return NULL; + } + for (n = 0; n < sigdata->n_patterns; ++n) { + if (it_stm_read_pattern(&sigdata->pattern[n], f, buffer)) { + free(buffer); + _dumb_it_unload_sigdata(sigdata); + return NULL; + } + } + free(buffer); + } + + for (n = 0; n < sigdata->n_samples; ++n) { + if (sample_offset[n]) { + if (dumbfile_seek(f, sample_offset[n] * 16, DFS_SEEK_SET) || + it_stm_read_sample_data(&sigdata->sample[n], f)) { + _dumb_it_unload_sigdata(sigdata); + return NULL; + } + } else { + sigdata->sample[n].flags = 0; + sigdata->sample[n].length = 0; + } + } + + _dumb_it_fix_invalid_orders(sigdata); + + return sigdata; +} + +DUH *dumb_read_stm_quick(DUMBFILE *f) { + sigdata_t *sigdata; + int ver; + + DUH_SIGTYPE_DESC *descptr = &_dumb_sigtype_it; + + sigdata = it_stm_load_sigdata(f, &ver); + + if (!sigdata) + return NULL; + + { + char version[16]; + const char *tag[2][2]; + tag[0][0] = "TITLE"; tag[0][1] = (const char *)(((DUMB_IT_SIGDATA *)sigdata)->name); - tag[1][0] = "FORMAT"; - version[0] = 'S'; - version[1] = 'T'; - version[2] = 'M'; - version[3] = ' '; - version[4] = 'v'; - version[5] = '0' + ((ver >> 8) & 15); - version[6] = '.'; - if ((ver & 255) > 99) - { - version[7] = '0' + ((ver & 255) / 100 ); - version[8] = '0' + (((ver & 255) / 10) % 10); - version[9] = '0' + ((ver & 255) % 10); - version[10] = 0; - } - else - { - version[7] = '0' + ((ver & 255) / 10); - version[8] = '0' + ((ver & 255) % 10); - version[9] = 0; - } - tag[1][1] = (const char *) &version; - return make_duh(-1, 2, (const char *const (*)[2])tag, 1, &descptr, &sigdata); - } + tag[1][0] = "FORMAT"; + version[0] = 'S'; + version[1] = 'T'; + version[2] = 'M'; + version[3] = ' '; + version[4] = 'v'; + version[5] = '0' + ((ver >> 8) & 15); + version[6] = '.'; + if ((ver & 255) > 99) { + version[7] = '0' + ((ver & 255) / 100); + version[8] = '0' + (((ver & 255) / 10) % 10); + version[9] = '0' + ((ver & 255) % 10); + version[10] = 0; + } else { + version[7] = '0' + ((ver & 255) / 10); + version[8] = '0' + ((ver & 255) % 10); + version[9] = 0; + } + tag[1][1] = (const char *)&version; + return make_duh(-1, 2, (const char *const(*)[2])tag, 1, &descptr, + &sigdata); + } } diff --git a/Frameworks/Dumb/dumb/src/it/readstm2.c b/Frameworks/Dumb/dumb/src/it/readstm2.c index c336b2a3d..ca883a988 100644 --- a/Frameworks/Dumb/dumb/src/it/readstm2.c +++ b/Frameworks/Dumb/dumb/src/it/readstm2.c @@ -19,11 +19,8 @@ #include "dumb.h" - - -DUH *dumb_read_stm(DUMBFILE *f) -{ - DUH *duh = dumb_read_stm_quick(f); - dumb_it_do_initial_runthrough(duh); - return duh; +DUH *dumb_read_stm(DUMBFILE *f) { + DUH *duh = dumb_read_stm_quick(f); + dumb_it_do_initial_runthrough(duh); + return duh; } diff --git a/Frameworks/Dumb/dumb/src/it/readxm.c b/Frameworks/Dumb/dumb/src/it/readxm.c index 69866ae72..bb0628ac1 100644 --- a/Frameworks/Dumb/dumb/src/it/readxm.c +++ b/Frameworks/Dumb/dumb/src/it/readxm.c @@ -25,8 +25,6 @@ #include "internal/it.h" #include "internal/dumbfile.h" - - /** TODO: * XM_TREMOLO doesn't sound quite right... @@ -56,592 +54,566 @@ */ +#define XM_LINEAR_FREQUENCY 1 /* otherwise, use amiga slides */ +#define XM_ENTRY_PACKED 128 +#define XM_ENTRY_NOTE 1 +#define XM_ENTRY_INSTRUMENT 2 +#define XM_ENTRY_VOLUME 4 +#define XM_ENTRY_EFFECT 8 +#define XM_ENTRY_EFFECTVALUE 16 -#define XM_LINEAR_FREQUENCY 1 /* otherwise, use amiga slides */ +#define XM_NOTE_OFF 97 -#define XM_ENTRY_PACKED 128 -#define XM_ENTRY_NOTE 1 -#define XM_ENTRY_INSTRUMENT 2 -#define XM_ENTRY_VOLUME 4 -#define XM_ENTRY_EFFECT 8 -#define XM_ENTRY_EFFECTVALUE 16 - -#define XM_NOTE_OFF 97 - -#define XM_ENVELOPE_ON 1 -#define XM_ENVELOPE_SUSTAIN 2 -#define XM_ENVELOPE_LOOP 4 - -#define XM_SAMPLE_NO_LOOP 0 -#define XM_SAMPLE_FORWARD_LOOP 1 -#define XM_SAMPLE_PINGPONG_LOOP 2 -#define XM_SAMPLE_16BIT 16 -#define XM_SAMPLE_STEREO 32 - -#define XM_VIBRATO_SINE 0 -#define XM_VIBRATO_SQUARE 1 -#define XM_VIBRATO_RAMP_DOWN 2 -#define XM_VIBRATO_RAMP_UP 3 +#define XM_ENVELOPE_ON 1 +#define XM_ENVELOPE_SUSTAIN 2 +#define XM_ENVELOPE_LOOP 4 +#define XM_SAMPLE_NO_LOOP 0 +#define XM_SAMPLE_FORWARD_LOOP 1 +#define XM_SAMPLE_PINGPONG_LOOP 2 +#define XM_SAMPLE_16BIT 16 +#define XM_SAMPLE_STEREO 32 +#define XM_VIBRATO_SINE 0 +#define XM_VIBRATO_SQUARE 1 +#define XM_VIBRATO_RAMP_DOWN 2 +#define XM_VIBRATO_RAMP_UP 3 /* Probably useless :) */ -const char xm_convert_vibrato[] = { - IT_VIBRATO_SINE, - IT_VIBRATO_XM_SQUARE, - IT_VIBRATO_RAMP_DOWN, - IT_VIBRATO_RAMP_UP, - IT_VIBRATO_RANDOM -}; - - +const char xm_convert_vibrato[] = {IT_VIBRATO_SINE, IT_VIBRATO_XM_SQUARE, + IT_VIBRATO_RAMP_DOWN, IT_VIBRATO_RAMP_UP, + IT_VIBRATO_RANDOM}; #define XM_MAX_SAMPLES_PER_INSTRUMENT 16 - - /* Extra data that doesn't fit inside IT_INSTRUMENT */ -typedef struct XM_INSTRUMENT_EXTRA -{ - int n_samples; - int vibrato_type; - int vibrato_sweep; /* 0-0xFF */ - int vibrato_depth; /* 0-0x0F */ - int vibrato_speed; /* 0-0x3F */ - int sample_header_size; -} -XM_INSTRUMENT_EXTRA; - - +typedef struct XM_INSTRUMENT_EXTRA { + int n_samples; + int vibrato_type; + int vibrato_sweep; /* 0-0xFF */ + int vibrato_depth; /* 0-0x0F */ + int vibrato_speed; /* 0-0x3F */ + int sample_header_size; +} XM_INSTRUMENT_EXTRA; /* Trims off trailing white space, usually added by the tracker on file creation */ -static void trim_whitespace(char *ptr, size_t size) -{ - char *p = ptr + size - 1; - while (p >= ptr && *p <= 0x20) *p-- = '\0'; +static void trim_whitespace(char *ptr, size_t size) { + char *p = ptr + size - 1; + while (p >= ptr && *p <= 0x20) + *p-- = '\0'; } /* Frees the original block if it can't resize it or if size is 0, and acts * as malloc if ptr is NULL. */ -static void *safe_realloc(void *ptr, size_t size) -{ - if (ptr == NULL) - return malloc(size); +static void *safe_realloc(void *ptr, size_t size) { + if (ptr == NULL) + return malloc(size); - if (size == 0) { - free(ptr); - return NULL; - } else { - void *new_block = realloc(ptr, size); - if (!new_block) - free(ptr); - return new_block; - } + if (size == 0) { + free(ptr); + return NULL; + } else { + void *new_block = realloc(ptr, size); + if (!new_block) + free(ptr); + return new_block; + } } - - /* The interpretation of the XM volume column is left to the player. Here, we * just filter bad values. */ // This function is so tiny now, should we inline it? -static void it_xm_convert_volume(int volume, IT_ENTRY *entry) -{ - entry->mask |= IT_ENTRY_VOLPAN; - entry->volpan = volume; +static void it_xm_convert_volume(int volume, IT_ENTRY *entry) { + entry->mask |= IT_ENTRY_VOLPAN; + entry->volpan = volume; - switch (volume >> 4) { - case 0xA: /* set vibrato speed */ - case 0xB: /* vibrato */ - case 0xF: /* tone porta */ - case 0x6: /* vol slide up */ - case 0x7: /* vol slide down */ - case 0x8: /* fine vol slide up */ - case 0x9: /* fine vol slide down */ - case 0xC: /* set panning */ - case 0xD: /* pan slide left */ - case 0xE: /* pan slide right */ - case 0x1: /* set volume */ - case 0x2: /* set volume */ - case 0x3: /* set volume */ - case 0x4: /* set volume */ - break; + switch (volume >> 4) { + case 0xA: /* set vibrato speed */ + case 0xB: /* vibrato */ + case 0xF: /* tone porta */ + case 0x6: /* vol slide up */ + case 0x7: /* vol slide down */ + case 0x8: /* fine vol slide up */ + case 0x9: /* fine vol slide down */ + case 0xC: /* set panning */ + case 0xD: /* pan slide left */ + case 0xE: /* pan slide right */ + case 0x1: /* set volume */ + case 0x2: /* set volume */ + case 0x3: /* set volume */ + case 0x4: /* set volume */ + break; - case 0x5: - if (volume == 0x50) - break; /* set volume */ - /* else fall through */ + case 0x5: + if (volume == 0x50) + break; /* set volume */ + /* else fall through */ - default: - entry->mask &= ~IT_ENTRY_VOLPAN; - break; - } + default: + entry->mask &= ~IT_ENTRY_VOLPAN; + break; + } } +static int it_xm_read_pattern(IT_PATTERN *pattern, DUMBFILE *f, int n_channels, + unsigned char *buffer, int version) { + int size; + int pos; + int channel; + int row; + int effect, effectvalue; + IT_ENTRY *entry; + /* pattern header size */ + if (dumbfile_igetl(f) != (version == 0x0102 ? 0x08 : 0x09)) { + TRACE("XM error: unexpected pattern header size\n"); + return -1; + } -static int it_xm_read_pattern(IT_PATTERN *pattern, DUMBFILE *f, int n_channels, unsigned char *buffer, int version) -{ - int size; - int pos; - int channel; - int row; - int effect, effectvalue; - IT_ENTRY *entry; + /* pattern data packing type */ + if (dumbfile_getc(f) != 0) { + TRACE("XM error: unexpected pattern packing type\n"); + return -1; + } - /* pattern header size */ - if (dumbfile_igetl(f) != ( version == 0x0102 ? 0x08 : 0x09 ) ) { - TRACE("XM error: unexpected pattern header size\n"); - return -1; - } + if (version == 0x0102) + pattern->n_rows = dumbfile_getc(f) + 1; + else + pattern->n_rows = dumbfile_igetw(f); /* 1..256 */ + size = dumbfile_igetw(f); + pattern->n_entries = 0; - /* pattern data packing type */ - if (dumbfile_getc(f) != 0) { - TRACE("XM error: unexpected pattern packing type\n"); - return -1; - } + if (dumbfile_error(f)) + return -1; - if ( version == 0x0102 ) - pattern->n_rows = dumbfile_getc(f) + 1; - else - pattern->n_rows = dumbfile_igetw(f); /* 1..256 */ - size = dumbfile_igetw(f); - pattern->n_entries = 0; + if (size == 0) + return 0; - if (dumbfile_error(f)) - return -1; - - if (size == 0) - return 0; - - if (size > 1280 * n_channels) { - TRACE("XM error: pattern data size > %d bytes\n", 1280 * n_channels); - return -1; - } + if (size > 1280 * n_channels) { + TRACE("XM error: pattern data size > %d bytes\n", 1280 * n_channels); + return -1; + } if (dumbfile_getnc((char *)buffer, size, f) < size) - return -1; + return -1; - /* compute number of entries */ - pattern->n_entries = 0; - pos = channel = row = 0; - while (pos < size) { - if (!(buffer[pos] & XM_ENTRY_PACKED) || (buffer[pos] & 31)) - pattern->n_entries++; + /* compute number of entries */ + pattern->n_entries = 0; + pos = channel = row = 0; + while (pos < size) { + if (!(buffer[pos] & XM_ENTRY_PACKED) || (buffer[pos] & 31)) + pattern->n_entries++; - channel++; - if (channel >= n_channels) { - channel = 0; - row++; - pattern->n_entries++; - } + channel++; + if (channel >= n_channels) { + channel = 0; + row++; + pattern->n_entries++; + } - if (buffer[pos] & XM_ENTRY_PACKED) { - static const char offset[] = { 0, 1, 1, 2, 1, 2, 2, 3, 1, 2, 2, 3, 2, 3, 3, 4, - 1, 2, 2, 3, 2, 3, 3, 4, 2, 3, 3, 4, 3, 4, 4, 5 }; - pos += 1 + offset[buffer[pos] & 31]; - } else { - pos += 5; - } - } + if (buffer[pos] & XM_ENTRY_PACKED) { + static const char offset[] = {0, 1, 1, 2, 1, 2, 2, 3, 1, 2, 2, + 3, 2, 3, 3, 4, 1, 2, 2, 3, 2, 3, + 3, 4, 2, 3, 3, 4, 3, 4, 4, 5}; + pos += 1 + offset[buffer[pos] & 31]; + } else { + pos += 5; + } + } - if (row > pattern->n_rows) { - TRACE("XM error: wrong number of rows in pattern data\n"); - return -1; - } + if (row > pattern->n_rows) { + TRACE("XM error: wrong number of rows in pattern data\n"); + return -1; + } - /* Whoops, looks like some modules may be short, a few channels, maybe even rows... */ + /* Whoops, looks like some modules may be short, a few channels, maybe even + * rows... */ - while (row < pattern->n_rows) - { - pattern->n_entries++; - row++; - } + while (row < pattern->n_rows) { + pattern->n_entries++; + row++; + } - pattern->entry = malloc(pattern->n_entries * sizeof(*pattern->entry)); - if (!pattern->entry) - return -1; + pattern->entry = malloc(pattern->n_entries * sizeof(*pattern->entry)); + if (!pattern->entry) + return -1; - /* read the entries */ - entry = pattern->entry; - pos = channel = row = 0; - while (pos < size) { - unsigned char mask; + /* read the entries */ + entry = pattern->entry; + pos = channel = row = 0; + while (pos < size) { + unsigned char mask; - if (buffer[pos] & XM_ENTRY_PACKED) - mask = buffer[pos++] & 31; - else - mask = 31; + if (buffer[pos] & XM_ENTRY_PACKED) + mask = buffer[pos++] & 31; + else + mask = 31; - if (mask) { - ASSERT(entry < pattern->entry + pattern->n_entries); + if (mask) { + ASSERT(entry < pattern->entry + pattern->n_entries); - entry->channel = channel; - entry->mask = 0; + entry->channel = channel; + entry->mask = 0; - if (mask & XM_ENTRY_NOTE) { - int note = buffer[pos++]; /* 1-96 <=> C0-B7 */ - entry->note = (note == XM_NOTE_OFF) ? (IT_NOTE_OFF) : (note-1); - entry->mask |= IT_ENTRY_NOTE; - } + if (mask & XM_ENTRY_NOTE) { + int note = buffer[pos++]; /* 1-96 <=> C0-B7 */ + entry->note = + (note == XM_NOTE_OFF) ? (IT_NOTE_OFF) : (note - 1); + entry->mask |= IT_ENTRY_NOTE; + } - if (mask & XM_ENTRY_INSTRUMENT) { - entry->instrument = buffer[pos++]; /* 1-128 */ - entry->mask |= IT_ENTRY_INSTRUMENT; - } + if (mask & XM_ENTRY_INSTRUMENT) { + entry->instrument = buffer[pos++]; /* 1-128 */ + entry->mask |= IT_ENTRY_INSTRUMENT; + } - if (mask & XM_ENTRY_VOLUME) - it_xm_convert_volume(buffer[pos++], entry); + if (mask & XM_ENTRY_VOLUME) + it_xm_convert_volume(buffer[pos++], entry); - effect = effectvalue = 0; - if (mask & XM_ENTRY_EFFECT) effect = buffer[pos++]; - if (mask & XM_ENTRY_EFFECTVALUE) effectvalue = buffer[pos++]; - _dumb_it_xm_convert_effect(effect, effectvalue, entry, 0); + effect = effectvalue = 0; + if (mask & XM_ENTRY_EFFECT) + effect = buffer[pos++]; + if (mask & XM_ENTRY_EFFECTVALUE) + effectvalue = buffer[pos++]; + _dumb_it_xm_convert_effect(effect, effectvalue, entry, 0); - entry++; - } + entry++; + } - channel++; - if (channel >= n_channels) { - channel = 0; - row++; - IT_SET_END_ROW(entry); - entry++; - } - } + channel++; + if (channel >= n_channels) { + channel = 0; + row++; + IT_SET_END_ROW(entry); + entry++; + } + } - while (row < pattern->n_rows) - { - row++; - IT_SET_END_ROW(entry); - entry++; - } + while (row < pattern->n_rows) { + row++; + IT_SET_END_ROW(entry); + entry++; + } - return 0; + return 0; } - - -static int it_xm_make_envelope(IT_ENVELOPE *envelope, const unsigned short *data, int y_offset) -{ +static int it_xm_make_envelope(IT_ENVELOPE *envelope, + const unsigned short *data, int y_offset) { int i, pos, val; - if (envelope->n_nodes > 12) { - /* XXX - TRACE("XM error: wrong number of envelope nodes (%d)\n", envelope->n_nodes); - envelope->n_nodes = 0; - return -1; */ - envelope->n_nodes = 12; - } + if (envelope->n_nodes > 12) { + /* XXX + TRACE("XM error: wrong number of envelope nodes (%d)\n", + envelope->n_nodes); envelope->n_nodes = 0; return -1; */ + envelope->n_nodes = 12; + } - if (envelope->sus_loop_start >= 12) envelope->flags &= ~IT_ENVELOPE_SUSTAIN_LOOP; - if (envelope->loop_end >= 12) envelope->loop_end = 0; - if (envelope->loop_start >= envelope->loop_end) envelope->flags &= ~IT_ENVELOPE_LOOP_ON; + if (envelope->sus_loop_start >= 12) + envelope->flags &= ~IT_ENVELOPE_SUSTAIN_LOOP; + if (envelope->loop_end >= 12) + envelope->loop_end = 0; + if (envelope->loop_start >= envelope->loop_end) + envelope->flags &= ~IT_ENVELOPE_LOOP_ON; - pos = 0; - for (i = 0; i < envelope->n_nodes; i++) { - envelope->node_t[i] = data[pos++]; + pos = 0; + for (i = 0; i < envelope->n_nodes; i++) { + envelope->node_t[i] = data[pos++]; val = data[pos++]; if (val > 64) { - TRACE("XM error: out-of-range envelope node (node_y[%d]=%d)\n", i, val); + TRACE("XM error: out-of-range envelope node (node_y[%d]=%d)\n", i, + val); /* FT2 seems to simply clip the value */ val = 64; - } + } envelope->node_y[i] = (signed char)(val + y_offset); - } + } - return 0; + return 0; } - - typedef struct LIMITED_XM LIMITED_XM; -struct LIMITED_XM -{ - unsigned char *buffered; - long ptr, limit, allocated; - DUMBFILE *remaining; +struct LIMITED_XM { + unsigned char *buffered; + long ptr, limit, allocated; + DUMBFILE *remaining; }; -static int limit_xm_resize(void *f, long n) -{ - DUMBFILE *df = f; - LIMITED_XM *lx = df->file; - if (n < 0) - return -1; - if (lx->buffered || n) { - if (n > lx->allocated) { - unsigned char *buffered = realloc( lx->buffered, n ); - if ( !buffered ) return -1; - lx->buffered = buffered; - memset( buffered + lx->allocated, 0, n - lx->allocated ); - lx->allocated = n; - } - if ( dumbfile_getnc( (char *)lx->buffered, n, lx->remaining ) < n ) return -1; - } else if (!n) { - if ( lx->buffered ) free( lx->buffered ); - lx->buffered = NULL; - lx->allocated = 0; - } - lx->limit = n; - lx->ptr = 0; - return 0; +static int limit_xm_resize(void *f, long n) { + DUMBFILE *df = f; + LIMITED_XM *lx = df->file; + if (n < 0) + return -1; + if (lx->buffered || n) { + if (n > lx->allocated) { + unsigned char *buffered = realloc(lx->buffered, n); + if (!buffered) + return -1; + lx->buffered = buffered; + memset(buffered + lx->allocated, 0, n - lx->allocated); + lx->allocated = n; + } + if (dumbfile_getnc((char *)lx->buffered, n, lx->remaining) < n) + return -1; + } else if (!n) { + if (lx->buffered) + free(lx->buffered); + lx->buffered = NULL; + lx->allocated = 0; + } + lx->limit = n; + lx->ptr = 0; + return 0; } -static int limit_xm_skip_end(void *f, long n) -{ - DUMBFILE *df = f; - LIMITED_XM *lx = df->file; - return dumbfile_skip( lx->remaining, n ); +static int limit_xm_skip_end(void *f, long n) { + DUMBFILE *df = f; + LIMITED_XM *lx = df->file; + return dumbfile_skip(lx->remaining, n); } -static int limit_xm_skip(void *f, long n) -{ - LIMITED_XM *lx = f; - lx->ptr += n; - return 0; +static int limit_xm_skip(void *f, dumb_off_t n) { + LIMITED_XM *lx = f; + lx->ptr += n; + return 0; } - - -static int limit_xm_getc(void *f) -{ - LIMITED_XM *lx = f; - if (lx->ptr >= lx->allocated) { - return 0; - } - return lx->buffered[lx->ptr++]; +static int limit_xm_getc(void *f) { + LIMITED_XM *lx = f; + if (lx->ptr >= lx->allocated) { + return 0; + } + return lx->buffered[lx->ptr++]; } - - -static long limit_xm_getnc(char *ptr, long n, void *f) -{ - LIMITED_XM *lx = f; - int left; - left = lx->allocated - lx->ptr; - if (n > left) { - if (left > 0) { - memcpy( ptr, lx->buffered + lx->ptr, left ); - memset( ptr + left, 0, n - left ); - } else { - memset( ptr, 0, n ); - } - } else { - memcpy( ptr, lx->buffered + lx->ptr, n ); - } - lx->ptr += n; - return n; +static dumb_ssize_t limit_xm_getnc(char *ptr, size_t n, void *f) { + LIMITED_XM *lx = f; + dumb_ssize_t left; + left = lx->allocated - lx->ptr; + if ((dumb_ssize_t)n > left) { + if (left > 0) { + memcpy(ptr, lx->buffered + lx->ptr, left); + memset(ptr + left, 0, n - left); + } else { + memset(ptr, 0, n); + } + } else { + memcpy(ptr, lx->buffered + lx->ptr, n); + } + lx->ptr += n; + return n; } - - -static void limit_xm_close(void *f) -{ - LIMITED_XM *lx = f; - if (lx->buffered) free(lx->buffered); - /* Do NOT close lx->remaining */ - free(f); +static void limit_xm_close(void *f) { + LIMITED_XM *lx = f; + if (lx->buffered) + free(lx->buffered); + /* Do NOT close lx->remaining */ + free(f); } - /* These two can be stubs since this implementation doesn't use seeking */ -static int limit_xm_seek(void *f, long n) -{ +static int limit_xm_seek(void *f, dumb_off_t n) { (void)f; (void)n; return 1; } - - -static long limit_xm_get_size(void *f) -{ +static dumb_off_t limit_xm_get_size(void *f) { (void)f; return 0; } +DUMBFILE_SYSTEM limit_xm_dfs = {NULL, + &limit_xm_skip, + &limit_xm_getc, + &limit_xm_getnc, + &limit_xm_close, + &limit_xm_seek, + &limit_xm_get_size}; - -DUMBFILE_SYSTEM limit_xm_dfs = { - NULL, - &limit_xm_skip, - &limit_xm_getc, - &limit_xm_getnc, - &limit_xm_close, - &limit_xm_seek, - &limit_xm_get_size -}; - -static DUMBFILE *dumbfile_limit_xm(DUMBFILE *f) -{ - LIMITED_XM * lx = malloc(sizeof(*lx)); - lx->remaining = f; - lx->buffered = NULL; - lx->ptr = 0; - lx->limit = 0; - lx->allocated = 0; - return dumbfile_open_ex( lx, &limit_xm_dfs ); +static DUMBFILE *dumbfile_limit_xm(DUMBFILE *f) { + LIMITED_XM *lx = malloc(sizeof(*lx)); + lx->remaining = f; + lx->buffered = NULL; + lx->ptr = 0; + lx->limit = 0; + lx->allocated = 0; + return dumbfile_open_ex(lx, &limit_xm_dfs); } -static int it_xm_read_instrument(IT_INSTRUMENT *instrument, XM_INSTRUMENT_EXTRA *extra, DUMBFILE *f) -{ - unsigned long size, bytes_read; - unsigned short vol_points[24]; - unsigned short pan_points[24]; - int i, type; - const unsigned long max_size = 4 + 22 + 1 + 2 + 4 + 96 + 48 + 48 + 1 * 14 + 2 + 2; - unsigned long skip_end = 0; +static int it_xm_read_instrument(IT_INSTRUMENT *instrument, + XM_INSTRUMENT_EXTRA *extra, DUMBFILE *f) { + unsigned long size, bytes_read; + unsigned short vol_points[24]; + unsigned short pan_points[24]; + int i, type; + const unsigned long max_size = + 4 + 22 + 1 + 2 + 4 + 96 + 48 + 48 + 1 * 14 + 2 + 2; + unsigned long skip_end = 0; - /* Header size. Tends to be more than the actual size of the structure. - * So unread bytes must be skipped before reading the first sample - * header. - */ + /* Header size. Tends to be more than the actual size of the structure. + * So unread bytes must be skipped before reading the first sample + * header. + */ - if ( limit_xm_resize( f, 4 ) < 0 ) return -1; + if (limit_xm_resize(f, 4) < 0) + return -1; - size = dumbfile_igetl(f); + size = dumbfile_igetl(f); - if ( size == 0 ) size = max_size; - else if ( size > max_size ) - { - skip_end = size - max_size; - size = max_size; - } + if (size == 0) + size = max_size; + else if (size > max_size) { + skip_end = size - max_size; + size = max_size; + } - if ( limit_xm_resize( f, size - 4 ) < 0 ) return -1; + if (limit_xm_resize(f, size - 4) < 0) + return -1; dumbfile_getnc((char *)instrument->name, 22, f); - instrument->name[22] = 0; + instrument->name[22] = 0; trim_whitespace((char *)instrument->name, 22); - instrument->filename[0] = 0; - dumbfile_skip(f, 1); /* Instrument type. Should be 0, but seems random. */ - extra->n_samples = dumbfile_igetw(f); + instrument->filename[0] = 0; + dumbfile_skip(f, 1); /* Instrument type. Should be 0, but seems random. */ + extra->n_samples = dumbfile_igetw(f); - if (dumbfile_error(f) || (unsigned int)extra->n_samples > XM_MAX_SAMPLES_PER_INSTRUMENT) - return -1; + if (dumbfile_error(f) || + (unsigned int)extra->n_samples > XM_MAX_SAMPLES_PER_INSTRUMENT) + return -1; - bytes_read = 4 + 22 + 1 + 2; + bytes_read = 4 + 22 + 1 + 2; - if (extra->n_samples) { - /* sample header size */ - /*i = dumbfile_igetl(f); - if (!i || i > 0x28) i = 0x28;*/ - dumbfile_skip(f, 4); - i = 0x28; - extra->sample_header_size = i; + if (extra->n_samples) { + /* sample header size */ + /*i = dumbfile_igetl(f); + if (!i || i > 0x28) i = 0x28;*/ + dumbfile_skip(f, 4); + i = 0x28; + extra->sample_header_size = i; - /* sample map */ - for (i = 0; i < 96; i++) { - instrument->map_sample[i] = dumbfile_getc(f) + 1; - instrument->map_note[i] = i; - } + /* sample map */ + for (i = 0; i < 96; i++) { + instrument->map_sample[i] = dumbfile_getc(f) + 1; + instrument->map_note[i] = i; + } - if (dumbfile_error(f)) - return 1; + if (dumbfile_error(f)) + return 1; - /* volume/panning envelopes */ - for (i = 0; i < 24; i++) - vol_points[i] = dumbfile_igetw(f); - for (i = 0; i < 24; i++) - pan_points[i] = dumbfile_igetw(f); + /* volume/panning envelopes */ + for (i = 0; i < 24; i++) + vol_points[i] = dumbfile_igetw(f); + for (i = 0; i < 24; i++) + pan_points[i] = dumbfile_igetw(f); - instrument->volume_envelope.n_nodes = dumbfile_getc(f); - instrument->pan_envelope.n_nodes = dumbfile_getc(f); + instrument->volume_envelope.n_nodes = dumbfile_getc(f); + instrument->pan_envelope.n_nodes = dumbfile_getc(f); - if (dumbfile_error(f)) - return -1; + if (dumbfile_error(f)) + return -1; - instrument->volume_envelope.sus_loop_start = dumbfile_getc(f); - instrument->volume_envelope.loop_start = dumbfile_getc(f); - instrument->volume_envelope.loop_end = dumbfile_getc(f); + instrument->volume_envelope.sus_loop_start = dumbfile_getc(f); + instrument->volume_envelope.loop_start = dumbfile_getc(f); + instrument->volume_envelope.loop_end = dumbfile_getc(f); - instrument->pan_envelope.sus_loop_start = dumbfile_getc(f); - instrument->pan_envelope.loop_start = dumbfile_getc(f); - instrument->pan_envelope.loop_end = dumbfile_getc(f); + instrument->pan_envelope.sus_loop_start = dumbfile_getc(f); + instrument->pan_envelope.loop_start = dumbfile_getc(f); + instrument->pan_envelope.loop_end = dumbfile_getc(f); - /* The envelope handler for XM files won't use sus_loop_end. */ + /* The envelope handler for XM files won't use sus_loop_end. */ - type = dumbfile_getc(f); - instrument->volume_envelope.flags = 0; - if ((type & XM_ENVELOPE_ON) && instrument->volume_envelope.n_nodes) - instrument->volume_envelope.flags |= IT_ENVELOPE_ON; - if (type & XM_ENVELOPE_LOOP) instrument->volume_envelope.flags |= IT_ENVELOPE_LOOP_ON; + type = dumbfile_getc(f); + instrument->volume_envelope.flags = 0; + if ((type & XM_ENVELOPE_ON) && instrument->volume_envelope.n_nodes) + instrument->volume_envelope.flags |= IT_ENVELOPE_ON; + if (type & XM_ENVELOPE_LOOP) + instrument->volume_envelope.flags |= IT_ENVELOPE_LOOP_ON; #if 1 - if (type & XM_ENVELOPE_SUSTAIN) instrument->volume_envelope.flags |= IT_ENVELOPE_SUSTAIN_LOOP; + if (type & XM_ENVELOPE_SUSTAIN) + instrument->volume_envelope.flags |= IT_ENVELOPE_SUSTAIN_LOOP; #else // This is now handled in itrender.c - /* let's avoid fading out when reaching the last envelope node */ - if (!(type & XM_ENVELOPE_LOOP)) { - instrument->volume_envelope.loop_start = instrument->volume_envelope.n_nodes-1; - instrument->volume_envelope.loop_end = instrument->volume_envelope.n_nodes-1; - } - instrument->volume_envelope.flags |= IT_ENVELOPE_LOOP_ON; + /* let's avoid fading out when reaching the last envelope node */ + if (!(type & XM_ENVELOPE_LOOP)) { + instrument->volume_envelope.loop_start = + instrument->volume_envelope.n_nodes - 1; + instrument->volume_envelope.loop_end = + instrument->volume_envelope.n_nodes - 1; + } + instrument->volume_envelope.flags |= IT_ENVELOPE_LOOP_ON; #endif - type = dumbfile_getc(f); - instrument->pan_envelope.flags = 0; - if ((type & XM_ENVELOPE_ON) && instrument->pan_envelope.n_nodes) - instrument->pan_envelope.flags |= IT_ENVELOPE_ON; - if (type & XM_ENVELOPE_LOOP) instrument->pan_envelope.flags |= IT_ENVELOPE_LOOP_ON; // should this be here? - if (type & XM_ENVELOPE_SUSTAIN) instrument->pan_envelope.flags |= IT_ENVELOPE_SUSTAIN_LOOP; + type = dumbfile_getc(f); + instrument->pan_envelope.flags = 0; + if ((type & XM_ENVELOPE_ON) && instrument->pan_envelope.n_nodes) + instrument->pan_envelope.flags |= IT_ENVELOPE_ON; + if (type & XM_ENVELOPE_LOOP) + instrument->pan_envelope.flags |= + IT_ENVELOPE_LOOP_ON; // should this be here? + if (type & XM_ENVELOPE_SUSTAIN) + instrument->pan_envelope.flags |= IT_ENVELOPE_SUSTAIN_LOOP; - if (it_xm_make_envelope(&instrument->volume_envelope, vol_points, 0) != 0) { - TRACE("XM error: volume envelope\n"); - if (instrument->volume_envelope.flags & IT_ENVELOPE_ON) return -1; - } + if (it_xm_make_envelope(&instrument->volume_envelope, vol_points, 0) != + 0) { + TRACE("XM error: volume envelope\n"); + if (instrument->volume_envelope.flags & IT_ENVELOPE_ON) + return -1; + } - if (it_xm_make_envelope(&instrument->pan_envelope, pan_points, -32) != 0) { - TRACE("XM error: pan envelope\n"); - if (instrument->pan_envelope.flags & IT_ENVELOPE_ON) return -1; - } + if (it_xm_make_envelope(&instrument->pan_envelope, pan_points, -32) != + 0) { + TRACE("XM error: pan envelope\n"); + if (instrument->pan_envelope.flags & IT_ENVELOPE_ON) + return -1; + } - instrument->pitch_envelope.flags = 0; + instrument->pitch_envelope.flags = 0; - extra->vibrato_type = dumbfile_getc(f); - extra->vibrato_sweep = dumbfile_getc(f); - extra->vibrato_depth = dumbfile_getc(f); - extra->vibrato_speed = dumbfile_getc(f); + extra->vibrato_type = dumbfile_getc(f); + extra->vibrato_sweep = dumbfile_getc(f); + extra->vibrato_depth = dumbfile_getc(f); + extra->vibrato_speed = dumbfile_getc(f); - if (dumbfile_error(f) || extra->vibrato_type > 4) // XXX - return -1; + if (dumbfile_error(f) || extra->vibrato_type > 4) // XXX + return -1; - /** WARNING: lossy approximation */ - instrument->fadeout = (dumbfile_igetw(f)*128 + 64)/0xFFF; + /** WARNING: lossy approximation */ + instrument->fadeout = (dumbfile_igetw(f) * 128 + 64) / 0xFFF; - dumbfile_skip(f, 2); /* reserved */ + dumbfile_skip(f, 2); /* reserved */ - bytes_read += 4 + 96 + 48 + 48 + 14*1 + 2 + 2; - } else - for (i = 0; i < 96; i++) - instrument->map_sample[i] = 0; + bytes_read += 4 + 96 + 48 + 48 + 14 * 1 + 2 + 2; + } else + for (i = 0; i < 96; i++) + instrument->map_sample[i] = 0; - if (size > bytes_read && dumbfile_skip(f, size - bytes_read)) - return -1; + if (size > bytes_read && dumbfile_skip(f, size - bytes_read)) + return -1; - if (skip_end && limit_xm_skip_end(f, skip_end)) - return -1; + if (skip_end && limit_xm_skip_end(f, skip_end)) + return -1; - instrument->new_note_action = NNA_NOTE_CUT; - instrument->dup_check_type = DCT_OFF; - instrument->dup_check_action = DCA_NOTE_CUT; - instrument->pp_separation = 0; - instrument->pp_centre = 60; /* C-5 */ - instrument->global_volume = 128; - instrument->default_pan = 32; - instrument->random_volume = 0; - instrument->random_pan = 0; - instrument->filter_cutoff = 0; - instrument->filter_resonance = 0; + instrument->new_note_action = NNA_NOTE_CUT; + instrument->dup_check_type = DCT_OFF; + instrument->dup_check_action = DCA_NOTE_CUT; + instrument->pp_separation = 0; + instrument->pp_centre = 60; /* C-5 */ + instrument->global_volume = 128; + instrument->default_pan = 32; + instrument->random_volume = 0; + instrument->random_pan = 0; + instrument->filter_cutoff = 0; + instrument->filter_resonance = 0; - return 0; + return 0; } - - /* I (entheh) have two XM files saved by a very naughty program. After a * 16-bit sample, it saved a rogue byte. The length of the sample was indeed * an odd number, incremented to include the rogue byte. @@ -654,611 +626,637 @@ static int it_xm_read_instrument(IT_INSTRUMENT *instrument, XM_INSTRUMENT_EXTRA * won't be accounted for by reading sample->length samples. It returns a * negative number on failure. */ -static int it_xm_read_sample_header(IT_SAMPLE *sample, DUMBFILE *f) -{ - int type; - int relative_note_number; /* relative to C4 */ - int finetune; - int roguebytes; - int roguebytesmask; - int reserved; +static int it_xm_read_sample_header(IT_SAMPLE *sample, DUMBFILE *f) { + int type; + int relative_note_number; /* relative to C4 */ + int finetune; + int roguebytes; + int roguebytesmask; + int reserved; - sample->length = dumbfile_igetl(f); - sample->loop_start = dumbfile_igetl(f); - sample->loop_end = sample->loop_start + dumbfile_igetl(f); - sample->global_volume = 64; - sample->default_volume = dumbfile_getc(f); - finetune = (signed char)dumbfile_getc(f); /* -128..127 <=> -1 semitone .. +127/128 of a semitone */ - type = dumbfile_getc(f); - sample->default_pan = dumbfile_getc(f); /* 0-255 */ - relative_note_number = (signed char)dumbfile_getc(f); + sample->length = dumbfile_igetl(f); + sample->loop_start = dumbfile_igetl(f); + sample->loop_end = sample->loop_start + dumbfile_igetl(f); + sample->global_volume = 64; + sample->default_volume = dumbfile_getc(f); + finetune = (signed char)dumbfile_getc( + f); /* -128..127 <=> -1 semitone .. +127/128 of a semitone */ + type = dumbfile_getc(f); + sample->default_pan = dumbfile_getc(f); /* 0-255 */ + relative_note_number = (signed char)dumbfile_getc(f); - reserved = dumbfile_getc(f); + reserved = dumbfile_getc(f); dumbfile_getnc((char *)sample->name, 22, f); - sample->name[22] = 0; + sample->name[22] = 0; trim_whitespace((char *)sample->name, 22); - sample->filename[0] = 0; + sample->filename[0] = 0; - if (dumbfile_error(f)) - return -1; + if (dumbfile_error(f)) + return -1; - sample->C5_speed = (long)(16726.0*pow(DUMB_SEMITONE_BASE, relative_note_number) /**pow(DUMB_PITCH_BASE, )*/ ); - sample->finetune = finetune*2; + sample->C5_speed = + (long)(16726.0 * pow(DUMB_SEMITONE_BASE, + relative_note_number) /**pow(DUMB_PITCH_BASE, )*/); + sample->finetune = finetune * 2; - sample->flags = IT_SAMPLE_EXISTS; + sample->flags = IT_SAMPLE_EXISTS; - if (reserved == 0xAD && - (!(type & (XM_SAMPLE_16BIT | XM_SAMPLE_STEREO)))) - { - /* F U Olivier Lapicque */ - roguebytes = 4; - roguebytesmask = 4 << 2; - } - else - { - roguebytes = (int)sample->length; - roguebytesmask = 3; - } + if (reserved == 0xAD && (!(type & (XM_SAMPLE_16BIT | XM_SAMPLE_STEREO)))) { + /* F U Olivier Lapicque */ + roguebytes = 4; + roguebytesmask = 4 << 2; + } else { + roguebytes = (int)sample->length; + roguebytesmask = 3; + } - if (type & XM_SAMPLE_16BIT) { - sample->flags |= IT_SAMPLE_16BIT; - sample->length >>= 1; - sample->loop_start >>= 1; - sample->loop_end >>= 1; - } else - roguebytesmask >>= 1; + if (type & XM_SAMPLE_16BIT) { + sample->flags |= IT_SAMPLE_16BIT; + sample->length >>= 1; + sample->loop_start >>= 1; + sample->loop_end >>= 1; + } else + roguebytesmask >>= 1; - if (type & XM_SAMPLE_STEREO) { - sample->flags |= IT_SAMPLE_STEREO; - sample->length >>= 1; - sample->loop_start >>= 1; - sample->loop_end >>= 1; - } else - roguebytesmask >>= 1; + if (type & XM_SAMPLE_STEREO) { + sample->flags |= IT_SAMPLE_STEREO; + sample->length >>= 1; + sample->loop_start >>= 1; + sample->loop_end >>= 1; + } else + roguebytesmask >>= 1; - roguebytes &= roguebytesmask; + roguebytes &= roguebytesmask; - if ((unsigned int)sample->loop_start < (unsigned int)sample->loop_end) { - if (type & XM_SAMPLE_FORWARD_LOOP) sample->flags |= IT_SAMPLE_LOOP; - if (type & XM_SAMPLE_PINGPONG_LOOP) sample->flags |= IT_SAMPLE_LOOP | IT_SAMPLE_PINGPONG_LOOP; - } + if ((unsigned int)sample->loop_start < (unsigned int)sample->loop_end) { + if (type & XM_SAMPLE_FORWARD_LOOP) + sample->flags |= IT_SAMPLE_LOOP; + if (type & XM_SAMPLE_PINGPONG_LOOP) + sample->flags |= IT_SAMPLE_LOOP | IT_SAMPLE_PINGPONG_LOOP; + } - if (sample->length <= 0) - sample->flags &= ~IT_SAMPLE_EXISTS; - else if ((unsigned int)sample->loop_end > (unsigned int)sample->length) - sample->flags &= ~IT_SAMPLE_LOOP; - else if ((unsigned int)sample->loop_start >= (unsigned int)sample->loop_end) - sample->flags &= ~IT_SAMPLE_LOOP; + if (sample->length <= 0) + sample->flags &= ~IT_SAMPLE_EXISTS; + else if ((unsigned int)sample->loop_end > (unsigned int)sample->length) + sample->flags &= ~IT_SAMPLE_LOOP; + else if ((unsigned int)sample->loop_start >= (unsigned int)sample->loop_end) + sample->flags &= ~IT_SAMPLE_LOOP; - return roguebytes; + return roguebytes; } +static int it_xm_read_sample_data(IT_SAMPLE *sample, unsigned char roguebytes, + DUMBFILE *f) { + int old; + long i; + long truncated_size; + int n_channels; + long datasize; + if (!(sample->flags & IT_SAMPLE_EXISTS)) + return dumbfile_skip(f, roguebytes); -static int it_xm_read_sample_data(IT_SAMPLE *sample, unsigned char roguebytes, DUMBFILE *f) -{ - int old; - long i; - long truncated_size; - int n_channels; - long datasize; + /* let's get rid of the sample data coming after the end of the loop */ + if ((sample->flags & IT_SAMPLE_LOOP) && sample->loop_end < sample->length && + roguebytes != 4) { + truncated_size = sample->length - sample->loop_end; + sample->length = sample->loop_end; + } else { + truncated_size = 0; + } - if (!(sample->flags & IT_SAMPLE_EXISTS)) - return dumbfile_skip(f, roguebytes); + n_channels = sample->flags & IT_SAMPLE_STEREO ? 2 : 1; + datasize = sample->length * n_channels; - /* let's get rid of the sample data coming after the end of the loop */ - if ((sample->flags & IT_SAMPLE_LOOP) && sample->loop_end < sample->length && roguebytes != 4) { - truncated_size = sample->length - sample->loop_end; - sample->length = sample->loop_end; - } else { - truncated_size = 0; - } + sample->data = malloc(datasize * (sample->flags & IT_SAMPLE_16BIT ? 2 : 1)); + if (!sample->data) + return -1; - n_channels = sample->flags & IT_SAMPLE_STEREO ? 2 : 1; - datasize = sample->length * n_channels; + if (roguebytes == 4) { + if (_dumb_it_read_sample_data_adpcm4(sample, f) < 0) + return -1; + roguebytes = 0; + } else { + /* sample data is stored as signed delta values */ + old = 0; + if (sample->flags & IT_SAMPLE_16BIT) + for (i = 0; i < sample->length; i++) + ((short *)sample->data)[i * n_channels] = old += + dumbfile_igetw(f); + else + for (i = 0; i < sample->length; i++) + ((signed char *)sample->data)[i * n_channels] = old += + dumbfile_getc(f); + } - sample->data = malloc(datasize * (sample->flags & IT_SAMPLE_16BIT ? 2 : 1)); - if (!sample->data) - return -1; + /* skip truncated data */ + dumbfile_skip(f, (sample->flags & IT_SAMPLE_16BIT) ? (2 * truncated_size) + : (truncated_size)); - if (roguebytes == 4) - { - if (_dumb_it_read_sample_data_adpcm4(sample, f) < 0) - return -1; - roguebytes = 0; - } - else - { - /* sample data is stored as signed delta values */ - old = 0; - if (sample->flags & IT_SAMPLE_16BIT) - for (i = 0; i < sample->length; i++) - ((short *)sample->data)[i*n_channels] = old += dumbfile_igetw(f); - else - for (i = 0; i < sample->length; i++) - ((signed char *)sample->data)[i*n_channels] = old += dumbfile_getc(f); - } + if (sample->flags & IT_SAMPLE_STEREO) { + old = 0; + if (sample->flags & IT_SAMPLE_16BIT) + for (i = 1; i < datasize; i += 2) + ((short *)sample->data)[i] = old += dumbfile_igetw(f); + else + for (i = 1; i < datasize; i += 2) + ((signed char *)sample->data)[i] = old += dumbfile_getc(f); - /* skip truncated data */ - dumbfile_skip(f, (sample->flags & IT_SAMPLE_16BIT) ? (2*truncated_size) : (truncated_size)); + /* skip truncated data */ + dumbfile_skip(f, (sample->flags & IT_SAMPLE_16BIT) + ? (2 * truncated_size) + : (truncated_size)); + } - if (sample->flags & IT_SAMPLE_STEREO) { - old = 0; - if (sample->flags & IT_SAMPLE_16BIT) - for (i = 1; i < datasize; i += 2) - ((short *)sample->data)[i] = old += dumbfile_igetw(f); - else - for (i = 1; i < datasize; i += 2) - ((signed char *)sample->data)[i] = old += dumbfile_getc(f); + dumbfile_skip(f, roguebytes); - /* skip truncated data */ - dumbfile_skip(f, (sample->flags & IT_SAMPLE_16BIT) ? (2*truncated_size) : (truncated_size)); - } + if (dumbfile_error(f)) + return -1; - dumbfile_skip(f, roguebytes); - - if (dumbfile_error(f)) - return -1; - - return 0; + return 0; } - - /* "Real programmers don't document. If it was hard to write, * it should be hard to understand." * * (Never trust the documentation provided with a tracker. * Real files are the only truth...) */ -static DUMB_IT_SIGDATA *it_xm_load_sigdata(DUMBFILE *f, int * version) -{ - DUMB_IT_SIGDATA *sigdata; - char id_text[18]; +static DUMB_IT_SIGDATA *it_xm_load_sigdata(DUMBFILE *f, int *version) { + DUMB_IT_SIGDATA *sigdata; + char id_text[18]; - int header_size; - int flags; - int n_channels; - int total_samples; - int i, j; + size_t header_size; + int flags; + int n_channels; + int total_samples; + int i, j; - /* check ID text */ - if (dumbfile_getnc(id_text, 17, f) < 17) - return NULL; - id_text[17] = 0; - if (strcmp(id_text, "Extended Module: ") != 0) { - TRACE("XM error: Not an Extended Module\n"); - return NULL; - } + /* check ID text */ + if (dumbfile_getnc(id_text, 17, f) < 17) + return NULL; + id_text[17] = 0; + if (strcmp(id_text, "Extended Module: ") != 0) { + TRACE("XM error: Not an Extended Module\n"); + return NULL; + } - sigdata = malloc(sizeof(*sigdata)); - if (!sigdata) - return NULL; + sigdata = malloc(sizeof(*sigdata)); + if (!sigdata) + return NULL; - /* song name */ + /* song name */ if (dumbfile_getnc((char *)sigdata->name, 20, f) < 20) { - free(sigdata); - return NULL; - } - sigdata->name[20] = 0; + free(sigdata); + return NULL; + } + sigdata->name[20] = 0; trim_whitespace((char *)sigdata->name, 20); - if (dumbfile_getc(f) != 0x1A) { - TRACE("XM error: 0x1A not found\n"); - free(sigdata); - return NULL; - } + if (dumbfile_getc(f) != 0x1A) { + TRACE("XM error: 0x1A not found\n"); + free(sigdata); + return NULL; + } - /* tracker name */ - if (dumbfile_skip(f, 20)) { - free(sigdata); - return NULL; - } + /* tracker name */ + if (dumbfile_skip(f, 20)) { + free(sigdata); + return NULL; + } - /* version number */ - * version = dumbfile_igetw(f); - if (* version > 0x0104 || * version < 0x0102) { - TRACE("XM error: wrong format version\n"); - free(sigdata); - return NULL; - } + /* version number */ + *version = dumbfile_igetw(f); + if (*version > 0x0104 || *version < 0x0102) { + TRACE("XM error: wrong format version\n"); + free(sigdata); + return NULL; + } - /* - ------------------ - --- Header --- - ------------------ - */ + /* + ------------------ + --- Header --- + ------------------ + */ - /* header size */ - header_size = dumbfile_igetl(f); - if (header_size < (4 + 2*8 + 1) || header_size > 0x114) { - TRACE("XM error: unexpected header size\n"); - free(sigdata); - return NULL; - } + /* header size */ + header_size = dumbfile_igetl(f); + if (header_size < (4 + 2 * 8 + 1) || header_size > 0x114) { + TRACE("XM error: unexpected header size\n"); + free(sigdata); + return NULL; + } - sigdata->song_message = NULL; - sigdata->order = NULL; - sigdata->instrument = NULL; - sigdata->sample = NULL; - sigdata->pattern = NULL; - sigdata->midi = NULL; - sigdata->checkpoint = NULL; + sigdata->song_message = NULL; + sigdata->order = NULL; + sigdata->instrument = NULL; + sigdata->sample = NULL; + sigdata->pattern = NULL; + sigdata->midi = NULL; + sigdata->checkpoint = NULL; - sigdata->n_samples = 0; - sigdata->n_orders = dumbfile_igetw(f); - sigdata->restart_position = dumbfile_igetw(f); - n_channels = dumbfile_igetw(f); /* max 32 but we'll be lenient */ - sigdata->n_pchannels = n_channels; - sigdata->n_patterns = dumbfile_igetw(f); - sigdata->n_instruments = dumbfile_igetw(f); /* max 128 */ /* XXX upped to 256 */ - flags = dumbfile_igetw(f); - sigdata->speed = dumbfile_igetw(f); - if (sigdata->speed == 0) sigdata->speed = 6; // Should we? What about tempo? - sigdata->tempo = dumbfile_igetw(f); + sigdata->n_samples = 0; + sigdata->n_orders = dumbfile_igetw(f); + sigdata->restart_position = dumbfile_igetw(f); + n_channels = dumbfile_igetw(f); /* max 32 but we'll be lenient */ + sigdata->n_pchannels = n_channels; + sigdata->n_patterns = dumbfile_igetw(f); + sigdata->n_instruments = dumbfile_igetw(f); + /* max 128 */ /* XXX upped to 256 */ + flags = dumbfile_igetw(f); + sigdata->speed = dumbfile_igetw(f); + if (sigdata->speed == 0) + sigdata->speed = 6; // Should we? What about tempo? + sigdata->tempo = dumbfile_igetw(f); - // FT2 always clips restart position against the song length - if (sigdata->restart_position > sigdata->n_orders) - sigdata->restart_position = sigdata->n_orders; - // And FT2 starts playback on order 0, regardless of length, - // and only checks if the next order is greater than or equal - // to this, not the current pattern. Work around this with - // DUMB's playback core by overriding a zero length with one. - if (sigdata->n_orders == 0) - sigdata->n_orders = 1; + // FT2 always clips restart position against the song length + if (sigdata->restart_position > sigdata->n_orders) + sigdata->restart_position = sigdata->n_orders; + // And FT2 starts playback on order 0, regardless of length, + // and only checks if the next order is greater than or equal + // to this, not the current pattern. Work around this with + // DUMB's playback core by overriding a zero length with one. + if (sigdata->n_orders == 0) + sigdata->n_orders = 1; - /* sanity checks */ - // XXX - i = header_size - 4 - 2 * 8; /* Maximum number of orders expected */ - if (dumbfile_error(f) || sigdata->n_orders <= 0 || sigdata->n_orders > i || !sigdata->n_patterns || sigdata->n_patterns > 256 || !sigdata->n_instruments || sigdata->n_instruments > 256 || n_channels > DUMB_IT_N_CHANNELS) { - _dumb_it_unload_sigdata(sigdata); - return NULL; - } + /* sanity checks */ + // XXX + i = (int)(header_size - 4 - 2 * 8); /* Maximum number of orders expected */ + if (dumbfile_error(f) || sigdata->n_orders <= 0 || sigdata->n_orders > i || + !sigdata->n_patterns || sigdata->n_patterns > 256 || + !sigdata->n_instruments || sigdata->n_instruments > 256 || + n_channels > DUMB_IT_N_CHANNELS) { + _dumb_it_unload_sigdata(sigdata); + return NULL; + } - //if (sigdata->restart_position >= sigdata->n_orders) - //sigdata->restart_position = 0; + // if (sigdata->restart_position >= sigdata->n_orders) + // sigdata->restart_position = 0; - /* order table */ - sigdata->order = malloc(sigdata->n_orders*sizeof(*sigdata->order)); - if (!sigdata->order) { - _dumb_it_unload_sigdata(sigdata); - return NULL; - } + /* order table */ + sigdata->order = malloc(sigdata->n_orders * sizeof(*sigdata->order)); + if (!sigdata->order) { + _dumb_it_unload_sigdata(sigdata); + return NULL; + } dumbfile_getnc((char *)sigdata->order, sigdata->n_orders, f); - dumbfile_skip(f, i - sigdata->n_orders); + dumbfile_skip(f, i - sigdata->n_orders); - if (dumbfile_error(f)) { - _dumb_it_unload_sigdata(sigdata); - return NULL; - } + if (dumbfile_error(f)) { + _dumb_it_unload_sigdata(sigdata); + return NULL; + } - if ( * version > 0x103 ) { - /* - -------------------- - --- Patterns --- - -------------------- - */ + if (*version > 0x103) { + /* + -------------------- + --- Patterns --- + -------------------- + */ - sigdata->pattern = malloc(sigdata->n_patterns * sizeof(*sigdata->pattern)); - if (!sigdata->pattern) { - _dumb_it_unload_sigdata(sigdata); - return NULL; - } - for (i = 0; i < sigdata->n_patterns; i++) - sigdata->pattern[i].entry = NULL; + sigdata->pattern = + malloc(sigdata->n_patterns * sizeof(*sigdata->pattern)); + if (!sigdata->pattern) { + _dumb_it_unload_sigdata(sigdata); + return NULL; + } + for (i = 0; i < sigdata->n_patterns; i++) + sigdata->pattern[i].entry = NULL; - { - unsigned char *buffer = malloc(1280 * n_channels); /* 256 rows * 5 bytes */ - if (!buffer) { - _dumb_it_unload_sigdata(sigdata); - return NULL; - } - for (i = 0; i < sigdata->n_patterns; i++) { - if (it_xm_read_pattern(&sigdata->pattern[i], f, n_channels, buffer, * version) != 0) { - free(buffer); - _dumb_it_unload_sigdata(sigdata); - return NULL; - } - } - free(buffer); - } + { + unsigned char *buffer = + malloc(1280 * n_channels); /* 256 rows * 5 bytes */ + if (!buffer) { + _dumb_it_unload_sigdata(sigdata); + return NULL; + } + for (i = 0; i < sigdata->n_patterns; i++) { + if (it_xm_read_pattern(&sigdata->pattern[i], f, n_channels, + buffer, *version) != 0) { + free(buffer); + _dumb_it_unload_sigdata(sigdata); + return NULL; + } + } + free(buffer); + } - /* - ----------------------------------- - --- Instruments and Samples --- - ----------------------------------- - */ + /* + ----------------------------------- + --- Instruments and Samples --- + ----------------------------------- + */ - sigdata->instrument = malloc(sigdata->n_instruments * sizeof(*sigdata->instrument)); - if (!sigdata->instrument) { - _dumb_it_unload_sigdata(sigdata); - return NULL; - } + sigdata->instrument = + malloc(sigdata->n_instruments * sizeof(*sigdata->instrument)); + if (!sigdata->instrument) { + _dumb_it_unload_sigdata(sigdata); + return NULL; + } - /* With XM, samples are not global, they're part of an instrument. In a - * file, each instrument is stored with its samples. Because of this, I - * don't know how to find how many samples are present in the file. Thus - * I have to do n_instruments reallocation on sigdata->sample. - * Looking at FT2, it doesn't seem possible to have more than 16 samples - * per instrument (even though n_samples is stored as 2 bytes). So maybe - * we could allocate a 128*16 array of samples, and shrink it back to the - * correct size when we know it? - * Alternatively, I could allocate samples by blocks of N (still O(n)), - * or double the number of allocated samples when I need more (O(log n)). - */ - total_samples = 0; - sigdata->sample = NULL; + /* With XM, samples are not global, they're part of an instrument. In a + * file, each instrument is stored with its samples. Because of this, I + * don't know how to find how many samples are present in the file. Thus + * I have to do n_instruments reallocation on sigdata->sample. + * Looking at FT2, it doesn't seem possible to have more than 16 samples + * per instrument (even though n_samples is stored as 2 bytes). So maybe + * we could allocate a 128*16 array of samples, and shrink it back to + * the correct size when we know it? Alternatively, I could allocate + * samples by blocks of N (still O(n)), or double the number of + * allocated samples when I need more (O(log n)). + */ + total_samples = 0; + sigdata->sample = NULL; - for (i = 0; i < sigdata->n_instruments; i++) { - XM_INSTRUMENT_EXTRA extra; + for (i = 0; i < sigdata->n_instruments; i++) { + XM_INSTRUMENT_EXTRA extra; - DUMBFILE * lf = dumbfile_limit_xm( f ); - if ( !lf ) { - _dumb_it_unload_sigdata(sigdata); - return NULL; - } + DUMBFILE *lf = dumbfile_limit_xm(f); + if (!lf) { + _dumb_it_unload_sigdata(sigdata); + return NULL; + } - if (it_xm_read_instrument(&sigdata->instrument[i], &extra, lf) < 0) { - // XXX - if ( ! i ) - { - TRACE("XM error: instrument %d\n", i+1); - dumbfile_close( lf ); - _dumb_it_unload_sigdata(sigdata); - return NULL; - } - else - { - dumbfile_close( lf ); - sigdata->n_instruments = i; - break; - } - } + if (it_xm_read_instrument(&sigdata->instrument[i], &extra, lf) < + 0) { + // XXX + if (!i) { + TRACE("XM error: instrument %d\n", i + 1); + dumbfile_close(lf); + _dumb_it_unload_sigdata(sigdata); + return NULL; + } else { + dumbfile_close(lf); + sigdata->n_instruments = i; + break; + } + } - if (extra.n_samples) { - unsigned char roguebytes[XM_MAX_SAMPLES_PER_INSTRUMENT]; + if (extra.n_samples) { + unsigned char roguebytes[XM_MAX_SAMPLES_PER_INSTRUMENT]; - /* adjust instrument sample map (make indices absolute) */ - for (j = 0; j < 96; j++) - sigdata->instrument[i].map_sample[j] += total_samples; + /* adjust instrument sample map (make indices absolute) */ + for (j = 0; j < 96; j++) + sigdata->instrument[i].map_sample[j] += total_samples; - sigdata->sample = safe_realloc(sigdata->sample, sizeof(*sigdata->sample)*(total_samples+extra.n_samples)); - if (!sigdata->sample) { - dumbfile_close( lf ); - _dumb_it_unload_sigdata(sigdata); - return NULL; - } - for (j = total_samples; j < total_samples+extra.n_samples; j++) - sigdata->sample[j].data = NULL; + sigdata->sample = safe_realloc( + sigdata->sample, sizeof(*sigdata->sample) * + (total_samples + extra.n_samples)); + if (!sigdata->sample) { + dumbfile_close(lf); + _dumb_it_unload_sigdata(sigdata); + return NULL; + } + for (j = total_samples; j < total_samples + extra.n_samples; + j++) + sigdata->sample[j].data = NULL; - if ( limit_xm_resize( lf, 0 ) < 0 ) { - dumbfile_close( lf ); - _dumb_it_unload_sigdata( sigdata ); - return NULL; - } + if (limit_xm_resize(lf, 0) < 0) { + dumbfile_close(lf); + _dumb_it_unload_sigdata(sigdata); + return NULL; + } - /* read instrument's samples */ - for (j = 0; j < extra.n_samples; j++) { - IT_SAMPLE *sample = &sigdata->sample[total_samples+j]; - int b; - if ( limit_xm_resize( lf, extra.sample_header_size ) < 0 ) { - dumbfile_close( lf ); - _dumb_it_unload_sigdata( sigdata ); - return NULL; - } - b = it_xm_read_sample_header(sample, lf); - if (b < 0) { - dumbfile_close( lf ); - _dumb_it_unload_sigdata(sigdata); - return NULL; - } - roguebytes[j] = b; - // Any reason why these can't be set inside it_xm_read_sample_header()? - sample->vibrato_speed = extra.vibrato_speed; - sample->vibrato_depth = extra.vibrato_depth; - sample->vibrato_rate = extra.vibrato_sweep; - /* Rate and sweep don't match, but the difference is - * accounted for in itrender.c. - */ - sample->vibrato_waveform = xm_convert_vibrato[extra.vibrato_type]; - sample->max_resampling_quality = -1; - } - for (j = 0; j < extra.n_samples; j++) { - if (it_xm_read_sample_data(&sigdata->sample[total_samples+j], roguebytes[j], f) != 0) { - dumbfile_close( lf ); - _dumb_it_unload_sigdata(sigdata); - return NULL; - } - } - total_samples += extra.n_samples; - } + /* read instrument's samples */ + for (j = 0; j < extra.n_samples; j++) { + IT_SAMPLE *sample = &sigdata->sample[total_samples + j]; + int b; + if (limit_xm_resize(lf, extra.sample_header_size) < 0) { + dumbfile_close(lf); + _dumb_it_unload_sigdata(sigdata); + return NULL; + } + b = it_xm_read_sample_header(sample, lf); + if (b < 0) { + dumbfile_close(lf); + _dumb_it_unload_sigdata(sigdata); + return NULL; + } + roguebytes[j] = b; + // Any reason why these can't be set inside + // it_xm_read_sample_header()? + sample->vibrato_speed = extra.vibrato_speed; + sample->vibrato_depth = extra.vibrato_depth; + sample->vibrato_rate = extra.vibrato_sweep; + /* Rate and sweep don't match, but the difference is + * accounted for in itrender.c. + */ + sample->vibrato_waveform = + xm_convert_vibrato[extra.vibrato_type]; + sample->max_resampling_quality = -1; + } + for (j = 0; j < extra.n_samples; j++) { + if (it_xm_read_sample_data( + &sigdata->sample[total_samples + j], roguebytes[j], + f) != 0) { + dumbfile_close(lf); + _dumb_it_unload_sigdata(sigdata); + return NULL; + } + } + total_samples += extra.n_samples; + } - dumbfile_close( lf ); - } + dumbfile_close(lf); + } - sigdata->n_samples = total_samples; - } else { - // ahboy! old layout! - // first instruments and sample headers, then patterns, then sample data! + sigdata->n_samples = total_samples; + } else { + // ahboy! old layout! + // first instruments and sample headers, then patterns, then sample + // data! - /* - ----------------------------------- - --- Instruments and Samples --- - ----------------------------------- - */ + /* + ----------------------------------- + --- Instruments and Samples --- + ----------------------------------- + */ - unsigned char * roguebytes = malloc( sigdata->n_instruments * XM_MAX_SAMPLES_PER_INSTRUMENT ); - if (!roguebytes) { - _dumb_it_unload_sigdata(sigdata); - return NULL; - } + unsigned char *roguebytes = + malloc(sigdata->n_instruments * XM_MAX_SAMPLES_PER_INSTRUMENT); + if (!roguebytes) { + _dumb_it_unload_sigdata(sigdata); + return NULL; + } - sigdata->instrument = malloc(sigdata->n_instruments * sizeof(*sigdata->instrument)); - if (!sigdata->instrument) { - free(roguebytes); - _dumb_it_unload_sigdata(sigdata); - return NULL; - } + sigdata->instrument = + malloc(sigdata->n_instruments * sizeof(*sigdata->instrument)); + if (!sigdata->instrument) { + free(roguebytes); + _dumb_it_unload_sigdata(sigdata); + return NULL; + } - total_samples = 0; - sigdata->sample = NULL; + total_samples = 0; + sigdata->sample = NULL; - for (i = 0; i < sigdata->n_instruments; i++) { - XM_INSTRUMENT_EXTRA extra; + for (i = 0; i < sigdata->n_instruments; i++) { + XM_INSTRUMENT_EXTRA extra; - DUMBFILE * lf = dumbfile_limit_xm( f ); - if ( !lf ) { - free(roguebytes); - _dumb_it_unload_sigdata(sigdata); - return NULL; - } + DUMBFILE *lf = dumbfile_limit_xm(f); + if (!lf) { + free(roguebytes); + _dumb_it_unload_sigdata(sigdata); + return NULL; + } - if (it_xm_read_instrument(&sigdata->instrument[i], &extra, lf) < 0) { - TRACE("XM error: instrument %d\n", i+1); - dumbfile_close(lf); - free(roguebytes); - _dumb_it_unload_sigdata(sigdata); - return NULL; - } + if (it_xm_read_instrument(&sigdata->instrument[i], &extra, lf) < + 0) { + TRACE("XM error: instrument %d\n", i + 1); + dumbfile_close(lf); + free(roguebytes); + _dumb_it_unload_sigdata(sigdata); + return NULL; + } - if (extra.n_samples) { - /* adjust instrument sample map (make indices absolute) */ - for (j = 0; j < 96; j++) - sigdata->instrument[i].map_sample[j] += total_samples; + if (extra.n_samples) { + /* adjust instrument sample map (make indices absolute) */ + for (j = 0; j < 96; j++) + sigdata->instrument[i].map_sample[j] += total_samples; - sigdata->sample = safe_realloc(sigdata->sample, sizeof(*sigdata->sample)*(total_samples+extra.n_samples)); - if (!sigdata->sample) { - dumbfile_close( lf ); - free(roguebytes); - _dumb_it_unload_sigdata(sigdata); - return NULL; - } - for (j = total_samples; j < total_samples+extra.n_samples; j++) - sigdata->sample[j].data = NULL; + sigdata->sample = safe_realloc( + sigdata->sample, sizeof(*sigdata->sample) * + (total_samples + extra.n_samples)); + if (!sigdata->sample) { + dumbfile_close(lf); + free(roguebytes); + _dumb_it_unload_sigdata(sigdata); + return NULL; + } + for (j = total_samples; j < total_samples + extra.n_samples; + j++) + sigdata->sample[j].data = NULL; - if ( limit_xm_resize( lf, 0 ) < 0 ) { - dumbfile_close( lf ); - free( roguebytes ); - _dumb_it_unload_sigdata( sigdata ); - return NULL; - } + if (limit_xm_resize(lf, 0) < 0) { + dumbfile_close(lf); + free(roguebytes); + _dumb_it_unload_sigdata(sigdata); + return NULL; + } - /* read instrument's samples */ - for (j = 0; j < extra.n_samples; j++) { - IT_SAMPLE *sample = &sigdata->sample[total_samples+j]; - int b; - if ( limit_xm_resize( lf, extra.sample_header_size ) < 0 ) { - dumbfile_close( lf ); - free( roguebytes ); - _dumb_it_unload_sigdata( sigdata ); - return NULL; - } - b = it_xm_read_sample_header(sample, lf); - if (b < 0) { - free(roguebytes); - _dumb_it_unload_sigdata(sigdata); - return NULL; - } - roguebytes[total_samples+j] = b; - // Any reason why these can't be set inside it_xm_read_sample_header()? - sample->vibrato_speed = extra.vibrato_speed; - sample->vibrato_depth = extra.vibrato_depth; - sample->vibrato_rate = extra.vibrato_sweep; - /* Rate and sweep don't match, but the difference is - * accounted for in itrender.c. - */ - sample->vibrato_waveform = xm_convert_vibrato[extra.vibrato_type]; - sample->max_resampling_quality = -1; - } - total_samples += extra.n_samples; - } + /* read instrument's samples */ + for (j = 0; j < extra.n_samples; j++) { + IT_SAMPLE *sample = &sigdata->sample[total_samples + j]; + int b; + if (limit_xm_resize(lf, extra.sample_header_size) < 0) { + dumbfile_close(lf); + free(roguebytes); + _dumb_it_unload_sigdata(sigdata); + return NULL; + } + b = it_xm_read_sample_header(sample, lf); + if (b < 0) { + free(roguebytes); + _dumb_it_unload_sigdata(sigdata); + return NULL; + } + roguebytes[total_samples + j] = b; + // Any reason why these can't be set inside + // it_xm_read_sample_header()? + sample->vibrato_speed = extra.vibrato_speed; + sample->vibrato_depth = extra.vibrato_depth; + sample->vibrato_rate = extra.vibrato_sweep; + /* Rate and sweep don't match, but the difference is + * accounted for in itrender.c. + */ + sample->vibrato_waveform = + xm_convert_vibrato[extra.vibrato_type]; + sample->max_resampling_quality = -1; + } + total_samples += extra.n_samples; + } - dumbfile_close( lf ); - } + dumbfile_close(lf); + } - sigdata->n_samples = total_samples; + sigdata->n_samples = total_samples; - /* - -------------------- - --- Patterns --- - -------------------- - */ + /* + -------------------- + --- Patterns --- + -------------------- + */ - sigdata->pattern = malloc(sigdata->n_patterns * sizeof(*sigdata->pattern)); - if (!sigdata->pattern) { - free(roguebytes); - _dumb_it_unload_sigdata(sigdata); - return NULL; - } - for (i = 0; i < sigdata->n_patterns; i++) - sigdata->pattern[i].entry = NULL; + sigdata->pattern = + malloc(sigdata->n_patterns * sizeof(*sigdata->pattern)); + if (!sigdata->pattern) { + free(roguebytes); + _dumb_it_unload_sigdata(sigdata); + return NULL; + } + for (i = 0; i < sigdata->n_patterns; i++) + sigdata->pattern[i].entry = NULL; - { - unsigned char *buffer = malloc(1280 * n_channels); /* 256 rows * 5 bytes */ - if (!buffer) { - free(roguebytes); - _dumb_it_unload_sigdata(sigdata); - return NULL; - } - for (i = 0; i < sigdata->n_patterns; i++) { - if (it_xm_read_pattern(&sigdata->pattern[i], f, n_channels, buffer, * version) != 0) { - free(buffer); - free(roguebytes); - _dumb_it_unload_sigdata(sigdata); - return NULL; - } - } - free(buffer); - } + { + unsigned char *buffer = + malloc(1280 * n_channels); /* 256 rows * 5 bytes */ + if (!buffer) { + free(roguebytes); + _dumb_it_unload_sigdata(sigdata); + return NULL; + } + for (i = 0; i < sigdata->n_patterns; i++) { + if (it_xm_read_pattern(&sigdata->pattern[i], f, n_channels, + buffer, *version) != 0) { + free(buffer); + free(roguebytes); + _dumb_it_unload_sigdata(sigdata); + return NULL; + } + } + free(buffer); + } - // and now we load the sample data - for (j = 0; j < total_samples; j++) { - if (it_xm_read_sample_data(&sigdata->sample[j], roguebytes[j], f) != 0) { - free(roguebytes); - _dumb_it_unload_sigdata(sigdata); - return NULL; - } - } + // and now we load the sample data + for (j = 0; j < total_samples; j++) { + if (it_xm_read_sample_data(&sigdata->sample[j], roguebytes[j], f) != + 0) { + free(roguebytes); + _dumb_it_unload_sigdata(sigdata); + return NULL; + } + } - free(roguebytes); - } + free(roguebytes); + } + sigdata->flags = IT_WAS_AN_XM | IT_OLD_EFFECTS | IT_COMPATIBLE_GXX | + IT_STEREO | IT_USE_INSTRUMENTS; + // Are we OK with IT_COMPATIBLE_GXX off? + // + // When specifying note + instr + tone portamento, and an old note is still + // playing (even after note off): + // - If Compatible Gxx is on, the new note will be triggered only if the + // instrument _changes_. + // - If Compatible Gxx is off, the new note will always be triggered, + // provided the instrument is specified. + // - FT2 seems to do the latter (unconfirmed). - sigdata->flags = IT_WAS_AN_XM | IT_OLD_EFFECTS | IT_COMPATIBLE_GXX | IT_STEREO | IT_USE_INSTRUMENTS; - // Are we OK with IT_COMPATIBLE_GXX off? - // - // When specifying note + instr + tone portamento, and an old note is still playing (even after note off): - // - If Compatible Gxx is on, the new note will be triggered only if the instrument _changes_. - // - If Compatible Gxx is off, the new note will always be triggered, provided the instrument is specified. - // - FT2 seems to do the latter (unconfirmed). + // Err, wait. XM playback has its own code. The change made to the IT + // playbackc code didn't affect XM playback. Forget this then. There's + // still a bug in XM playback though, and it'll need some investigation... + // tomorrow... - // Err, wait. XM playback has its own code. The change made to the IT - // playbackc code didn't affect XM playback. Forget this then. There's - // still a bug in XM playback though, and it'll need some investigation... - // tomorrow... + // UPDATE: IT_COMPATIBLE_GXX is required to be on, so that tone porta has + // separate memory from portamento. - // UPDATE: IT_COMPATIBLE_GXX is required to be on, so that tone porta has - // separate memory from portamento. + if (flags & XM_LINEAR_FREQUENCY) + sigdata->flags |= IT_LINEAR_SLIDES; - if (flags & XM_LINEAR_FREQUENCY) - sigdata->flags |= IT_LINEAR_SLIDES; + sigdata->global_volume = 128; + sigdata->mixing_volume = 48; + sigdata->pan_separation = 128; - sigdata->global_volume = 128; - sigdata->mixing_volume = 48; - sigdata->pan_separation = 128; + memset(sigdata->channel_volume, 64, DUMB_IT_N_CHANNELS); + memset(sigdata->channel_pan, 32, DUMB_IT_N_CHANNELS); - memset(sigdata->channel_volume, 64, DUMB_IT_N_CHANNELS); - memset(sigdata->channel_pan, 32, DUMB_IT_N_CHANNELS); + _dumb_it_fix_invalid_orders(sigdata); - _dumb_it_fix_invalid_orders(sigdata); - - return sigdata; + return sigdata; } - - #if 0 // no fucking way, dude! /* The length returned is the time required to play from the beginning of the @@ -1390,41 +1388,41 @@ long it_compute_length(const DUMB_IT_SIGDATA *sigdata) #endif /* 0 */ - -static char hexdigit(int in) -{ - if (in < 10) return in + '0'; - else return in + 'A' - 10; +static char hexdigit(int in) { + if (in < 10) + return in + '0'; + else + return in + 'A' - 10; } -DUH *dumb_read_xm_quick(DUMBFILE *f) -{ - sigdata_t *sigdata; - int ver; +DUH *dumb_read_xm_quick(DUMBFILE *f) { + sigdata_t *sigdata; + int ver; - DUH_SIGTYPE_DESC *descptr = &_dumb_sigtype_it; + DUH_SIGTYPE_DESC *descptr = &_dumb_sigtype_it; - sigdata = it_xm_load_sigdata(f, &ver); + sigdata = it_xm_load_sigdata(f, &ver); - if (!sigdata) - return NULL; + if (!sigdata) + return NULL; - { - char version[16]; - const char *tag[2][2]; - tag[0][0] = "TITLE"; + { + char version[16]; + const char *tag[2][2]; + tag[0][0] = "TITLE"; tag[0][1] = (const char *)(((DUMB_IT_SIGDATA *)sigdata)->name); - tag[1][0] = "FORMAT"; - version[0] = 'X'; - version[1] = 'M'; - version[2] = ' '; - version[3] = 'v'; - version[4] = hexdigit( ( ver >> 8 ) & 15 ); - version[5] = '.'; - version[6] = hexdigit( ( ver >> 4 ) & 15 ); - version[7] = hexdigit( ver & 15 ); - version[8] = 0; - tag[1][1] = ( const char * ) & version; - return make_duh(-1, 2, (const char *const (*)[2])tag, 1, &descptr, &sigdata); - } + tag[1][0] = "FORMAT"; + version[0] = 'X'; + version[1] = 'M'; + version[2] = ' '; + version[3] = 'v'; + version[4] = hexdigit((ver >> 8) & 15); + version[5] = '.'; + version[6] = hexdigit((ver >> 4) & 15); + version[7] = hexdigit(ver & 15); + version[8] = 0; + tag[1][1] = (const char *)&version; + return make_duh(-1, 2, (const char *const(*)[2])tag, 1, &descptr, + &sigdata); + } } diff --git a/Frameworks/Dumb/dumb/src/it/readxm2.c b/Frameworks/Dumb/dumb/src/it/readxm2.c index c79f753fd..56a48c8bb 100644 --- a/Frameworks/Dumb/dumb/src/it/readxm2.c +++ b/Frameworks/Dumb/dumb/src/it/readxm2.c @@ -19,11 +19,8 @@ #include "dumb.h" - - -DUH *dumb_read_xm(DUMBFILE *f) -{ - DUH *duh = dumb_read_xm_quick(f); - dumb_it_do_initial_runthrough(duh); - return duh; +DUH *dumb_read_xm(DUMBFILE *f) { + DUH *duh = dumb_read_xm_quick(f); + dumb_it_do_initial_runthrough(duh); + return duh; } diff --git a/Frameworks/Dumb/dumb/src/it/xmeffect.c b/Frameworks/Dumb/dumb/src/it/xmeffect.c index c490780b8..f851f1262 100644 --- a/Frameworks/Dumb/dumb/src/it/xmeffect.c +++ b/Frameworks/Dumb/dumb/src/it/xmeffect.c @@ -17,8 +17,6 @@ * \__/ */ - - #include #include #include @@ -72,28 +70,29 @@ static const char xm_has_memory[] = { }; #endif - - /* Effects marked with 'special' are handled specifically in itrender.c */ -void _dumb_it_xm_convert_effect(int effect, int value, IT_ENTRY *entry, int mod) -{ -const int log = 0; +void _dumb_it_xm_convert_effect(int effect, int value, IT_ENTRY *entry, + int mod) { + const int log = 0; - if ((!effect && !value) || (effect >= XM_N_EFFECTS)) - return; + if ((!effect && !value) || (effect >= XM_N_EFFECTS)) + return; -if (log) printf("%c%02X", (effect<10)?('0'+effect):('A'+effect-10), value); + if (log) + printf("%c%02X", (effect < 10) ? ('0' + effect) : ('A' + effect - 10), + value); - /* Linearisation of the effect number... */ - if (effect == XM_E) { - effect = EBASE + HIGH(value); - value = LOW(value); - } else if (effect == XM_X) { - effect = XBASE + HIGH(value); - value = LOW(value); - } + /* Linearisation of the effect number... */ + if (effect == XM_E) { + effect = EBASE + HIGH(value); + value = LOW(value); + } else if (effect == XM_X) { + effect = XBASE + HIGH(value); + value = LOW(value); + } -if (log) printf(" - %2d %02X", effect, value); + if (log) + printf(" - %2d %02X", effect, value); #if 0 // This should be handled in itrender.c! /* update effect memory */ @@ -119,128 +118,188 @@ if (log) printf(" - %2d %02X", effect, value); } #endif - /* convert effect */ - entry->mask |= IT_ENTRY_EFFECT; - switch (effect) { + /* convert effect */ + entry->mask |= IT_ENTRY_EFFECT; + switch (effect) { - case XM_APPREGIO: effect = IT_ARPEGGIO; break; - case XM_VIBRATO: effect = IT_VIBRATO; break; - case XM_TONE_PORTAMENTO: effect = IT_TONE_PORTAMENTO; break; - case XM_TREMOLO: effect = IT_TREMOLO; break; - case XM_SET_PANNING: effect = IT_SET_PANNING; break; - case XM_SAMPLE_OFFSET: effect = IT_SET_SAMPLE_OFFSET; break; - case XM_POSITION_JUMP: effect = IT_JUMP_TO_ORDER; break; - case XM_MULTI_RETRIG: effect = IT_RETRIGGER_NOTE; break; - case XM_TREMOR: effect = IT_TREMOR; break; - case XM_PORTAMENTO_UP: effect = IT_XM_PORTAMENTO_UP; break; - case XM_PORTAMENTO_DOWN: effect = IT_XM_PORTAMENTO_DOWN; break; - case XM_SET_CHANNEL_VOLUME: effect = IT_SET_CHANNEL_VOLUME; break; /* special */ - case XM_VOLSLIDE_TONEPORTA: effect = IT_VOLSLIDE_TONEPORTA; break; /* special */ - case XM_VOLSLIDE_VIBRATO: effect = IT_VOLSLIDE_VIBRATO; break; /* special */ + case XM_APPREGIO: + effect = IT_ARPEGGIO; + break; + case XM_VIBRATO: + effect = IT_VIBRATO; + break; + case XM_TONE_PORTAMENTO: + effect = IT_TONE_PORTAMENTO; + break; + case XM_TREMOLO: + effect = IT_TREMOLO; + break; + case XM_SET_PANNING: + effect = IT_SET_PANNING; + break; + case XM_SAMPLE_OFFSET: + effect = IT_SET_SAMPLE_OFFSET; + break; + case XM_POSITION_JUMP: + effect = IT_JUMP_TO_ORDER; + break; + case XM_MULTI_RETRIG: + effect = IT_RETRIGGER_NOTE; + break; + case XM_TREMOR: + effect = IT_TREMOR; + break; + case XM_PORTAMENTO_UP: + effect = IT_XM_PORTAMENTO_UP; + break; + case XM_PORTAMENTO_DOWN: + effect = IT_XM_PORTAMENTO_DOWN; + break; + case XM_SET_CHANNEL_VOLUME: + effect = IT_SET_CHANNEL_VOLUME; + break; /* special */ + case XM_VOLSLIDE_TONEPORTA: + effect = IT_VOLSLIDE_TONEPORTA; + break; /* special */ + case XM_VOLSLIDE_VIBRATO: + effect = IT_VOLSLIDE_VIBRATO; + break; /* special */ - case XM_PATTERN_BREAK: - effect = IT_BREAK_TO_ROW; - value = BCD_TO_NORMAL(value); - if (value > 63) value = 0; /* FT2, maybe ProTracker? */ - break; + case XM_PATTERN_BREAK: + effect = IT_BREAK_TO_ROW; + value = BCD_TO_NORMAL(value); + if (value > 63) + value = 0; /* FT2, maybe ProTracker? */ + break; - case XM_VOLUME_SLIDE: /* special */ - effect = IT_VOLUME_SLIDE; - value = HIGH(value) ? EFFECT_VALUE(HIGH(value), 0) : EFFECT_VALUE(0, LOW(value)); - break; + case XM_VOLUME_SLIDE: /* special */ + effect = IT_VOLUME_SLIDE; + value = HIGH(value) ? EFFECT_VALUE(HIGH(value), 0) + : EFFECT_VALUE(0, LOW(value)); + break; - case XM_PANNING_SLIDE: - effect = IT_PANNING_SLIDE; - //value = HIGH(value) ? EFFECT_VALUE(HIGH(value), 0) : EFFECT_VALUE(0, LOW(value)); - value = HIGH(value) ? EFFECT_VALUE(0, HIGH(value)) : EFFECT_VALUE(LOW(value), 0); - break; + case XM_PANNING_SLIDE: + effect = IT_PANNING_SLIDE; + // value = HIGH(value) ? EFFECT_VALUE(HIGH(value), 0) : EFFECT_VALUE(0, + // LOW(value)); + value = HIGH(value) ? EFFECT_VALUE(0, HIGH(value)) + : EFFECT_VALUE(LOW(value), 0); + break; - case XM_GLOBAL_VOLUME_SLIDE: /* special */ - effect = IT_GLOBAL_VOLUME_SLIDE; - value = HIGH(value) ? EFFECT_VALUE(HIGH(value), 0) : EFFECT_VALUE(0, LOW(value)); - break; + case XM_GLOBAL_VOLUME_SLIDE: /* special */ + effect = IT_GLOBAL_VOLUME_SLIDE; + value = HIGH(value) ? EFFECT_VALUE(HIGH(value), 0) + : EFFECT_VALUE(0, LOW(value)); + break; - case XM_SET_TEMPO_BPM: - if (mod) effect = (value <= 0x20) ? (IT_SET_SPEED) : (IT_SET_SONG_TEMPO); - else effect = (value < 0x20) ? (IT_SET_SPEED) : (IT_SET_SONG_TEMPO); - break; + case XM_SET_TEMPO_BPM: + if (mod) + effect = (value <= 0x20) ? (IT_SET_SPEED) : (IT_SET_SONG_TEMPO); + else + effect = (value < 0x20) ? (IT_SET_SPEED) : (IT_SET_SONG_TEMPO); + break; - case XM_SET_GLOBAL_VOLUME: - effect = IT_SET_GLOBAL_VOLUME; - value *= 2; - if (value > 128) value = 128; - break; + case XM_SET_GLOBAL_VOLUME: + effect = IT_SET_GLOBAL_VOLUME; + value *= 2; + if (value > 128) + value = 128; + break; - case XM_KEY_OFF: - effect = IT_XM_KEY_OFF; - break; + case XM_KEY_OFF: + effect = IT_XM_KEY_OFF; + break; - case XM_SET_ENVELOPE_POSITION: - effect = IT_XM_SET_ENVELOPE_POSITION; - break; + case XM_SET_ENVELOPE_POSITION: + effect = IT_XM_SET_ENVELOPE_POSITION; + break; - case EBASE+XM_E_SET_FILTER: effect = SBASE+IT_S_SET_FILTER; break; - case EBASE+XM_E_SET_GLISSANDO_CONTROL: effect = SBASE+IT_S_SET_GLISSANDO_CONTROL; break; /** TODO */ - case EBASE+XM_E_SET_FINETUNE: effect = SBASE+IT_S_FINETUNE; break; - case EBASE+XM_E_SET_LOOP: effect = SBASE+IT_S_PATTERN_LOOP; break; - case EBASE+XM_E_NOTE_CUT: effect = SBASE+IT_S_DELAYED_NOTE_CUT; break; - case EBASE+XM_E_NOTE_DELAY: effect = SBASE+IT_S_NOTE_DELAY; break; - case EBASE+XM_E_PATTERN_DELAY: effect = SBASE+IT_S_PATTERN_DELAY; break; - case EBASE+XM_E_SET_PANNING: effect = SBASE+IT_S_SET_PAN; break; - case EBASE+XM_E_FINE_VOLSLIDE_UP: effect = IT_XM_FINE_VOLSLIDE_UP; break; - case EBASE+XM_E_FINE_VOLSLIDE_DOWN: effect = IT_XM_FINE_VOLSLIDE_DOWN; break; - case EBASE+XM_E_SET_MIDI_MACRO: effect = SBASE+IT_S_SET_MIDI_MACRO; break; + case EBASE + XM_E_SET_FILTER: + effect = SBASE + IT_S_SET_FILTER; + break; + case EBASE + XM_E_SET_GLISSANDO_CONTROL: + effect = SBASE + IT_S_SET_GLISSANDO_CONTROL; + break; /** TODO */ + case EBASE + XM_E_SET_FINETUNE: + effect = SBASE + IT_S_FINETUNE; + break; + case EBASE + XM_E_SET_LOOP: + effect = SBASE + IT_S_PATTERN_LOOP; + break; + case EBASE + XM_E_NOTE_CUT: + effect = SBASE + IT_S_DELAYED_NOTE_CUT; + break; + case EBASE + XM_E_NOTE_DELAY: + effect = SBASE + IT_S_NOTE_DELAY; + break; + case EBASE + XM_E_PATTERN_DELAY: + effect = SBASE + IT_S_PATTERN_DELAY; + break; + case EBASE + XM_E_SET_PANNING: + effect = SBASE + IT_S_SET_PAN; + break; + case EBASE + XM_E_FINE_VOLSLIDE_UP: + effect = IT_XM_FINE_VOLSLIDE_UP; + break; + case EBASE + XM_E_FINE_VOLSLIDE_DOWN: + effect = IT_XM_FINE_VOLSLIDE_DOWN; + break; + case EBASE + XM_E_SET_MIDI_MACRO: + effect = SBASE + IT_S_SET_MIDI_MACRO; + break; - case EBASE + XM_E_FINE_PORTA_UP: - effect = IT_PORTAMENTO_UP; - value = EFFECT_VALUE(0xF, value); - break; + case EBASE + XM_E_FINE_PORTA_UP: + effect = IT_PORTAMENTO_UP; + value = EFFECT_VALUE(0xF, value); + break; - case EBASE + XM_E_FINE_PORTA_DOWN: - effect = IT_PORTAMENTO_DOWN; - value = EFFECT_VALUE(0xF, value); - break; + case EBASE + XM_E_FINE_PORTA_DOWN: + effect = IT_PORTAMENTO_DOWN; + value = EFFECT_VALUE(0xF, value); + break; - case EBASE + XM_E_RETRIG_NOTE: - effect = IT_XM_RETRIGGER_NOTE; - value = EFFECT_VALUE(0, value); - break; + case EBASE + XM_E_RETRIG_NOTE: + effect = IT_XM_RETRIGGER_NOTE; + value = EFFECT_VALUE(0, value); + break; - case EBASE + XM_E_SET_VIBRATO_CONTROL: - effect = SBASE+IT_S_SET_VIBRATO_WAVEFORM; - value &= ~4; - break; + case EBASE + XM_E_SET_VIBRATO_CONTROL: + effect = SBASE + IT_S_SET_VIBRATO_WAVEFORM; + value &= ~4; + break; - case EBASE + XM_E_SET_TREMOLO_CONTROL: - effect = SBASE+IT_S_SET_TREMOLO_WAVEFORM; - value &= ~4; - break; + case EBASE + XM_E_SET_TREMOLO_CONTROL: + effect = SBASE + IT_S_SET_TREMOLO_WAVEFORM; + value &= ~4; + break; - case XBASE + XM_X_EXTRAFINE_PORTA_UP: - effect = IT_PORTAMENTO_UP; - value = EFFECT_VALUE(0xE, value); - break; + case XBASE + XM_X_EXTRAFINE_PORTA_UP: + effect = IT_PORTAMENTO_UP; + value = EFFECT_VALUE(0xE, value); + break; - case XBASE + XM_X_EXTRAFINE_PORTA_DOWN: - effect = IT_PORTAMENTO_DOWN; - value = EFFECT_VALUE(0xE, value); - break; + case XBASE + XM_X_EXTRAFINE_PORTA_DOWN: + effect = IT_PORTAMENTO_DOWN; + value = EFFECT_VALUE(0xE, value); + break; - default: - /* user effect (often used in demos for synchronisation) */ - entry->mask &= ~IT_ENTRY_EFFECT; - } + default: + /* user effect (often used in demos for synchronisation) */ + entry->mask &= ~IT_ENTRY_EFFECT; + } -if (log) printf(" - %2d %02X", effect, value); + if (log) + printf(" - %2d %02X", effect, value); - /* Inverse linearisation... */ - if (effect >= SBASE && effect < SBASE+16) { - value = EFFECT_VALUE(effect-SBASE, value); - effect = IT_S; - } + /* Inverse linearisation... */ + if (effect >= SBASE && effect < SBASE + 16) { + value = EFFECT_VALUE(effect - SBASE, value); + effect = IT_S; + } -if (log) printf(" - %c%02X\n", 'A'+effect-1, value); + if (log) + printf(" - %c%02X\n", 'A' + effect - 1, value); - entry->effect = effect; - entry->effectvalue = value; + entry->effect = effect; + entry->effectvalue = value; }