An Audio Synthesis Textbook For Musicians, Digital Artists and Programmers by Mike Krzyzaniak
<-- Up to: 1 Window Functions-->

  1. //WindowFunctions.c
  2. //gcc MKAiff.c WindowFunctions.c -o WindowFunctions
  4. #include "MKAiff.h"
  5. #include <math.h>
  7. #define SAMPLE_RATE 44100
  8. #define NUM_CHANNELS 1
  9. #define BITS_PER_SAMPLE 16
  10. #define GRAIN_DURATION 1
  11. const int framesPerGrain = GRAIN_DURATION * SAMPLE_RATE;
  12. const int samplesPerGrain = GRAIN_DURATION * SAMPLE_RATE * NUM_CHANNELS;
  13. #define PI 3.141592653589793
  14. #define e 2.718281828459045
  15. const double TWO_PI_OVER_SAMPLE_RATE = 2 * PI / SAMPLE_RATE;
  17. int main()
  18. {
  19. MKAiff* aiff = aiffWithDurationInSeconds(NUM_CHANNELS, SAMPLE_RATE, BITS_PER_SAMPLE, GRAIN_DURATION);
  20. if(aiff == NULL) return 1;
  22. float windowFunction[framesPerGrain];
  23. int i;
  24. for(i=0; i<framesPerGrain; i++)
  25. {
  26. //SINE
  27. //windowFunction[i] = sin( PI * (double)i / samplesPerGrain );
  29. //HANN
  30. //windowFunction[i] = 0.5 * (1-cos(2*PI*i/samplesPerGrain));
  32. //HAMMING
  33. //windowFunction[i] = 0.54 - 0.46 * cos(2*PI*i/samplesPerGrain);
  35. //TUKEY
  36. //float truncationHeight = 0.5;
  37. //float f = 1/(2*truncationHeight) * (1-cos(2*PI*i/samplesPerGrain));
  38. //windowFunction[i] = f < 1 ? f : 1;
  40. //GAUSSIAN
  41. float sigma = 0.3;
  42. windowFunction[i] = pow(e, -0.5* pow(((i-samplesPerGrain/2) / (sigma*samplesPerGrain/2)), 2) );
  44. //TRAPEZOIDAL
  45. //float slope = 10;
  46. //float x = (float) i / framesPerGrain;
  47. //float f1 = slope * x;
  48. //float f2 = -1 * slope * (x-(slope-1) / slope) + 1;
  49. //windowFunction[i] = x < 0.5 ? (f1 < 1 ? f1 : 1) : (f2 < 1 ? f2 : 1);
  50. }
  52. float audioBuffer[samplesPerGrain];
  53. double frequency = 440, angle = 0;
  55. for(i=0; i<samplesPerGrain; i+=NUM_CHANNELS)
  56. {
  57. audioBuffer[i] = sin(angle) * windowFunction[i/NUM_CHANNELS];
  58. angle += frequency * TWO_PI_OVER_SAMPLE_RATE;
  59. }
  61. aiffAppendFloatingPointSamples(aiff, audioBuffer, samplesPerGrain, aiffFloatSampleType);
  62. aiffSaveWithFilename(aiff, "WindowFunctions.aif");
  64. aiffDestroy(aiff);
  66. return 0;
  67. }

Output:

Downloads

Download Code Download Audio Download MKAiff

Builds On

AIFF Template Sine Wave Envelopes

Explanation of the Concepts

This example shows how to create several various window functions for creating 'grains' for use in granular synthesis. Here, for the sake of demonstration, the window function is applied to a simple audio-rate sine-wave, and the result is one very simple (and somewhat long) grain of audio.

The following graphs represent amplitude plotted as a function of time for various window functions.

SINE

The sine window function is just the top half of a sine wave, between 0 and 180 degrees:

Sine

HANN

A Hann window is an entire cosine wave, between 0 and 360 degrees, but it is raised up so that it does not dip below y=0. For this reason, it is also known as a "raised cosine" window.

Hann

HAMMING

An Hamming window is also a type of "raised cosine" window, but it has been raised a little further, so the bottom does not touch y=0. This type of window is often used in DFT algorithms (discussed in the chapter on Fourier Synthesis) because it produces a very accurate spectrum. It, however, is not great for granular synthesis because, since it does not reach y=0, it can cause popping noises as it is begins and ends.

Hamming

TUKEY

A Tukey window is a Hann window that has had its top chopped off, and the result has been stretched to fit between y=0 and y=1. The height at which it has been chopped of is known as H. Tukey windows are good for making grains out of speech. If the window is chopped off low, then it reaches its maximum amplitude quickly and stays there for a large percentage of the windows duration, which preserves the intelligibility of individual words. Higher values of H decrease the intelligibility.

Tukey from Hann Tukey 0.1 Tukey 0.5 Tukey 0.9 Tukey 1.0

GAUSSIAN

A Gaussian function is the plot of the familiar "bell curve", that often represents natural probability distributions. Its shape makes it good for use here. The coefficient 'Sigma' determines the width of the function. Because the function never reaches y=0, it can cause popping as the grain begins and ends, especially for values of sigma much above 0.3. Nonetheless, in a dense, granular music, manipulating sigma gives an interesting control over the overall texture of the music. Low values of sigma produce choppy textures and higher values produce a smoother texture. For high values of sigma, popping can be avoided by multiplying the Gaussian function by a trapezoidal function (or another function that reaches 0).

Gaussian 0.1 Gaussian 0.5 Gaussian 1.0

TRAPEZOIDAL

Trapezoidal windows are useful for convolving other window functions that do not reach y=0. Notice too, that a triangular window is just the special case of a trapezoidal window in which Slope=2;

Trapezoid 2.0 Trapezoid 3.0 Trapezoid 201.0

Explanation of the Code

In this example, the window function is written into a separate buffer for before being applied to the audio buffer. The window buffer is allocated on line 22. Lines 22-40 then write a window function into the buffer, according to which lines of code are not commented out. Lines 52-59 then applies the window function to the a sine wave that is written into an audio buffer, Identical to the usage in many of the examples in the chapter on envelopes.

<-- Up to: 1 Window Functions-->