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

  1. //LinearInterpolation.c
  2. //gcc MKAiff.c LinearInterpolation.c -o LinearInterpolation
  5. #include "MKAiff.h"
  6. #include <math.h>
  8. #define TRANSPOSITION -21
  9. #define NUM_CHANNELS aiffNumChannels(prerecordedAudio)
  10. #define SAMPLE_RATE aiffSampleRate(prerecordedAudio)
  11. #define BITS_PER_SAMPLE aiffBitsPerSample(prerecordedAudio)
  12. #define PRERECORDED_AUDIO_PATH "demo.aif"
  13. #define BUFFER_NUM_FRAMES 4096
  14. #define BUFFER_NUM_SAMPLES (BUFFER_NUM_FRAMES * NUM_CHANNELS)
  16. void linearInterpolateBuffer(float* previousFrame, int numChannels, float* input, int inNumFrames, float* output, int outFrames);
  17. void cubicInterpolateBuffer(float* previous3Frames, int numChannels, float* input, int inNumFrames, float* output, int outNumFrames);
  19. int main()
  20. {
  21. MKAiff* prerecordedAudio = aiffWithContentsOfFile(PRERECORDED_AUDIO_PATH);
  22. if(prerecordedAudio == NULL) return 1;
  23. const float PLAYBACK_SPEED = pow(pow(2, -TRANSPOSITION), (1/12.0));
  24. const float NUM_SECONDS = (PLAYBACK_SPEED * aiffDurationInSeconds(prerecordedAudio));
  25. int i;
  27. MKAiff* aiff = aiffWithDurationInSeconds(NUM_CHANNELS, SAMPLE_RATE, BITS_PER_SAMPLE, NUM_SECONDS + 1);
  28. if(aiff == NULL) return 1;
  30. float audioBuffer[BUFFER_NUM_SAMPLES];
  31. float interpolatedAudioBuffer[(int)(BUFFER_NUM_SAMPLES * PLAYBACK_SPEED)];
  32. int numSamplesRead, numSamplesToWrite;
  34. //Linear Interpolation needs 1 previous frame
  35. float previousFrame[NUM_CHANNELS * 3];
  36. for(i=0; i<NUM_CHANNELS * 3; previousFrame[i++] = 0);
  38. /* //Cubic Interpolation needs 3 previous frames
  39. float previousFrame[NUM_CHANNELS * 3];
  40. for(i=0; i<NUM_CHANNELS * 3; previousFrame[i++] = 0);
  41. */
  42. do{
  43. numSamplesRead = aiffReadFloatingPointSamplesAtPlayhead(prerecordedAudio, audioBuffer, BUFFER_NUM_SAMPLES);
  44. numSamplesToWrite = numSamplesRead * PLAYBACK_SPEED;
  45. numSamplesToWrite -= (numSamplesToWrite % NUM_CHANNELS);
  46. linearInterpolateBuffer(previousFrame, NUM_CHANNELS, audioBuffer, numSamplesRead / NUM_CHANNELS, interpolatedAudioBuffer, numSamplesToWrite / NUM_CHANNELS);
  47. //cubicInterpolateBuffer (previousFrame, NUM_CHANNELS, audioBuffer, numSamplesRead / NUM_CHANNELS, interpolatedAudioBuffer, numSamplesToWrite / NUM_CHANNELS);
  48. aiffAppendFloatingPointSamples(aiff, interpolatedAudioBuffer, numSamplesToWrite, aiffFloatSampleType);
  49. }while(numSamplesRead == BUFFER_NUM_SAMPLES);
  51. aiffSaveWithFilename(aiff, "LinearInterpolation.aif");
  52. aiffDestroy(aiff);
  54. return 0;
  55. }
  58. void linearInterpolateBuffer(float* previousFrame, int numChannels, float* input, int inNumFrames, float* output, int outNumFrames)
  59. {
  60. int i, j, index;
  61. double distance, prevValue, nextValue;
  63. for(i=0; i<outNumFrames; i++)
  64. {
  65. for(j=0; j<numChannels; j++)
  66. {
  67. distance = i * (inNumFrames / (double)outNumFrames);
  68. index = ((int)distance) * numChannels + j;
  69. nextValue = input[index];
  70. prevValue = distance < 1 ? previousFrame[j] : input[index-numChannels];
  71. distance -= (int)distance;
  72. output[i*numChannels+j] = (nextValue-prevValue) * distance + prevValue;
  73. }
  74. }
  75. for(j=0; j<numChannels; j++)
  76. previousFrame[j] = input[(inNumFrames - 1) * numChannels + j];
  77. }
  80. void cubicInterpolateBuffer(float* previous3Frames, int numChannels, float* input, int inNumFrames, float* output, int outNumFrames)
  81. {
  82. int i, j, index;
  83. double distance, prev, prevPrev, next, nextNext;
  84. double a, b, c, d;
  86. for(i=0; i<outNumFrames; i++)
  87. {
  88. for(j=0; j<numChannels; j++)
  89. {
  90. distance = i * (inNumFrames / (double)outNumFrames);
  91. index = ((int)distance) * numChannels + j;
  92. nextNext = input[index ];
  93. next = distance < 1 ? previous3Frames[index + 2*numChannels] : input[index - numChannels];
  94. prev = distance < 2 ? previous3Frames[index + numChannels ] : input[index - 2*numChannels];
  95. prevPrev = distance < 3 ? previous3Frames[index ] : input[index - 3*numChannels];
  96. distance -= (int)distance;
  97. a = nextNext - next - prevPrev + prev;
  98. b = prevPrev - prev - a;
  99. c = next - prevPrev;
  100. d = prev;
  101. output[i*numChannels+j] = ((a * distance * distance * distance) + (b * distance*distance) + (c * distance) + (d));
  102. }
  103. }
  104. for(j=0; j<numChannels*3; j++)
  105. previous3Frames[j] = input[(inNumFrames - 3) * numChannels + j];
  106. }

