diff options
Diffstat (limited to 'lib/libsamplerate/libsamplerate-0.2.2/docs')
21 files changed, 1199 insertions, 0 deletions
diff --git a/lib/libsamplerate/libsamplerate-0.2.2/docs/CMakeLists.txt b/lib/libsamplerate/libsamplerate-0.2.2/docs/CMakeLists.txt new file mode 100755 index 00000000..e1e8c697 --- /dev/null +++ b/lib/libsamplerate/libsamplerate-0.2.2/docs/CMakeLists.txt @@ -0,0 +1,19 @@ +install( + FILES + api.md + api_callback.md + api_full.md + api_misc.md + api_simple.md + bugs.md + download.md + faq.md + history.md + index.md + license.md + lists.md + quality.md + win32.md + SRC.png + DESTINATION + ${CMAKE_INSTALL_DOCDIR}) diff --git a/lib/libsamplerate/libsamplerate-0.2.2/docs/SRC.css b/lib/libsamplerate/libsamplerate-0.2.2/docs/SRC.css new file mode 100755 index 00000000..f5c10c86 --- /dev/null +++ b/lib/libsamplerate/libsamplerate-0.2.2/docs/SRC.css @@ -0,0 +1,56 @@ +a:link { + color: #FB1465; +} + +a:active, a:visited { + color: #FB1465; +} + +body { + background: black; + color: white; + font-family: arial, helvetica, sans-serif; +} + +h1, h2, h3, h4, h5, h6 { + color: #FB1465; +} + +code, kbd, samp, var { + font-family: courier, monospace; + font-size: 1em; +} + +main { + padding-left: 3%; + padding-right: 3%; +} + +pre { + font-family: courier, monospace; + font-size: 1em; +} + +.image-logo { + display: block; + margin-left: auto; + margin-right: auto; + margin-bottom: 1em; +} + +.indent_block { + margin-left: 10%; + margin-right: 10%; +} + +.nf { + font-weight: bold; +} + +.container { + display: flex; +} + +.content { + flex: 1; +} diff --git a/lib/libsamplerate/libsamplerate-0.2.2/docs/SRC.png b/lib/libsamplerate/libsamplerate-0.2.2/docs/SRC.png Binary files differnew file mode 100755 index 00000000..85f327b0 --- /dev/null +++ b/lib/libsamplerate/libsamplerate-0.2.2/docs/SRC.png diff --git a/lib/libsamplerate/libsamplerate-0.2.2/docs/_config.yml b/lib/libsamplerate/libsamplerate-0.2.2/docs/_config.yml new file mode 100755 index 00000000..79eae420 --- /dev/null +++ b/lib/libsamplerate/libsamplerate-0.2.2/docs/_config.yml @@ -0,0 +1,8 @@ +--- +author: Erik de Castro Lopo, erikd@mega-nerd.com +description: An audio Sample Rate Conversion library +keywords: libsamplerate, sound, resample, audio, dsp, Linux +version: 0.2.1 + +markdown: kramdown +--- diff --git a/lib/libsamplerate/libsamplerate-0.2.2/docs/_layouts/default.html b/lib/libsamplerate/libsamplerate-0.2.2/docs/_layouts/default.html new file mode 100755 index 00000000..33d41f53 --- /dev/null +++ b/lib/libsamplerate/libsamplerate-0.2.2/docs/_layouts/default.html @@ -0,0 +1,49 @@ +<!DOCTYPE html"> +<html lang="en"> + +<head> + <meta charset="utf-8"> + <meta name="viewport" content="width=device-width, initial-scale=1.0"> + <meta name="description" content="{{ site.description | page.description }}"> + <meta name="keywords" content="{{ site.keywords | page.keywords }}"> + <title>{{ page.title }}</title> + <link rel="stylesheet" href="SRC.css" type="text/css" media="all"> +</HEAD> + +<body> + <footer> + <img src="SRC.png" class="image-logo" height=100 width=760 alt="SRC.png"> + </footer> + <div class="container"> + <div class="navbar"> + <nav> + <a href="index.html">Home</a><br> + <a href="license.html">License</a><br> + <a href="history.html">History</a><br> + <a href="download.html">Download</a><br> + <a href="quality.html">Quality</a><br> + <a href="api.html">API</a><br> + <a href="bugs.html">Bug Reporting</a><br> + <a href="win32.html">On Win32</a><br> + <a href="faq.html">FAQ</a><br> + <a href="lists.html">Mailing Lists</a><br> + <a href="https://github.com/libsndfile/libsamplerate/blob/master/ChangeLog">ChangeLog</a><br> + </nav> + <div class="block"> + <p>Author:<br> Erik de Castro Lopo</p> + </div> + </div> + <div class="content"> + <main> + <article> + + {{ content }} + + </article> + </main> + </div> + </div> + +</body> + +</html>
\ No newline at end of file diff --git a/lib/libsamplerate/libsamplerate-0.2.2/docs/api.md b/lib/libsamplerate/libsamplerate-0.2.2/docs/api.md new file mode 100755 index 00000000..f673e0b7 --- /dev/null +++ b/lib/libsamplerate/libsamplerate-0.2.2/docs/api.md @@ -0,0 +1,46 @@ +--- +layout: default +--- + +# Applications Programming Interface + +The publically callable functions of libsamplerate are all listed in the +**\<samplerate.h\>** header file. In order to use any of the functionality of +libsamplerate, you need to add + +```c +#include <samplerate.h> +``` + +to the top of any function that call any of the following functions. You will +also need to link you binary with the libsamplerate library. + +The API allows three methods for accessing the capabilities of the library: + +- A [simple interface](api_simple.md) which can sample rate convert a single + block of samples (one or more channels) in one go. The simple API is less + capable than the full API. +- A [more fully featured interface](api_full.md) which allows time varying + sample rate conversion on streaming data (again one or more channels). +- A [callback interface](api_callback.md) which has the same functionality as + the interface above but allows the details of input and output to be + separated. The output is generated by call a read function and the library + calls a user supplied callback function to obtain its input. This interface is + particularly well suited to applications where the output sample rate is + varied with time. + +**NB :** All three access methods are able to process multi channel interleaved +data. + +The parts of the API which are common to all three interfaces are: + +- The [error reporting](api_misc.md#error-reporting) mechanisim. +- The available [converter](api_misc.md#converters) types. +- The [SRC_DATA](api_misc.md#src_data) struct. + +All three versions of the API are restricted to operating on buffers of ISO C +Standard **float** data. However, there are two [auxiliary functions](api_misc.md#auxiliary-functions) +for converting arrays of float data to and from short data. + +**Note:** The **tests/** and **examples/** directories of the source code +distribution contain numerous example programs showing the use of the library. diff --git a/lib/libsamplerate/libsamplerate-0.2.2/docs/api_callback.md b/lib/libsamplerate/libsamplerate-0.2.2/docs/api_callback.md new file mode 100755 index 00000000..45ca868e --- /dev/null +++ b/lib/libsamplerate/libsamplerate-0.2.2/docs/api_callback.md @@ -0,0 +1,88 @@ +--- +layout: default +--- + +# Callback API + +The callback API consists of the following functions : + +```c +typedef long (*src_callback_t) (void *cb_data, float **data) ; + +SRC_STATE* src_callback_new (src_callback_t func, + int converter_type, int channels, + int *error, void* cb_data) ; + +SRC_STATE* src_delete (SRC_STATE *state) ; + +long src_callback_read (SRC_STATE *state, double src_ratio, + long frames, float *data) ; + +int src_reset (SRC_STATE *state) ; +int src_set_ratio (SRC_STATE *state, double new_ratio) ; +``` + +Like the [simple API](api_simple.md) and the [full API](api_full.md), the +callback based API is able to operate on interleaved multi channel data. + +An example of the use of the callback based API can be found in the +**varispeed-play** program in the **examples/** directory of the source code +tarball. + +## Initialisation + +```c +SRC_STATE* src_callback_new (src_callback_t func, + int converter_type, int channels, + int *error, void* cb_data) ; +``` + +The **src_callback_new** function returns an anonymous pointer to a sample rate +converter callback object, src_state. This is the same type of object as that +returned by [src\_new](api_full.md#initialisation), but with different internal +state. Although these are the same object type, they cannot be used +interchangeably. If an error occurs the function returns a NULL pointer and +fills in the error value pointed to by the **error** pointer supplied by the +caller. + +The caller then passes the SRC_STATE object to the **src_callback_read** +function to pull data out of the converter. When the caller is finished with the +converter they should pass it to the clean up function [src_delete](api_full.md#cleanup). + +The **func** parameter is a user supplied function which must match the +**src_callback_t** type signature while **cb_data** is a pointer to data which +be passed as the first parameter to the user supplied callback function. This +function is called by the converter whenever it needs input data as a result of +being calls to **src_callback_read**. + +If the converter was initialised to work with more than one channel, the +callback function must work with mutiple channels of interleaved data. The +callback function should return the number of frames it supplying to the +converter. For multi channel files, this return value should be the number of +floats divided by the number of channels. + +The converter must be one of the supplied converter types documented [here](api_misc.md#converters). + +The caller then passes the SRC_STATE pointer to the **src_callback_read** +function to pull data out of the converter. + +## Callback Read + +```c +long src_callback_read (SRC_STATE *state, double src_ratio, + long frames, float *data) ; +``` + +The **src_callback_read** function is passed the [**SRC_STATE**](api_misc.md#src_data) +pointer returned by **src_callback_new**, the coversion ratio +(output_sample_rate / input_sample_rate), the maximum number of output frames to +generate and a pointer to a buffer in which to place the output data. For multi +channel files, the data int the output buffer is stored in interleaved format. + +The **src_callback_read** function returns the number of frames generated or +zero if an error occurs or it runs out of input (ie the user supplied callback +function returns zero and there is no more data buffered internally). If an +error has occurred, the function [src_error](api_misc.md#error-reporting) +will return non-zero. + +See also : [**src_set_ratio**](api_full.md#set-ratio) diff --git a/lib/libsamplerate/libsamplerate-0.2.2/docs/api_full.md b/lib/libsamplerate/libsamplerate-0.2.2/docs/api_full.md new file mode 100755 index 00000000..63eacdc9 --- /dev/null +++ b/lib/libsamplerate/libsamplerate-0.2.2/docs/api_full.md @@ -0,0 +1,146 @@ +--- +layout: default +--- + +# Full API + +The full API consists of the following functions : + +```c +SRC_STATE* src_new (int converter_type, int channels, int *error) ; +SRC_STATE* src_delete (SRC_STATE *state) ; + +int src_process (SRC_STATE *state, SRC_DATA *data) ; +int src_reset (SRC_STATE *state) ; +int src_set_ratio (SRC_STATE *state, double new_ratio) ; +``` + +## Initialisation + +```c +SRC_STATE* src_new (int converter_type, int channels, int *error) ; +``` + +The **src\_new** function returns an anonymous pointer to a sample rate +converter object, src\_state. If an error occurs the function returns a +NULL pointer and fills in the error value pointed to by the **error** +pointer supplied by the caller. The converter must be one of the +supplied converter types documented [here](api_misc.md#converters). + +## Cleanup + +```c +SRC_STATE* src_delete (SRC_STATE *state) ; +``` + +The **src\_delete** function frees up all memory allocated for the given +sample rate converter object and returns a NULL pointer. The caller is +responsible for freeing any memory passed to the sample rate converter +via the pointer to the **SRC\_DATA** struct. + +## Process + +```c +int src_process (SRC_STATE *state, SRC_DATA *data) ; +``` + +The **src\_process** function processes the data provided by the caller +in an **SRC\_DATA** struct using the sample rate converter object +specified by the **SRC\_STATE** pointer. When operating on streaming +data, this function can be called over and over again, with each new +call providing new input data and returning new output data. + +The **SRC\_DATA** struct passed as the second parameter to the +**src\_process** function has the following fields: + +```c +typedef struct +{ const float *data_in; + float *data_out; + + long input_frames, output_frames ; + long input_frames_used, output_frames_gen ; + + int end_of_input ; + + double src_ratio ; +} SRC_DATA ; +``` + +The fields of this struct which must be filled in by the caller are: + +data_in +: A pointer to the input data samples. + +input_frames +: The number of frames of data pointed to by data_in. + +data_out +: A pointer to the output data samples. + +output_frames +: Maximum number of frames pointer to by data_out. + +src_ratio +: Equal to output_sample_rate / input_sample_rate. + +end_of_input +: Equal to 0 if more input data is available and 1 otherwise. + +Note that the data\_in and data\_out arrays may not overlap. If they do, +the library will return an error code. + +When the **src\_process** function returns **output\_frames\_gen** will +be set to the number of output frames generated and +**input\_frames\_used** will be set to the number of input frames +consumed to generate the provided number of output frames. + +The **src\_process** function returns non-zero if an error occurs. The +non-zero error return value can be decoded into a text string using the +function documented [here](api_misc.md#error-reporting). + +## Reset + +```c +int src_reset (SRC_STATE *state) ; +``` + +The **src\_reset** function resets the internal state of the sample rate +converter object to the same state it had immediately after its creation +using **src\_new**. This should be called whenever a sample rate +converter is to be used on two separate, unrelated pieces of audio. + +## Clone + +```c +SRC_STATE* src_clone (SRC_STATE *state, int *error) ; +``` + +The **src_clone** function creates a copy of the internal state of the sample +rate converter object. The output of the next call to **src\_process** will be +identical for both the original and cloned state (given the same **SRC_DATA** +input). This could be used to later resume sample rate conversion at a specific +location in a stream with the same state, which may be useful in real-time +applications. + +If an error occurs the function returns a NULL pointer and fills in the +error value pointed to by the **error** pointer supplied by the caller. + +## Set Ratio + +```c +int src_set_ratio (SRC_STATE *state, double new_ratio) ; +``` + +When using the **src_process** or **src_callback_process** APIs and updating the +**src_ratio** field of the **SRC_STATE** struct, the library will try to +smoothly transition between the conversion ratio of the last call and the +conversion ratio of the current call. + +If the user wants to bypass this smooth transition and achieve a step response in +the conversion ratio, the **src_set_ratio** function can be used to set the +starting conversion ratio of the next call to **src_process** or +**src_callback_process**. + +This function returns non-zero on error and the error return value can be +decoded into a text string using the function documented [here](api_misc.md#error-reporting). diff --git a/lib/libsamplerate/libsamplerate-0.2.2/docs/api_misc.md b/lib/libsamplerate/libsamplerate-0.2.2/docs/api_misc.md new file mode 100755 index 00000000..9e9a53ba --- /dev/null +++ b/lib/libsamplerate/libsamplerate-0.2.2/docs/api_misc.md @@ -0,0 +1,145 @@ +--- +layout: default +--- + +# Miscellaneous API Documentation + +## Error Reporting + +Most of the API functions either return an integer error (ie **src_simple** and +**src_process**) or return an integer error value via an int pointer parameter +(**src_new**). These integer error values can be converted into human-readable +text strings by calling the function: + +```c +const char* src_strerror (int error) ; +``` + +which will return an error string for valid error numbers, the string +\"No Error\" for an error value of zero or a NULL pointer if no error message +has been defined for that error value. + +## Converters + +Secret Rabbit Code has a number of different converters which can be selected +using the **converter_type** parameter when calling **src_simple** or +**src_new**. Currently, the five converters available are: + +```c +enum +{ + SRC_SINC_BEST_QUALITY = 0, + SRC_SINC_MEDIUM_QUALITY = 1, + SRC_SINC_FASTEST = 2, + SRC_ZERO_ORDER_HOLD = 3, + SRC_LINEAR = 4 +} ; +``` + +As new converters are added, they will be given a number corresponding to the next +integer. + +The details of these converters are as follows: + +- **SRC_SINC_BEST_QUALITY** - This is a bandlimited interpolator derived from + the mathematical **sinc** function and this is the highest quality sinc based + converter, providing a worst case Signal-to-Noise Ratio (SNR) of 97 decibels + (dB) at a bandwidth of 97%. All three SRC_SINC_* converters are based on the + techniques of [Julius O. Smith](http://ccrma.stanford.edu/~jos/resample/) + although this code was developed independently. +- **SRC_SINC_MEDIUM_QUALITY** - This is another bandlimited interpolator much + like the previous one. It has an SNR of 97dB and a bandwidth of 90%. The speed + of the conversion is much faster than the previous one. +- **SRC_SINC_FASTEST** - This is the fastest bandlimited interpolator and has an + SNR of 97dB and a bandwidth of 80%. +- **SRC_ZERO_ORDER_HOLD** - A Zero Order Hold converter (interpolated value is + equal to the last value). The quality is poor but the conversion speed is + blindlingly fast. Be aware that this interpolator is not bandlimited, and the + user is responsible for adding anti-aliasing filtering. +- **SRC_LINEAR** - A linear converter. Again the quality is poor, but the + conversion speed is blindingly fast. This interpolator is also not bandlimited, + and the user is responsible for adding anti-aliasing filtering. + +There are two functions that give either a (text string) name or description for +each converter: + +```c +const char *src_get_name (int converter_type) ; +const char *src_get_description (int converter_type) ; +``` + +The name will typically be a short string for use in a dialog box, while the +description string is longer. + +Both of these functions return a NULL pointer if there is no converter for the +given **converter_type** value. Since the converters have consecutive +**converter_type** values, the caller is easily able to figure out the number of +converters at run time. This enables a binary dynamically linked against an old +version of the library to know about converters from later versions of the +library as they become available. + +## SRC_DATA + +Both the simple and the full featured versions of the API use the **SRC_DATA** +struct to pass audio and control data into the sample rate converter. This +struct is defined as: + +```c +typedef struct +{ const float *data_in; + float *data_out ; + + long input_frames, output_frames ; + long input_frames_used, output_frames_gen ; + + int end_of_input ; + + double src_ratio ; +} SRC_DATA ; +``` + +The **data_in** pointer is used to pass audio data into the converter while the +**data_out** pointer supplies the converter with an array to hold the +converter's output. For a converter which has been configured for multichannel +operation, these pointers need to point to a single array of interleaved data. + +The **input_frames** and **output_frames** fields supply the converter with the +lengths of the arrays (in frames) pointed to by the **data_in** and **data_out** +pointers respectively. For monophonic data, these values would indicate the +length of the arrays while for multi channel data these values would be equal to +the length of the array divided by the number of channels. + +The **end_of_input** field is only used when the sample rate converter is used +by calling the **src_process** function. In this case it should be set to zero +if more buffers are to be passed to the converter and 1 if the current buffer is +the last. + +Finally, the **src_ratio** field specifies the conversion ratio defined as the +output sample rate divided by the input sample rate. For a connected set of +buffers, this value can vary on each call to **src_process** resulting in a +time varying sample rate conversion process. For time varying sample rate +conversions, the ratio will be linearly interpolated between the **src_ratio** +value of the previous call to **src_process** and the value for the current +call. + +The **input_frames_used** and **output_frames_gen** fields are set by the +converter to inform the caller of the number of frames consumed from the +**data_in** array and the number of frames generated in the **data_out** array +respectively. These values are for the current call to **src_process** only. + +## Auxiliary Functions + +There are four auxiliary functions for converting arrays of float data to and +from short or int data. These functions are defined as: + +```c +void src_short_to_float_array (const short *in, float *out, int len) ; +void src_float_to_short_array (const float *in, short *out, int len) ; +void src_int_to_float_array (const int *in, float *out, int len) ; +void src_float_to_int_array (const float *in, int *out, int len) ; +``` + +The float data is assumed to be in the range [-1.0, 1.0] and it is automatically +scaled on the conversion to and from float. On the float to short/int conversion +path, any data values which would overflow the range of short/int data are +clipped. diff --git a/lib/libsamplerate/libsamplerate-0.2.2/docs/api_simple.md b/lib/libsamplerate/libsamplerate-0.2.2/docs/api_simple.md new file mode 100755 index 00000000..9947f3b6 --- /dev/null +++ b/lib/libsamplerate/libsamplerate-0.2.2/docs/api_simple.md @@ -0,0 +1,71 @@ +--- +layout: default +--- + +# Simple API + +**Important Note:** The simple API is not designed to work on small chunks of a +larger piece of audio. If you attempt to use it this way you are doing it wrong +and will not get the results you want. For processing audio data in chunks you +**must** use the [full api](api_full.md) or the [callback based api](api_callback.md). + +The simple API consists of a single function: + +```c +int src_simple (SRC_DATA *data, int converter_type, int channels) ; +``` + +The use of this function rather than the more fully featured API requires the +caller to know the total length of the input data before hand and that all input +and output data can be held in the system's memory at once. It also assumes that +there is a single constant ratio between input and output sample rates. + +Dealing with the easy stuff first, the **converter_type** parameter should be +one of the values defined in **samplerate.h** and documented [here](api_misc.md#converters) +while the **channels** parameter specifies the number of interleaved channels +that the sample rate converter is being asked to process (number of input +channels and output channels is always equal). There is no hard upper limit on +the number of channels; it is limited purely by the amount of memory available. + +The first parameter to **src_simple** is a pointer to an **SRC_DATA** struct +(more info [here](api_misc.md#src_data)) defined as follows: + +```c +typedef struct +{ const float *data_in; + float *data_out ; + + long input_frames, output_frames ; + long input_frames_used, output_frames_gen ; + + int end_of_input ; + + double src_ratio ; +} SRC_DATA ; +``` + +The fields of this struct which must be filled in by the caller are: + +data_in +: A pointer to the input data samples. + +input_frames +: The number of frames of data pointed to by data_in. + +data_out +: A pointer to the output data samples. + +output_frames +: Maximum number of frames pointer to by data_out. + +src_ratio +: Equal to output_sample_rate / input_sample_rate. + +When the **src_simple** function returns **output_frames_gen** will be set to +the number of output frames generated and **input_frames_used** will be set to +the number of input frames used to generate the provided number of output +frames. + +The **src_simple** function returns a non-zero value when an error occurs. See +[here](api_misc.md#error-reporting) for how to convert the error value into a +text string. diff --git a/lib/libsamplerate/libsamplerate-0.2.2/docs/bugs.md b/lib/libsamplerate/libsamplerate-0.2.2/docs/bugs.md new file mode 100755 index 00000000..ef24c459 --- /dev/null +++ b/lib/libsamplerate/libsamplerate-0.2.2/docs/bugs.md @@ -0,0 +1,37 @@ +--- +layout: default +--- + +# Bug Reporting + +If you are a user and have a problem using libsamplerate with another piece of +software, you should contact the author of that other software and get them to +explore their use of this library and possibly submit a bug report. If you are a +coder and think you have found a bug in libsamplerate then read on. + +Secret Rabbit Code is an extremely complex piece of code but I do think that it +is relatively bug free. In addition, the source code distribution includes a +comprehensive test suite for regression testing. This means it is extremely +unlikely that new bugs creep in when modifications are made to the code. + +SRC is also not the most simple library to use which means that I do get a +number of bug reports which turn out to be bugs in the user's program rather +than bugs in SRC. Up until now, I have investigated each bug report as +thoroughly as possible. Unfortunately, this chews up a lot of my time which +could otherwise be spent improving SRC, working on other Free Software or +spending time with my family. + +I have therefore decided, that I cannot investigate any bug report unless the +person reporting the problem can supply me with a short self contained test +program or a modification to one of the existing test programs in the tests/ +directory of the source code distribution. The test program should meet the +following criteria: + +- Written in C or C++. +- Does not use any libraries or header files other than the ones which are + standard for the relevant languages. (Of course libsamplerate can be used :-)). +- It is the minimal program which can adequately display the problem. +- It clearly displays the criteria for pass or fail. + +Supplying a good test program will maximize the speed with which your bug report +gets dealt with. diff --git a/lib/libsamplerate/libsamplerate-0.2.2/docs/download.md b/lib/libsamplerate/libsamplerate-0.2.2/docs/download.md new file mode 100755 index 00000000..7f0d32d0 --- /dev/null +++ b/lib/libsamplerate/libsamplerate-0.2.2/docs/download.md @@ -0,0 +1,15 @@ +--- +layout: default +--- + +# Download + +The latest version of Secret Rabbit Code is {{ site.version }}. + +Download it on [GitHub releases page](https://github.com/libsndfile/libsamplerate/releases/latest). + +Compiling libsamplerate is relatively easy. The INSTALL file in the top level +directory gives instructions on compiling and installing libsamplerate on +Unix-like systems (including MacOSX). For Win32 there are instructions in the +docs/ directory of the tarball. These instructions are mirrored +[here](win32.md). diff --git a/lib/libsamplerate/libsamplerate-0.2.2/docs/faq.md b/lib/libsamplerate/libsamplerate-0.2.2/docs/faq.md new file mode 100755 index 00000000..da3d87a9 --- /dev/null +++ b/lib/libsamplerate/libsamplerate-0.2.2/docs/faq.md @@ -0,0 +1,193 @@ +--- +layout: default +--- + +# Frequently Asked Questions + +1. [Q1 : Is it normal for the output of libsamplerate to be louder than its input?](#Q001) +2. [Q2 : On Unix/Linux/MacOSX, what is the best way of detecting the presence and location of libsamplerate and its header file using autoconf?](#Q002) +3. [Q3 : If I upsample and downsample to the original rate, for example 44.1-\>96-\>44.1, do I get an identical signal as the one before the up/down resampling?](#Q003) +4. [Q4 : If I ran src\_simple (libsamplerate) on small chunks (160 frames) would that sound bad?](#Q004) +5. [Q5 : I\'m using libsamplerate but the high quality settings sound worse than the SRC\_LINEAR converter. Why?](#Q005) +6. [Q6 : I\'m use the SRC\_SINC\_\* converters and up-sampling by a ratio of 2. I reset the converter and put in 1000 samples and I expect to get 2000 samples out, but I\'m getting less than that. Why?](#Q006) +7. [Q7 : I have input and output sample rates that are integer values, but the API wants me to divide one by the other and put the result in a floating point number. Won\'t this case problems for long running conversions?](#Q007) + +## Q1 : Is it normal for the output of libsamplerate to be louder than its input? {#Q001} + +The output of libsamplerate will be roughly the same volume as the input. +However, even if the input is strictly in the range (-1.0, 1.0), it is still +possible for the output to contain peak values outside this range. + +Consider four consecutive samples of [0.5 0.999 0.999 0.5]. If we are up +sampling by a factor of two we need to insert samples between each of the +existing samples. Its pretty obvious then, that the sample between the two 0.999 +values should and will be bigger than 0.999. + +This means that anyone using libsamplerate should normalize its output before +doing things like saving the audio to a 16 bit WAV file. + +## Q2 : On Unix/Linux/MacOSX, what is the best way of detecting the presence and location of libsamplerate and its header file using autoconf? {#Q002} + +libsamplerate uses the pkg-config (man pkg-config) method of registering itself +with the host system. The best way of detecting its presence is using something +like this in configure.ac (or configure.in): + + PKG_CHECK_MODULES(SAMPLERATE, samplerate >= 0.1.3, + ac_cv_samplerate=1, ac_cv_samplerate=0) + + AC_DEFINE_UNQUOTED([HAVE_SAMPLERATE],${ac_cv_samplerate}, + [Set to 1 if you have libsamplerate.]) + + AC_SUBST(SAMPLERATE_CFLAGS) + AC_SUBST(SAMPLERATE_LIBS) + +This will automatically set the **SAMPLERATE_CFLAGS** and **SAMPLERATE_LIBS** +variables which can be used in Makefile.am or Makefile.in like this: + + SAMPLERATE_CFLAGS = @SAMPLERATE_CFLAGS@ + SAMPLERATE_LIBS = @SAMPLERATE_LIBS@ + +If you install libsamplerate from source, you will probably need to set the +**PKG_CONFIG_PATH** environment variable's suggested at the end of the +libsamplerate configure process. For instance on my system I get this: + + -=-=-=-=-=-=-=-=-=-= Configuration Complete =-=-=-=-=-=-=-=-=-=-=- + + Configuration summary : + + Version : ..................... 0.1.3 + Enable debugging : ............ no + + Tools : + + Compiler is GCC : ............. yes + GCC major version : ........... 3 + + Extra tools required for testing and examples : + + Have FFTW : ................... yes + Have libsndfile : ............. yes + Have libefence : .............. no + + Installation directories : + + Library directory : ........... /usr/local/lib + Program directory : ........... /usr/local/bin + Pkgconfig directory : ......... /usr/local/lib/pkgconfig + +## Q3 : If I upsample and downsample to the original rate, for example 44.1->96->44.1, do I get an identical signal as the one before the up/down resampling? {#Q003} + +The short answer is that for the general case, no, you don't. The long answer is +that for some signals, with some converters, you will get very, very close. + +In order to resample correctly (ie using the **SRC_SINC_*** converters), +filtering needs to be applied, regardless of whether its upsampling or +downsampling. This filter needs to attenuate all frequencies above 0.5 times the +minimum of the source and destination sample rate (call this fshmin). Since the +filter needed to achieve full attenuation at this point, it has to start rolling +off a some frequency below this point. It is this rolloff of the very highest +frequencies which causes some of the loss. + +The other factor is that the filter itself can introduce transient artifacts +which causes the output to be different to the input. + +## Q4 : If I ran src_simple on small chunks (say 160 frames) would that sound bad? {#Q004} + +Well if you are after odd sound effects, it might sound OK. If you are after +high quality sample rate conversion you will be disappointed. + +The src_simple() was designed to provide a simple to use interface for people +who wanted to do sample rate conversion on say, a whole file all at once. + +## Q5 : I'm using libsamplerate but the high quality settings sound worse than the SRC_LINEAR converter. Why? {#Q005} + +There are two possible problems. Firstly, if you are using the src_simple() +function on successive blocks of a stream of samples, you will get bad results. +The src_simple() function is designed for use on a whole sound file, all at +once, not on contiguous segments of the same sound file. To fix the problem, you +need to move to the src_process() API or the callback based API. + +If you are already using the src_process() API or the callback based API and the +high quality settings sound worse than SRC_LINEAR, then you have other problems. +Read on for more debugging hints. + +All of the higher quality converters need to keep state while doing conversions +on segments of a large chunk of audio. This state information is kept inside the +private data pointed to by the SRC_STATE pointer returned by the src_new() +function. This means, that when you want to start doing sample rate conversion +on a stream of data, you should call src_new() to get a new SRC_STATE pointer +(or alternatively, call src_reset() on an existing SRC_STATE pointer). You +should then pass this SRC_STATE pointer to the src_process() function with each +new block of audio data. When you have completed the conversion, you can then +call src_delete() on the SRC_STATE pointer. + +If you are doing all of the above correctly, you need to examine your usage of +the values passed to src\_process() in the [SRC_DATA](api_misc.md#src_data) +struct. Specifically: + +- Check that input_frames and output_frames fields are being set in terms of + frames (number of sample values times channels) instead of just the number of + samples. +- Check that you are using the return values input_frames_used and + output_frames_gen to update your source and destination pointers correctly. +- Check that you are updating the data_in and data_out pointers correctly for + each successive call. + +While doing the above, it is probably useful to compare what you are doing to +what is done in the example programs in the examples/ directory of the source +code tarball. + +If you have done all of the above and are still having problems then its +probably time to email the author with the smallest chunk of code that +adequately demonstrates your problem. This chunk should not need to be any more +than 100 lines of code. + +## Q6 : I'm use the SRC_SINC_* converters and up-sampling by a ratio of 2. I reset the converter and put in 1000 samples and I expect to get 2000 samples out, but I'm getting less than that. Why? {#Q006} + +The short answer is that there is a transport delay inside the converter itself. +Long answer follows. + +By way of example, the first time you call src_process() you might only get 1900 +samples out. However, after that first call all subsequent calls will probably +get you about 2000 samples out for every 1000 samples you put in. + +The main problems people have with this transport delay is that they need to +read out an exact number of samples and the transport delay scews this up. The +best way to overcome this problem is to always supply more samples on the input +than is actually needed to create the required number of output samples. With +reference to the example above, if you always supply 1500 samples at the input, +you will always get 2000 samples at the output. You will always need to keep +track of the number of input frames used on each call to src_process() and deal +with these values appropriately. + +## Q7 : I have input and output sample rates that are integer values, but the API wants me to divide one by the other and put the result in a floating point number. Won't this case problems for long running conversions? {#Q007} + +The short answer is no, the precision of the ratio is many orders of magnitude +more than is really needed. + +For the long answer, lets do come calculations. Firstly, the `src_ratio` field +is double precision floating point number which has [53 bits of precision](http://en.wikipedia.org/wiki/Double_precision). + +That means that the maximum error in your ratio converted to a double is one bit +in 2^53 which means the double float value would be wrong by one sample +after 9007199254740992 samples have passed or wrong by more than half a sample +wrong after half that many (4503599627370496 samples) have passed. + +Now if for example our output sample rate is 96kHz then + + 4503599627370496 samples at 96kHz is 46912496118 seconds + 46912496118 seconds is 781874935 minutes + 781874935 minutes is 13031248 hours + 13031248 hours is 542968 days + 542968 days is 1486 years + +So, after 1486 years, the input will be wrong by more than half of one sampling +period. + +All this assumes that the crystal oscillators uses to sample the audio stream is +perfect. This is not the case. According to [this web site](http://www.ieee-uffc.org/freqcontrol/quartz/vig/vigcomp.htm), +the accuracy of standard crystal oscillators (XO, TCXO, OCXO) is at best 1 in +100 million. The `src_ratio` is therefore 45035996 times more accurate than the +crystal clock source used to sample the original audio signal and any potential +problem with the `src_ratio` being a floating point number will be completely +swamped by sampling inaccuracies. diff --git a/lib/libsamplerate/libsamplerate-0.2.2/docs/foo_dsp_src9.png b/lib/libsamplerate/libsamplerate-0.2.2/docs/foo_dsp_src9.png Binary files differnew file mode 100755 index 00000000..285c694c --- /dev/null +++ b/lib/libsamplerate/libsamplerate-0.2.2/docs/foo_dsp_src9.png diff --git a/lib/libsamplerate/libsamplerate-0.2.2/docs/history.md b/lib/libsamplerate/libsamplerate-0.2.2/docs/history.md new file mode 100755 index 00000000..46686b9b --- /dev/null +++ b/lib/libsamplerate/libsamplerate-0.2.2/docs/history.md @@ -0,0 +1,38 @@ +--- +layout: default +--- + +# History + +- Version 0.0.0 (Oct 06 2002) First alpha release (friends and family only). +- Version 0.0.2 (Oct 10 2002) Second alpha release (fools rush in ....). +- ... +- Version 0.0.7 (Nov 17 2002) The last mono only version. +- Version 0.0.9 (Nov 21 2002) Full multi channel support. First pass at + documentation. Still not ready for release. +- Version 0.0.11 (Nov 26 2002) Incorporated some suggestions from Conrad Parker. +- Version 0.0.12 (Nov 28 2002) First public release. +- Version 0.0.13 (Dec 03 2002) Fixes for MacOSX and Solaris. +- Version 0.0.14 (Jan 13 2003) Now compiles on Win32. Major code speedup. Minor + bug fixes. +- Version 0.0.15 (May 02 2003) Minor bug fixes. +- Version 0.1.0 (Mar 14 2004) Add callback API, functions for short to float and + float to short conversion. Minor bug fixes. +- Version 0.1.1 (Jul 17 2004) Callback API bug fix. Bugfix for aggressive + gcc-3.4 optimisations. +- Version 0.1.2 (Sep 12 2004) Callback API reset bug fix. +- Version 0.1.3 (Mar 23 2008) Huge quality improvements to two best SINC based + converters. +- Version 0.1.4 (Jul 02 2008) Fix segfault when using extremely low conversion + ratios. +- Version 0.1.5 (Jan 11 2009) Optimisation resulting in dramatic throughput + improvements ([See here.](http://www.mega-nerd.com/erikd/Blog/CodeHacking/SecretRabbitCode/rel_0_1_5.html)). +- Version 0.1.6 (Jan 27 2009) Minor bug fix in test suite (account for rounding + error on x86_64). +- Version 0.1.7 (Feb 14 2009) Fix a segfault bug. Fix compilation under MSVC. +- Version 0.1.8 (Aug 15 2011) Minor bug fixes and updates. +- Version 0.1.9 (Sep 19 2016) Fix for a segfault. Relicense under BSD license. +- Version 0.2.0 (Jan 21 2021) Cleaned up build system. +- Version 0.2.1 (Jan 23 2021) Fix libtool ABI versioning. +- Version 0.2.2 (Sep 05 2021) Fix ABI version incompatibility between Autotools + and CMake build on Apple platforms. Minor bug fixes and updates. diff --git a/lib/libsamplerate/libsamplerate-0.2.2/docs/index.md b/lib/libsamplerate/libsamplerate-0.2.2/docs/index.md new file mode 100755 index 00000000..4546d7bd --- /dev/null +++ b/lib/libsamplerate/libsamplerate-0.2.2/docs/index.md @@ -0,0 +1,160 @@ +--- +layout: default +title: Libsamplerate home page +--- + +{: .indent_block} +*"Choosing a sample rate coverter wasn't easy. We ran numerous tests with Secret +Rabbit Code and other sample rate converters, then compared them all. In the +end, SRC outperformed the others, including some extremely well known and +popular software. We had one issue with SRC, but after emailing Erik, he got +back to us immediately with an answer. Choosing SRC was a no brainer."* +Ryan Smith, International Marketing Manager, +[Emersys Corp.](http://emersys.co.kr/), South Korea. +Product : [Maven3D](http://maven3d.com) + +**S**ecret **R**abbit **C**ode (aka libsamplerate) is a **S**ample **R**ate +**C**onverter for audio. One example of where such a thing would be useful is +converting audio from the CD sample rate of 44.1kHz to the 48kHz sample rate +used by DAT players. + +**SRC** is capable of arbitrary and time varying conversions, from downsampling +by a factor of 256 to upsampling by the same factor. Arbitrary in this case +means that the ratio of input and output sample rates can be an irrational +number. The conversion ratio can also vary with time for speeding up and slowing +down effects. + +**SRC** provides a small set of converters to allow quality to be traded off +against computation cost. The current best converter provides a signal-to-noise +ratio of 145dB with -3dB passband extending from DC to 96% of the theoretical +best bandwidth for a given pair of input and output sample rates. + +Since the library has few dependencies beyond that provided by the standard C +library, it should compile and work on just about any operating system. It is +known to work on Linux, MacOSX, [Win32](win32.md) and Solaris. With some +relatively minor hacking it should also be relatively easy to port it to +embedded systems and digital signal processors. + +In addition, the library comes with a comprehensive test suite which can +validate the performance of the library on new platforms. + +## Download + +Check latest version on +[GitHub Releases page](https://github.com/libsndfile/libsamplerate/releases). + +Binaries and source packages are signed by current release manager David Seifert aka +@SoapGentoo. You can verify signatures with his public GPG key (`0xA47620E801E47E95`): + +``` +-----BEGIN PGP PUBLIC KEY BLOCK----- +Version: GnuPG v2 + +mQINBFppABgBEAC42ZiNvV7BTIgR6TQy0YnF54fx3mVRP1u8Mq00UZa7reAsNKh7 +1H60j0W4s6+4pVVIKGfpVGxLwUdJe+KVCYw1Cd3YW6uMf5zZrC/ZWqnJiH/n6S6o +1l4INII2o6YbGBnzIWBPRo7PlOL+mvgKTLpBSJPnhD8XDGN5wRiV8rL2+6Dptg0F +nJt7oxECGF3OD3gk6HMel0o82CVkIqMtNaX1L/bhcdF7K0Rp2MXPZMmpn1izW5sI +asN1G9+w+Zwj7kMJzq1Aw3ac+rsX4SEYdvXjS2QhDHQUIr6LXri3D2WbcEqIZj2R +JVoVwblsrG11dYXFDBbgrq4NhgTBsxHYDlkr/qF2W+kbPC/nhSqTVZeCYvTBZbOQ ++RqyN/I0izukglnWmV1jGijFA8snyP8efx732hw/24zRYmtXOtnEITUpw8WOeZCq +6uiHaQ+eopnY2ojBg9BI7WZm0AFn58xxT9soMsyFOUFgXTqaWFZWlJ3fhZE8/0v8 +JEu/kPGE5aJReT3b34B+Bojkj74XR+h2u7iJJBHMTE8RwGoUOZHer/XsL9xlcdks +I+7TCjiq++ShaSSt2XsJmw2BhREohrjW/2KkwmvT3b44RMpKPB4WTH+++aqJQNeM +IqmswOMoZvzEZezInj7WVY/r0WEei1Y6wt1tBrJ/cFf1oQBM1UmphxcrfQARAQAB +tB9EYXZpZCBTZWlmZXJ0IDxzb2FwQGdlbnRvby5vcmc+iQJUBBMBCgA+BQsJCAcD +BRUKCQgLBRYCAwEAAh4BAheAAhsBFiEEMdlcq22A0mIkShdQpHYg6AHkfpUFAl/V +CvoFCQkuceIACgkQpHYg6AHkfpXYxA//aiJW1NwunpmzEc62id8lRMnoLHWVjISZ +b+xSlm+hk4LYq+ZbthJDzKcT86/3DJOSE1zQw9wLuCao9IW2UfFJQBtR+TAfbagG +0Yyk/kMcLoFJxnG1ywdJWypCAauuIhia52Z7PmmjsBbFwr6LygDwSQmZAyACMAs7 +TLQe+yERc2RNDsIEsquLSxxRF0Spk9gagWtKgrPc2XBjuNtQDwW7JgsOUoEeHyxC +29fRUjC3o/pG2I6iAZp17OROZI5yl4TSORrSBDGIi2sayxyxP0x+IPKtrCUcBGNx +wGp+56bP/V0hA6sgCPh/iwvqLoeibso6l/Kd4ltVAEQnHTd6fr8g+wLEUXfbJVTR +7aeFUoaFmWjSPlQrNr6HlxSLV/kRx9kVJp1Pn16vkfVBF7fG7iDLiqphwEeQg5ND +nmGeKAbRRNxFHyBHf0XRsaYiFZQckguO+71XSRtVx8/YP5nyNbtl9y1h/4JlT6Gy +t7hb5twYFQyQrKss83E/Bo1sRdHpj0ibtqb4ZbYANbh482E6yFhAkuo8YjVTJipI +1Ve8EBKnX3R+pDt147uyysNvtPVXML+sWpGSMVSm4NA8uT3F5nqxVwj+SeXy3Wq/ +CHQ2VBKGBC655G+wFD5C6O7cTx2MwH+2H8tzhWm+gFlI3MFKEXa/PC+YUC/diYcb +BrApavriTRa5Ag0EWmkAZgEQAPXMD3mZI+ChvBysXZWksC88/uSEwFeb3XkcRm7v +04GN7hcz+bfrmnUTB3tuE/ZQgv+u7ZjetvH1aEKieznn/GjnWoOBoJusOYvfAQeF +0mQVi118QiOZRCnEZpkz+RY9TiXVgrZJg+AGqHZ3Ol4GkInEV2NWgH37Xal+HkFl +rwI2U7mL0kZRG+LAVCQHKzqU0R0HE1XyJ4qf0awtG5Qi/TZvgXBdZPDXgr8i9Vlf +UUu10c2XnXM0Av/YAlZmBFjVYrSOUCFenqSVqL+s9sTCVdWlJrGjrr3Ja4uT3kl2 +rLva0AR4oSQoxt8adKohmFz0vzOkQtCoRzhrCwoo3JvNjKdSNoOP1nSsxlO5ji8r +ih5d+ajPgi580XyHLnrvG7vobR48qqscv1hizKuCgTacOTe6Db2Gqc8xF6v8HhJa +KwWJtmFllIfN/tIvZ6BbbgHQn0IGf4CYnWf0SksPZqpBmTRpD2jfBxcj2UEg+AR3 +LARjuyUVpFJScyu6ExQG+6O+ByLL31iWP5MgUrza1rIpriPa3NT3rZ3DG2pvQrS3 +ySsrPzH7VRX8L1ThSMSzjwF96aMsd14s7XzR4EzNuWwZDukfs0yavZk6l4o1M0mb +tbJi7hE4cz13KRHYvIkKMdZGYUnzRzZUDlsj2imakk3BR6GXnxZ1ST6062g+QxiL +AJFLABEBAAGJBHIEGAEKACYCGwIWIQQx2VyrbYDSYiRKF1CkdiDoAeR+lQUCX9UL +DQUJCS5xpwJAwXQgBBkBCgAdFiEEuNUxXaAAcsCoYIifzjbhFyAuOEIFAlppAGYA +CgkQzjbhFyAuOELmrQ/9H9wrWsWa21STZdxUmyU2sh9VXAWEHl1Ey0fVTznDM0Fl +zx5YSR/TmmnE36rpaz31Ttkx8SP914oV+mMgseecdya9Bf6uZL9Cv7V3KEsJBRL/ +ncrOWQBHP/Xy1X+mLD6A19xq7H4RihSLj0LeK2YVjrJzJ7wMf4mKXuBayQeAHImU +WRCRTbmK3umh2nB5V0iPd/XZEIiYtiTPe+7E/va6+0bBvOumF3a+Z0iui7eU4hFC +7Jk71D0dcg09SlIaNoMOrw7cMC3j2pMdKtsj8+0I6WBv14PhhqPAsnjdf7I/4NfK +L7Jav8T/gDS01uA2Jxm72d+wr+eSjOBXa6x8CEbTqfkjAGxsWENThCp6zDkaXSDd +JsV0va47vjzG8+wTDAvPy5IxIM/KZZdl4uWM+mF5K+q+eSTOHe7aLF2OdcussoBA +A18zm994dAkG1COX/qpxanxx2bv/2IvCGPg+x6JtAN8ji2kncWu3dWGQdE5XbVjc +fDwgsUPpp04G27Mr/x+HpEbgZ5SdA0dAqJktlNvCcHALhlblCWrsh/1QNjT/2iG8 +wsjcpEy/s4tWAuV4PTa4xvZ1JPS7Z7Eo5aBy9ZGOWG9SrHEiHnhkUsiswbHBOEjd +pBSkmNElDcv9fRUahVCTPfvWBATFDrQyMjJBSm+cV8c/iFQM7isVSu8W7E0eetsJ +EKR2IOgB5H6Vv9sP/1dxTvH0N0UoEoxIG/hnirEkbRpljdvqy4/uikYBKyQgSbo8 +VITTjea7gIhDztil9WZYt35jbOmoaGM2Z6TP2LEDOWgljYUNq9pl9Sc2GS8cNtEO +WxExzGOc1Flo730dX3A85Ks3+0WPXZjLDcRRcPVkFd5WLQQDV1YVYopWkuQBC+Br +4q3uv+sk+bw6gDa9+zFBbDuegdsYuTXrFHoxHz2GRv9Yb7ULCMgpFeNKDgtQq91u +RqewoTwQp9tlp91LH/hh7R0Q4DRgeFDkLnVRXwSKjVvCrT5cBgImGwtFTGS4egoy +MDKd/KKjZllp1ahRCln1XfmFQyQVMVvuF/JTtt31n6KwXwK2yxIlXB01xvRH+Ees +AWeRYWKWXydaAY/9Ve0/PLFlgsr/XUGvt0GoEKe7odD3nZgg6015+/8JTroKw19L +NZkhdfFMl11Zi0j5k3UbyzjYVpFSd8K2o0VoOG1LFsPp8tlRxNoVzpId0CX1au/p +y1H7Wy/39mzriRG3rw+mJAQbBjN09putCltXFXpOEWk08n/N3vufCVQUoSu/2Bqw +2HYj8VtToQp+O5dG3XxvDHINtInP1yr2Wcw2plna0KoXLwv/lZgDm3LN+eCWpG6d +N/xk25DTSqTHArUQIEkhcHYK6GnyxUcvoKtG88hXtqEPYXiK08FZYAUPTnDYuQIN +BFppAIkBEADDjvQZUs1NoqJpxkD2QDBudU1DBCaeI1D6CancMtb5FebPUxgFlDMd +CBGOun48dY5i87gDhT/qS3gP/Mv9rjKJmcG9JHfhpXdW73owxrcsQ96nxxVJNEVl +UHJw00z8C9eGWqr0SzSoE33K/PkzSkgtsaotF6+3uCerWulweulmGa5dpVfV0mbS +aVw8VmrhZ5NmCeodyy/lR85rPik5pb32NT6v7xBkgkfS0VYtPB2E5gW1pXX/jEOi +Mfq9idOEP9lxrNXV9j49Lr0JQCwAcrYbQ2+VPe6eacJEjzJ/6HiUqhPrYdnvydmb +hU+xmv2NjGp2UnDZDEhzQfwm6fMx+8Nx2uPzCnXQGoyRBwiC/KcdW0F1ZPKdSXqH +NKoOF62pLvIMSmfI3ZVOrTohArfr1kFEYVDv9Nl7oY+qg2rZEc2srOF74a9Z46bR +TDPsEQzE2UMCvu3+rofhSD7aRotlKeDCvbe2s0yE4Man457Xc3LXh8Gva8CzCOLE +2eMhNTsHIZk68WgXp3/uvE4Xy42myrk1AV8XXDdlWgx0Kc/I6tE59O5NVPSfuGvH +1a15KKx0F6euEnYDKKpQ5PDR6dSn61po0tfbt96m044G/xQFjrfhHei4jji9Ogd9 +vlXVAi2vn3+NCSHFP5l3igLByBHy9iLIdmz7yQuus/1nwRmxOHOf2QARAQABiQI8 +BBgBCgAmAhsMFiEEMdlcq22A0mIkShdQpHYg6AHkfpUFAl/VCxkFCQkucZAACgkQ +pHYg6AHkfpVPSRAAmheYkYJmtDbkzPBBnj5mbCIQN1/G5PI9eixc/TXWFOXtcjU1 +mJlJpSidHJyLRrx7r0c+N+s8vnY/JuUBsNoMJMER+Mv/CFW4iFi59V534SyAb2S0 +7NINJnFNkXBY62CDz9KsMuv/MdSv2yLhPH2Tfrm/eDRQesj1PanE4U1cgjWyJRc/ +IOlaRHvTasWDLgwbQi8ykt+4xUWzL/YKHzB+KyyzBK7vPBXqySX8ka4BOw7SDwG5 +lX2gtmhk4AGBwVChLXKflqVx1WXj4DPOt0kmOKVnKFyvUijK58M0A2FMgFMXDTIS +DRtoZPdx/rkODXxgS+W+27NcYAnxJiM0cQqizEnQh7PQ1KzgdChPejYXMKe9lwdn +ssMUxrBpbuAuagEf+pebNjD2eaNR4p8kfaDdGn53q55ysDvoyxKvnVQGSk1FAR9Q +s4N5a4f02U7dzlyEhEfIcuUlRCfnlpn4n725YIhHheDig5zKWoEZCkNIfiRcGzDl +8Drj+tlZiUR+gDkIoWSBaCkKbIQlc8qCYy6Hm7oZBaol6xKlUnTMK2rjK8fR4i8r +bVDWBAaWj3jcDHJ0Jg3fS/qBpeya/JXMp89TR8NK5Ys7PZpWbor+puXBYyXDAVx3 +rXQ7JBA5klHPxrgjso1S/LqwscKLENtrVjdjhryLBmPifrmofJRnrpiHIEa5Ag0E +WmkAswEQAL0hKwsRybQzkNGpJP+ElLSwFHd7XQhr+qIwLllpumWtnIK/DHmv8SpW +FqAYajmRTXipFcBHH25x2jIIliZidn0a9826l+sMzrFadMC6/W4pitP71TeqZzwn +pAuHs14YL7Wiy0aJQnfbCpRzPq3kYyOXmhmY7lPWO0WdUpR6W8wUbleK5XOVDDRx +aIC/M3hhDOxZOMzQ+pdn4BaOFQQ0ygsRkqOudbuc0R1giYRt1i6gMeT8gfzL9jlw +HcJ+aVnxdUQQ4uC47oKo/+lg7qh7LsiW79pQC1Bcdm8lhRmqtxe6ub60ecjax3XU +1ILIEfIFCv6M7LRUAwz0bqk35spgkJqrGGKkdeWEKAFHg2QWR2F0zy+HdlPLfKxO +uhaccpwc9EJtf744GS0SXa2AXr32j56n7CFcEjFcIQPBC6OJn6eA3hOVUYGZ7SrT +4fsmZiFAdGEkvLKFuNhju1Hj2EJQUY1pm4GSBco7BR8x+QqoYrt5clU3WxRMNfTR +0Rtuzsh4xskXNVMMgvKOahAtxENv2M2Cx6zJPVL5dmaysP7d6QRVeOQA5PwkcZ5Q +qK6JtDZj2jpaKQH4Za715kiIcdqMDSkwxa6avc0kARHvfFcBR4hwDm1GAlaKG7eH +8TOGGQIk8x2F3s4l8mTJVLWTP/uJYnkYBdqANYo5t1NIQLvwLFV3ABEBAAGJAjwE +GAEKACYCGyAWIQQx2VyrbYDSYiRKF1CkdiDoAeR+lQUCX9ULIwUJCS5xcAAKCRCk +diDoAeR+leekD/sF7aHH0W35ckWrXZlfSp0qHPWrBUaLBI9OAUHenRhgs4SbK0D4 +wqEiu0C5iDQojpXAeALQ8g/1pUsZ1yuFqYbGYWrHkA0Pm+P3tAGB4LMZ41YfvROP +uaiW/+IMJbWllgRtaDt8/NtCgs30WI9I+az5M29HcGfvEwEUykrBx3dE9T+1ui3O +capdd+GMvdAAsX5PyVkjWgZ7GrZeH8mG7UysYfT4qthxEtQfZ/u8ceSduKA46ugh +C2eafIDNvluqn7BU4oKxME61u6C8BN2yHLI6LV0Tr4z5H8joVbM4BSFMwLVGlsXf +HhB8kLiErN6bXolxsjARlmYiD9S9H2AcYidr6RYXf2EVFSpBG59xn1WTDN+DsHQf +7btNPEPl/OPxa3OQjG+xn8USddiP0N0B4xsyzMNCCKDgvXXcIhX55KG9eh3Tc98S +fEyhxu8ybZBIGmTJysPKxijfvSgQF+RPNTsz9lvXqkoK7RTgeYMschpjJEznCLbt +M6eTDb5z0G5uLXh6+dYxtDOlPogI5OHd+G51LwCjvrQ+AtIUCgafuemwA9mpFT2b +svb/qcxSVUb44bVaNHn1JHebX2YbokGtBOm1x2PI5fT8n6YIIYz3jKYOZAYdUT7x +6qURyNjOfG4aPJIATwuh4GSNuxUG40+yuT+XfQF24mu1esS1J3wzRloJ7w== +=K3x+ +-----END PGP PUBLIC KEY BLOCK----- +``` diff --git a/lib/libsamplerate/libsamplerate-0.2.2/docs/license.md b/lib/libsamplerate/libsamplerate-0.2.2/docs/license.md new file mode 100755 index 00000000..95c7f858 --- /dev/null +++ b/lib/libsamplerate/libsamplerate-0.2.2/docs/license.md @@ -0,0 +1,12 @@ +--- +layout: default +--- + +# License + +From its first release in 2002, Secret Rabbit Code was under a dual licensing +scheme where people could chose to use it under the terms of the GNU General +Public License or pay for a commercial use license. + +In 2016, thanks to a generous offer from Epic Games International, Secret Rabbit +Code was relicensed under the 2-clause BSD license. diff --git a/lib/libsamplerate/libsamplerate-0.2.2/docs/lists.md b/lib/libsamplerate/libsamplerate-0.2.2/docs/lists.md new file mode 100755 index 00000000..fa04e38f --- /dev/null +++ b/lib/libsamplerate/libsamplerate-0.2.2/docs/lists.md @@ -0,0 +1,17 @@ +--- +layout: default +--- + +# Mailing Lists + +There are currently two mailings lists for Secret Rabbit Code: + +- **src-announce\@mega-nerd.com** + [Subscribe](mailto:src-announce-request@mega-nerd.com?subject=subscribe) + + A read only announcement list. +- **src\@mega-nerd.com** + [Subscribe](mailto:src-request@mega-nerd.com?subject=subscribe) + + A general list which will also carry all the email from the announce + list. Posting to this list is restricted to subscribers. diff --git a/lib/libsamplerate/libsamplerate-0.2.2/docs/paypal.png b/lib/libsamplerate/libsamplerate-0.2.2/docs/paypal.png Binary files differnew file mode 100755 index 00000000..2706d25b --- /dev/null +++ b/lib/libsamplerate/libsamplerate-0.2.2/docs/paypal.png diff --git a/lib/libsamplerate/libsamplerate-0.2.2/docs/quality.md b/lib/libsamplerate/libsamplerate-0.2.2/docs/quality.md new file mode 100755 index 00000000..5c69578e --- /dev/null +++ b/lib/libsamplerate/libsamplerate-0.2.2/docs/quality.md @@ -0,0 +1,84 @@ +--- +layout: default +--- + +# SRC Quality + +**This document not yet complete.** + +When measuring the performance of a Sample Rate Converter, there are three +factors to consider: + +- **Signal-to-Noise Ratio** - a measure of how much noise the sample rate + conversion process adds to the signal. This is measured in decibels (dB) and + the higher this value the better. For most sample rate converters, the SNR + will vary depending on the input signal and the ratio between input and output + sample rates. The only valid comparison of SNR is between the worst case for + each converter. +- **Bandwidth** - most sample rate converters attenuate high frequencies as part + of their operation. Bandwidth can be measured by finding the frequency where + the attenuation is 3dB and expressing that as a percentage of the full + bandwidth at that sampling rate. +- **Speed** - the faster the better **:-)**. + +There are a number of sample rate converters available for downloading but I +will limit the comparison of Secret Rabbit Code to the following: + +- [sndfile-resample](http://libsndfile.github.io/libsamplerate/download.html) + which is a program (which uses libsamplerate) from the **examples/** directory + of the Secret Rabbit Code source code distribution. +- [Resample](https://ccrma.stanford.edu/~jos/resample/) by Julius O Smiths which + seems to have been the first high quality converter available as source code. +- [ResampAudio](http://www.tsp.ece.mcgill.ca/MMSP/Documents/Software/AFsp/ResampAudio.html) + which is part of [Audio File Programs and Routines](http://www.tsp.ece.mcgill.ca/MMSP/Documents/Software/AFsp/AFsp.html) + by Peter Kabal. +- [SoX](http://home.sprynet.com/~cbagwell/sox.html) which is maintained by Chris + Bagwell. SoX is also able to perform some low quality sample rate conversions + but these will not be investigated. +- [Shibatch](http://shibatch.sourceforge.net/) which seems to be a frequency + domain sample rate converter. Unfortunately, this converter does not handle + arbitrary conversion ratios and hence could not be properly compared to the + other converters. +- [sr-convert](http://sr-convert.sourceforge.net/) is another converter which + does not handle arbitrary conversion ratios. + +It should be noted that the first three converters above are based on the +algorithm by [Julius O. Smith](http://www-ccrma.stanford.edu/~jos/resample/) +which emulates the conversion of the digital signal to an analogue one and then +samples the analogue signal at the new sample rate. + +## Methodology + +Measuring the SNR of a converter is relatively straightforward. Generate an +input signal consisting of a windowed sine wave, sample rate convert it and +measure the signal-to-noise ratio of the output signal. A typical length for the +original file is 30000 samples. + +The bandwidth of a sample rate converter is a little more difficult to measure. +Currently this is done by generating two short files containing a windowed sine +wave. The frequencies of the sine waves are 0.35 and 0.495 of the sample rate. +These files are then upsampled by a factor of 2 using the converter under test. +If the attenuation of the lower frequency is less than 3dB and higher frequency +is more than 3dB, it is then possible to iteratively increase the lower +frequency and decrease the upper frequency keeping the -3dB point bracketed. +When the distance between the upper and lower frequency is sufficiently small, +it is possible to obtain a very accurate estimate of the -3dB frequency. + +The speed of a sample rate converter is easy to measure; simply perform a +conversion on a large file or a number of smaller files and time the conversion +process. + +The above measurement techniques are built into a test program which is +delivered with the Secret Rabbit Code source code distribution. This program is +able to test the first four of the above converters. + +## SoX + +SoX provides three methods of resampling; a linear interpolator, a polyphase +resampler and the Julius O. Smith simulated analogue filter method. + +## Shibatch + +Shibach + +**More Coming Soon.** diff --git a/lib/libsamplerate/libsamplerate-0.2.2/docs/win32.md b/lib/libsamplerate/libsamplerate-0.2.2/docs/win32.md new file mode 100755 index 00000000..6f93347d --- /dev/null +++ b/lib/libsamplerate/libsamplerate-0.2.2/docs/win32.md @@ -0,0 +1,15 @@ +--- +layout: default +--- + +# Compiling on Win32 + +You can use [CMake](https://cmake.org/) to generate Visual Studio project. The +configuration process is described [here](https://cmake.org/runningcmake/). + +The libsamplerate library itself does not require any dependencies, but if you +want to build examples and tests, you will need the [libsndfile](https://github.com/libsndfile/libsndfile) +and [FFTW](http://www.fftw.org/) libraries. The easiest way to install them is +to use a package manager, such as [Vcpkg](https://github.com/microsoft/vcpkg). Their README.md contains detailed +installation instructions for supported platforms. Libsamplerate requires the +`libsndfile` and `fftw3` packages. |
