medusa/the_information_nexus
1
0
Fork 0
Code Issues Pull Requests Actions Packages Projects Releases Wiki Activity

site updates

Browse Source
This commit is contained in:
Whisker Jones
2024-05-05 10:38:02 -06:00
parent 0d2386870d
commit 7d794ad2f9
19 changed files with 7376 additions and 0 deletions
Download Patch File Download Diff File Expand all files Collapse all files

93
tech_docs/music/SoX_guide.md Normal file
View File

@@ -0,0 +1,93 @@
Creating a complete user guide for SoX involves covering a range of basic use cases to help you get started with this versatile audio processing tool. SoX is highly effective for tasks like format conversion, audio effects application, and general sound manipulation, making it a go-to utility for both beginners and advanced users comfortable with the command line.
### Installation
First, ensure SoX is installed on your system. It's available in most Linux distributions' package repositories.
For Debian-based systems (like Ubuntu), use:
```bash
sudo apt-get install sox
```
For Red Hat-based systems, use:
```bash
sudo yum install sox
```
### Basic Operations
#### 1. Converting Audio Formats
SoX can convert audio files between various formats. For example, to convert an MP3 file to a WAV file:
```bash
sox input.mp3 output.wav
```
#### 2. Playing Audio Files
SoX can play audio files directly from the command line:
```bash
play filename.mp3
```
#### 3. Recording Audio
To record audio with SoX, use the `rec` command. This example records a 5-second audio clip from the default recording device:
```bash
rec -d 5 myrecording.wav
```
### Applying Effects
#### 1. Changing Volume
To increase or decrease the volume of an audio file, use the `vol` effect:
```bash
sox input.mp3 output.mp3 vol 2dB
```
#### 2. Applying Reverb
Add reverb to an audio file with:
```bash
sox input.wav output.wav reverb
```
#### 3. Trimming Audio
Trim an audio file to only include a specific portion (e.g., start at 10 seconds and end at 20 seconds):
```bash
sox input.mp3 output.mp3 trim 10 10
```
#### 4. Combining Audio Files
Concatenate two or more audio files into one:
```bash
sox input1.mp3 input2.mp3 output.mp3
```
### Advanced Features
#### 1. Applying Multiple Effects
You can chain multiple effects in a single command:
```bash
sox input.mp3 output.mp3 reverb vol 2dB trim 0 30
```
#### 2. Noise Reduction
To reduce noise, first capture a noise profile:
```bash
sox noise-audio.wav -n noiseprof noise.prof
```
Then apply the noise reduction:
```bash
sox input.wav output.wav noisered noise.prof 0.3
```
#### 3. Spectrogram
Generate a spectrogram of an audio file:
```bash
sox input.mp3 -n spectrogram -o output.png
```
### Tips and Tricks
- **Chain Effects**: SoX allows for complex processing chains that combine multiple effects, optimizing the processing flow.
- **Scripting**: Integrate SoX commands into shell scripts for batch processing or automated audio manipulation tasks.
- **Documentation**: For more detailed information on all SoX capabilities and effects, consult the SoX man page or the official SoX documentation by running `man sox` or visiting [SoX - Sound eXchange](http://sox.sourceforge.net/).
SoX is an exceptionally powerful tool for audio processing, offering a wide range of functionality from basic to advanced audio manipulation and analysis. Experimenting with its various options and effects can help you achieve precisely the audio outcomes you need.

228
tech_docs/music/SuperCollider.md Normal file
View File

@@ -0,0 +1,228 @@
Great choice! SuperCollider is a powerful tool for music production and sound synthesis. Here's a framework you can follow to get started with creating projects in SuperCollider, focusing on beat making, melodies, and other music production functions:
1. Learn the basics of SuperCollider:
- Familiarize yourself with the SuperCollider environment and its key components: the language (SCLang) and the server (scsynth).
- Understand the basic syntax and structure of SCLang, which is similar to Python in some ways.
- Explore the built-in UGens (Unit Generators) and their functionalities for audio synthesis and processing.
2. Set up your SuperCollider environment:
- Install SuperCollider on your computer and ensure it runs properly.
- Choose an IDE or text editor for writing SuperCollider code (e.g., the built-in IDE, Atom, or Vim).
- Test your audio output and configure any necessary audio settings.
3. Learn the fundamentals of sound synthesis:
- Study the different synthesis techniques available in SuperCollider, such as subtractive, additive, FM, and granular synthesis.
- Experiment with creating basic waveforms, envelopes, and filters to shape your sounds.
- Understand the concepts of oscillators, amplitudes, frequencies, and modulation.
4. Dive into rhythm and beat making:
- Learn how to create rhythmic patterns using SuperCollider's timing and sequencing capabilities.
- Explore the Pbind and Pmono classes for creating patterns and sequences.
- Experiment with different drum synthesis techniques, such as using noise generators, envelopes, and filters to create kick drums, snares, hi-hats, and other percussive sounds.
5. Explore melody and harmony:
- Learn how to create melodic patterns and sequences using SuperCollider's pitch and scale functions.
- Experiment with different waveforms, envelopes, and effects to create various instrument sounds, such as synths, pads, and leads.
- Understand the concepts of scales, chords, and musical intervals to create harmonically pleasing melodies.
6. Incorporate effects and processing:
- Explore the wide range of audio effects available in SuperCollider, such as reverb, delay, distortion, and compression.
- Learn how to apply effects to individual sounds or entire mixtures using the SynthDef and Synth classes.
- Experiment with creating custom effects chains and modulating effect parameters in real-time.
7. Structure and arrange your music:
- Learn how to organize your musical elements into a structured composition using SuperCollider's Patterns and Routines.
- Explore techniques for arranging and transitioning between different sections of your track, such as verse, chorus, and bridge.
- Utilize automation and parameter modulation to add variation and movement to your arrangements.
8. Experiment, iterate, and refine:
- Practice creating different genres and styles of EDM using SuperCollider.
- Iterate on your patches and compositions, fine-tuning sounds, rhythms, and arrangements.
- Seek feedback from the SuperCollider community, share your creations, and learn from others' techniques and approaches.
Remember to refer to the SuperCollider documentation, tutorials, and community resources as you progress through your projects. The SuperCollider website (https://supercollider.github.io/) provides extensive documentation, guides, and examples to help you along the way.
Start with simple projects and gradually increase complexity as you become more comfortable with SuperCollider's concepts and workflow. Don't hesitate to experiment, explore, and have fun while creating your music!
---
Certainly! Let's dive into mastering sound synthesis basics, rhythm and beat production, and crafting melodies and harmonies in SuperCollider.
**Mastering Sound Synthesis Basics:**
1. Synthesis Techniques:
- Subtractive Synthesis: This technique starts with a harmonically rich waveform (e.g., sawtooth or square wave) and then filters out certain frequencies to shape the sound. It's often used for creating warm pads, lush strings, and smooth basslines.
Example: `{RLPF.ar(Saw.ar(440), LFNoise1.kr(1).range(200, 5000), 0.1)}.play`
- FM Synthesis: Frequency Modulation synthesis involves modulating the frequency of one oscillator (carrier) with another oscillator (modulator). FM synthesis is known for creating complex, dynamic, and evolving timbres, such as metallic sounds, bells, and percussive hits.
Example: `{SinOsc.ar(440 + SinOsc.ar(1, 0, 100, 100), 0, 0.5)}.play`
- Additive Synthesis: This technique combines multiple sine waves at different frequencies and amplitudes to create complex timbres. It's useful for creating rich, harmonically dense sounds like organs, brass, and unique textures.
Example: `{Mix.fill(5, {|i| SinOsc.ar(440 * (i + 1), 0, 1 / (i + 1))})}.play`
2. Practical Exercise:
- Create a simple sine wave:
`{SinOsc.ar(440, 0, 0.5)}.play`
- Create a noise burst:
`{WhiteNoise.ar(0.5) * EnvGen.kr(Env.perc(0.01, 0.1), doneAction: 2)}.play`
**Rhythm and Beat Production:**
1. Building a Basic Drum Pattern:
- Here's an example of creating a simple drum pattern using `Pbind` and `SynthDef`:
```supercollider
SynthDef(\kick, {|amp = 0.5, freq = 60|
var sig = SinOsc.ar(freq, 0, amp) * EnvGen.kr(Env.perc(0.01, 0.5), doneAction: 2);
Out.ar(0, sig ! 2);
}).add;
SynthDef(\snare, {|amp = 0.5|
var sig = WhiteNoise.ar(amp) * EnvGen.kr(Env.perc(0.01, 0.2), doneAction: 2);
Out.ar(0, sig ! 2);
}).add;
Pbind(
\instrument, \kick,
\dur, Pseq([1, 1, 1, 1], inf),
\amp, 0.6
).play;
Pbind(
\instrument, \snare,
\dur, Pseq([Rest(1), 1, Rest(1), 1], inf),
\amp, 0.4
).play;
```
2. Rhythmic Complexity and Timing:
- Use `Pbind` with `Pseq` and `Prand` to create dynamic and evolving rhythms:
```supercollider
Pbind(
\instrument, \kick,
\dur, Pseq([1, 0.5, 0.5, Prand([1, 0.5], 1)], inf),
\amp, 0.6
).play;
```
**Crafting Melodies and Harmonies:**
1. Constructing Melodies:
- Use scale and pitch classes to create melodic patterns:
```supercollider
var scale = Scale.major.degrees;
var melody = Pbind(
\instrument, \synth,
\freq, Pseq(scale.collect({|degree| degree + 60}), inf),
\dur, 0.25,
\amp, 0.4
).play;
```
2. Harmony and Chords:
- Generate chords and progressions using chord degrees and intervals:
```supercollider
var chords = [
[0, 2, 4], // I chord
[2, 4, 6], // II chord
[4, 6, 8] // III chord
];
var progression = Pbind(
\instrument, \synth,
\freq, Pseq(chords.collect({|chord| chord.collect({|degree| degree + 60})}), inf),
\dur, 2,
\amp, 0.4
).play;
```
Remember to experiment, explore, and build upon these examples to create your own unique sounds and compositions in SuperCollider. Happy music-making!
---
Certainly! Here's a guide to producing down tempo music in minor keys using SuperCollider, incorporating the previously discussed mathematical concepts and ratios:
I. Harmony and Chord Progressions
A. Use the `Scale` class to generate minor scales and chords
1. `Scale.minor` for natural minor
2. `Scale.harmonicMinor` for harmonic minor
3. `Scale.melodicMinor` for melodic minor
B. Utilize `Pseq` and `Prand` to create chord progressions
C. Experiment with `Pswitch` and `Pif` to incorporate chromatic mediants
II. Rhythm and Tempo
A. Use `TempoClock` to set the tempo between 60-90 BPM
B. Utilize `Pbind` to create rhythmic patterns and polyrhythms
1. `\dur` for note durations (e.g., `Pseq([1/3, 1/6], inf)` for triplets against eighth notes)
2. `\stretch` for rhythmic variations (e.g., `Pseq([2/3, 1/3], inf)` for dotted eighth notes against quarter notes)
C. Apply swing using `Pswing` or by manipulating durations
III. Sound Design and Frequencies
A. Use `SinOsc`, `Saw`, `Pulse`, and other UGens for basic waveforms
B. Apply `RLPF`, `RHPF`, and `BPF` filters to focus on specific frequency ranges
C. Create layered textures using `Splay`, `Mix`, and `Splay`
D. Utilize the golden ratio for amplitude envelopes and modulation depths
IV. Arrangement and Structure
A. Use the Fibonacci sequence for section lengths and transitions with `Pn`, `Pfin`, and `Pdef`
B. Create tension and release by alternating between sections using `Pseq` and `Ppar`
C. Use the rule of thirds for placing key elements and transitions with `Quant`
V. Mixing and Mastering
A. Apply `AmpComp` and `FreqShift` to balance frequencies based on equal loudness contours
B. Use `Pan2` and `PanAz` for panning, following the "rule of sixths"
C. Adjust dynamics using `Compander`, `Limiter`, and `Normalizer`
D. Utilize `Meter` and `Loudness` UGens to monitor and control the dynamic range
VI. Example Code
```supercollider
(
// Minor scale and chord progression
~scale = Scale.minor;
~chords = ~scale.degrees.collect(_.chord);
~progression = Pseq([0, 3, 4, 0], inf);
// Rhythm and tempo
~tempo = 72;
~rhythmPattern = Pseq([2/3, 1/3], inf);
// Sound design and frequencies
~synthDef = SynthDef(\pad, {
|freq = 440, amp = 0.5, cutoff = 500, rq = 0.5|
var osc1 = Saw.ar(freq);
var osc2 = Pulse.ar(freq * (1 + MouseX.kr(-0.1, 0.1)));
var env = EnvGen.kr(Env.perc(0.01, 1.618), doneAction: 2);
var filter = RLPF.ar(osc1 + osc2, cutoff * env, rq);
Out.ar(0, Pan2.ar(filter * env * amp));
}).add;
// Arrangement and structure
~sections = [
Pn(Ppar([
Pbind(\instrument, \pad, \freq, Pseq((~chords[0] + 60).midicps, 1), \dur, 4),
Pbind(\instrument, \pad, \freq, Pseq((~chords[3] + 48).midicps, 1), \dur, 4),
]), 8),
Pn(Ppar([
Pbind(\instrument, \pad, \freq, Pseq((~chords[4] + 60).midicps, 1), \dur, 4),
Pbind(\instrument, \pad, \freq, Pseq((~chords[0] + 48).midicps, 1), \dur, 4),
]), 13),
];
// Mixing and mastering
~master = {
var sig = In.ar(0, 2);
sig = CompanderD.ar(sig, 0.5, 1, 0.3, 0.01, 0.1);
sig = Limiter.ar(sig, 0.9, 0.01);
sig = Splay.ar(sig);
sig = Loudness.ar(sig);
Out.ar(0, sig * 0.8);
}.play;
// Play the sections
~sections[0].play(TempoClock(~tempo / 60));
~sections[1].play(TempoClock(~tempo / 60), quant: [8]);
)
```
Remember to experiment with different UGens, patterns, and parameters to achieve your desired sound. SuperCollider provides a powerful and flexible environment for creating generative and algorithmic music, so don't hesitate to explore and customize the code to suit your needs.