Output:

Downloads

Download Code Download Audio Download MKAiff

Builds On

AIFF Template Linear Interpolation Cubic Interpolation

Explanation of the Concepts

This example shows how to use the interpolation algorithms in the previous sections of this chapter. It example reads in the audio file "demo.aif", and transposes it down 21 half-steps by interpolating it.

Download Demo.aif

The most memory-efficient way to interpolate a longer file is to read a smaller number (say a few thousand) of samples out of the original file, interpolate them, add them to a new file, and then get the next few thousand samples, and so forth, until the end of the file. The algorithms in the previous example were designed to facilitate this technique, so this example demonstrates the proper use of those functions.

From a musical perspective, we are not usually concerned with the duration of a sound after it is interpolated, so much as we are concerned with the pitch of that sound. Since interpolation deals in durations (number of samples), we will need to convert. The duration os a sound is inversely proportional to its pitch (i.e. raising the pitch reduces the duration), so when we transpose, if we know the ratio of the original pitch to the target pitch, then we also know the ratio of their durations. In the tempered chromatic scale, the ratio is one note to the next is equal to twelfth root of two. An interval of say, 5 half-steps is created by raising 2 to the 5th (the number of half steps), and taking the twelfth root of that. Furthermore, (more high-school math) we remember that taking the 12th root of two is the same as raising two to the power of 1/12. So, if we want to transpose a sound by a certain number of half steps, we can find the ratio of their frequencies like so:

frequencyRatio = (2^numHalfsteps)^(1/12)

The ratio ratio of the duration of the original audio file to the interpolated audio file would just be one over this number. The mathematical shortcut for this, however, is just to raise 2 to the negative number of half-steps, so that the duration ratio can be found like so:

durationRatio = (2^-numHalfsteps)^(1/12)

Then, of course, multiplying the number of samples in the original audio buffer by the duration-ratio gives the number of samples that will be required in the interpolated buffer to transpose the sound by the given amount.

<-- Up to: 1 Linear Interpolation-->