bloopsaphone 0.4

data/COPYING

@@ -0,0 +1,27 @@
+  
+  :$: BLOOPSAPHONE :$:
+  Copyright (c) 2009 why the lucky stiff
+  Based on sfxr (c) 2007 Tomas Pettersson
+    (Also released under the MIT license)
+  
+  Permission is hereby granted, free of charge, to any person
+  obtaining a copy of this software and associated documentation
+  files (the "Software"), to deal in the Software without restriction,
+  including without limitation the rights to use, copy, modify, merge,
+  publish, distribute, sublicense, and/or sell copies of the Software,
+  and to permit persons to whom the Software is furnished to do so,
+  subject to the following conditions:
+    
+  The above copyright notice and this permission notice shall be 
+  included in all copies or substantial portions of the Software.
+     
+  THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF
+  ANY KIND, EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED
+  TO THE WARRANTIES OF MERCHANTABILITY, FITNESS FOR A
+  PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT
+  SHALL THE AUTHORS BE LIABLE FOR ANY CLAIM, DAMAGES OR
+  OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT
+  OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION
+  WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+  SOFTWARE.
+

data/README

@@ -0,0 +1,164 @@
+
+      |~~              |~~
+      |                |
+     :$: bloopsaphone :$:
+      `''''''''''''''''`
+
+  for writing chiptune-style songs
+  in c or ruby. you know: the sounds
+  of ataris, gameboys and the like.
+
+               ~
+
+  -$- ABOUT
+
+  this is a small c library for sending
+  chiptunes through portaudio, which is
+  a rather light cross-platform audio lib.
+  <http://www.portaudio.com/>
+
+  right now i'm only including ruby
+  bindings. you are welcome to contribute
+  code to hook up to other languages,
+  though.
+
+  i wrote this for h-ety h.
+  <http://hacketyhack.net/>
+
+  i don't have binaries ready for this yet,
+  so if you're on windows or os x, you may
+  have to wait until HH comes out at ART
+  AND CODE. the tribulations you face.
+
+               ~
+
+  -$- THE BLOOPSAPHONE THEME SONG
+      (in ruby)
+
+      require 'bloops'
+
+    # the bloops o' phone
+      b = Bloops.new
+      b.tempo = 320
+
+    # melodious
+      s1 = b.sound Bloops::SQUARE
+      s1.punch = 0.5
+      s1.sustain = 0.4
+      s1.decay = 0.2
+      s1.arp = 0.4
+      s1.aspeed = 0.6
+      s1.repeat = 0.6
+      s1.phase = 0.2
+      s1.psweep = 0.2
+
+    # beats
+      s2 = b.sound Bloops::NOISE
+      s2.punch = 0.5
+      s2.sustain = 0.2
+      s2.decay = 0.4
+      s2.slide = -0.4
+      s2.phase = 0.2
+      s2.psweep = 0.2
+
+    # the tracks
+      b.tune s1, "f#5 c6 e4 b6 g5 d6 4  f#5 e5 c5 b6 c6 d6 4 "
+      b.tune s2, "4   c6 4  b5 4  4  e4 4   c6 4  b5 4  4  e4"
+
+    # and away we go
+      b.play
+      sleep 1 while !b.stopped?
+
+               ~
+
+  -$- BUILDING FOR RUBY
+
+  If Ruby is in your path and PortAudio 1.9
+  or greater is installed:
+
+    make ruby
+
+  To install PortAudio 1.9 under Ubuntu:
+
+    aptitude install portaudio19-dev
+
+  Under MacPorts, you may need to add
+  /opt/local to your make settings:
+
+    make CFLAGS="-I/opt/local/include" \
+         LDFLAGS="-L/opt/local/lib" \
+         ruby
+
+               ~
+
+  -$- THE IDEALS,
+
+  -1- ASYNCHRONOUS.
+      You send it a song and it plays in
+      the background. You'll get an event
+      when it finishes.
+
+  -2- SMALL.
+      This is just a toy, I don't want it
+      to be very big and comprehensive.
+      Just to play little tunes with a
+      nostalgic arcade sound rather than
+      the CASIO-stylings of most MIDI.
+
+  -3- CUSTOM NOTATION.
+      Someone told me about Nokring, iMelody,
+      numbered musical notation and I did
+      some reading. They're little languages
+      for texting yourself a ringtone.
+
+  <http://en.wikipedia.org/wiki/Ring_Tone_Transfer_Language>
+  <http://homepage.mac.com/alvinmok/ericsson/emelody.html>
+
+      Bloopsaphone uses a variation on RTTTL.
+
+      Instead of commas, I use whitespace.
+      A rest is simply a number. A plus sign
+      moves everything up an octave. A minus
+      down an octave.
+
+      The Simpsons' Theme, for instance, would be:
+
+        32 + C E F# 8:A G E C - 8:A 8:F# 8:F# 8:F# 2:G
+
+      Which translates into:
+
+       * a 1/32nd note rest.
+       * change one octave up.
+       * C quarter note.
+       * E quarter note.
+       * F# quarter note.
+       * A eighth note.
+       * G quarter.
+       * E quarter.
+       * C one-quarter note.
+       * change one octave down.
+       * A eighth.
+       * Three F# eighths.
+       * G half note.
+
+      The colons are optional. They are there because you
+      can place an octave number after each note. Somehow
+      "8B6" (an eighth note of B at the sixth octave) looks
+      more confusing than "8:B6". I guess I figured that
+      the timing "8" is conceptually separate from the
+      actual tone "B6", even though they both comprise
+      the note itself.
+
+  -4- SERIALIZE SOUNDS.
+      To accomodate passing instruments between
+      ruby and c, bloopsaphone comes with a tiny
+      file format for describing sounds.
+
+      You can find examples of these in the sounds/
+      folder in this distro. Possible sound types
+      are 'square', 'sawtooth', 'sine' and 'noise'.
+      All other settings go from 0.0 to 1.0.
+
+      The 'freq' setting is only used if the sound
+      is played without a tune.
+

data/c/bloopsaphone.c

@@ -0,0 +1,443 @@
+//
+// bloopsaphone.c
+// the chiptune maker for portaudio
+// (with bindings for ruby)
+// 
+// (c) 2009 why the lucky stiff
+// See COPYING for the license
+//
+#include <stdio.h>
+#include <stdlib.h>
+#include <string.h>
+#include <time.h>
+#include <math.h>
+#include <portaudio.h>
+#include <unistd.h>
+#include "bloopsaphone.h"
+
+#define SAMPLE_RATE 44100
+#define rnd(n) (rand() % (n + 1))
+#define tempo2frames(tempo) ((float)SAMPLE_RATE / (tempo / 60.0f))
+#define PI 3.14159265f
+
+float
+frnd(float range)
+{
+  return (float)rnd(10000) / 10000 * range;
+}
+
+void
+bloops_ready(bloops *B, bloopsatrack *A, unsigned char init)
+{
+  A->period = 100.0 / (A->P->freq * A->P->freq + 0.001);
+  A->maxperiod = 100.0 / (A->P->limit * A->P->limit + 0.001);
+  A->slide = 1.0 - pow((double)A->P->slide, 3.0) * 0.01;
+  A->dslide = -pow((double)A->P->dslide, 3.0) * 0.000001;
+  A->square = 0.5f - A->P->square * 0.5f;
+  A->sweep = -A->P->sweep * 0.00005f;
+  if (A->P->arp >= 0.0f)
+    A->arp = 1.0 - pow((double)A->P->arp, 2.0) * 0.9;
+  else
+    A->arp = 1.0 + pow((double)A->P->arp, 2.0) * 10.0;
+  A->atime = 0;
+  A->alimit = (int)(pow(1.0f - A->P->aspeed, 2.0f) * 20000 + 32);
+  if (A->P->aspeed == 1.0f)
+    A->alimit = 0;
+
+  if (init)
+  {
+    int i = 0;
+    A->phase = 0;
+    A->filter[0] = 0.0f;
+    A->filter[1] = 0.0f;
+    A->filter[2] = pow(A->P->lpf, 3.0f) * 0.1f;
+    A->filter[3] = 1.0f + A->P->lsweep * 0.0001f;
+    A->filter[4] = 5.0f / (1.0f + pow(A->P->resonance, 2.0f) * 20.0f) * (0.01f + A->filter[2]);
+    if (A->filter[4] > 0.8f) A->filter[4] = 0.8f;
+    A->filter[5] = 0.0f;
+    A->filter[6] = pow(A->P->hpf, 2.0f) * 0.1f;
+    A->filter[7] = 1.0 + A->P->hsweep * 0.0003f;
+
+    A->vibe = 0.0f;
+    A->vspeed = pow(A->P->vspeed, 2.0f) * 0.01f;
+    A->vdelay = A->P->vibe * 0.5f;
+
+    A->volume = 0.0f;
+    A->stage = 0;
+    A->time = 0;
+    A->length[0] = (int)(A->P->attack * A->P->attack * 100000.0f);
+    A->length[1] = (int)(A->P->sustain * A->P->sustain * 100000.0f);
+    A->length[2] = (int)(A->P->decay * A->P->decay * 100000.0f);
+
+    A->fphase = pow(A->P->phase, 2.0f) * 1020.0f;
+    if (A->P->phase < 0.0f) A->fphase = -A->fphase;
+    A->dphase = pow(A->P->psweep, 2.0f) * 1.0f;
+    if (A->P->psweep < 0.0f) A->dphase = -A->dphase;
+    A->iphase = abs((int)A->fphase);
+    A->phasex = 0;
+
+    memset(A->phaser, 0, 1024 * sizeof(float));
+    for (i = 0; i < 32; i++)
+      A->noise[i] = frnd(2.0f) - 1.0f;
+
+    A->repeat = 0;
+    A->limit = (int)(pow(1.0f - A->P->repeat, 2.0f) * 20000 + 32);
+    if (A->P->repeat == 0.0f)
+      A->limit = 0;
+    A->playing = BLOOPS_PLAY;
+  }
+}
+
+void
+bloops_clear(bloops *B)
+{
+  int i;
+  for (i = 0; i < BLOOPS_MAX_TRACKS; i++)
+    B->tracks[i] = NULL;
+}
+
+void
+bloops_tempo(bloops *B, int tempo)
+{
+  B->tempo = tempo;
+}
+
+void
+bloops_track_at(bloops *B, bloopsatrack *track, int num)
+{
+  B->tracks[num] = track;
+}
+
+void
+bloops_play(bloops *B)
+{
+  int i;
+  for (i = 0; i < BLOOPS_MAX_TRACKS; i++)
+    if (B->tracks[i] != NULL) {
+      bloops_ready(B, B->tracks[i], 1);
+      B->tracks[i]->frames = 0;
+    }
+  B->play = BLOOPS_PLAY;
+}
+
+int
+bloops_is_done(bloops *B)
+{
+  return B->play == BLOOPS_STOP;
+}
+
+static void
+bloops_synth(bloops *B, int length, float* buffer)
+{
+  int t, i, si;
+
+  while (length--)
+  {
+    int samplecount = 0;
+    int moreframes = 0;
+    float allsample = 0.0f;
+
+    for (t = 0; t < BLOOPS_MAX_TRACKS; t++)
+    {
+      bloopsatrack *A = B->tracks[t];
+      if (A == NULL)
+        continue;
+
+      if (A->notes)
+      {
+        int frames = 0;
+        for (i = 0; i < A->nlen; i++)
+        {
+          bloopsanote *note = &A->notes[i];
+          if (A->frames == frames)
+          {
+            float freq = bloops_note_freq(note->tone, (int)note->octave);
+            if (freq == 0.0f) {
+              A->period = 0.0f;
+              A->playing = BLOOPS_STOP;
+            } else {
+              bloops_ready(B, A, 1);
+              A->period = 100.0 / (freq * freq + 0.001);
+            }
+          }
+          else if (A->frames < frames)
+            break;
+          frames += (int)(tempo2frames(B->tempo) * (4.0f / note->duration));
+        }
+
+        if (A->frames <= frames)
+          moreframes++;
+      }
+      else
+      {
+        moreframes++;
+      }
+
+      A->frames++;
+
+      if (A->playing == BLOOPS_STOP)
+        continue;
+
+      samplecount++;
+      A->repeat++;
+      if (A->limit != 0 && A->repeat >= A->limit)
+      {
+        A->repeat = 0;
+        bloops_ready(B, A, 0);
+      }
+
+      A->atime++;
+      if (A->alimit != 0 && A->atime >= A->alimit)
+      {
+        A->alimit = 0;
+        A->period *= A->arp;
+      }
+
+      A->slide += A->dslide;
+      A->period *= A->slide;
+      if (A->period > A->maxperiod)
+      {
+        A->period = A->maxperiod;
+        if (A->P->limit > 0.0f)
+          A->playing = BLOOPS_STOP;
+      }
+
+      float rfperiod = A->period;
+      if (A->vdelay > 0.0f)
+      {
+        A->vibe += A->vspeed;
+        rfperiod = A->period * (1.0 + sin(A->vibe) * A->vdelay);
+      }
+
+      int period = (int)rfperiod;
+      if (period < 8) period = 8;
+      A->square += A->sweep;
+      if(A->square < 0.0f) A->square = 0.0f;
+      if(A->square > 0.5f) A->square = 0.5f;    
+
+      A->time++;
+      if (A->time > A->length[A->stage])
+      {
+        A->time = 0;
+        A->stage++;
+        if (A->stage == 3)
+          A->playing = BLOOPS_STOP;
+      }
+
+      switch (A->stage) {
+        case 0:
+          A->volume = (float)A->time / A->length[0];
+        break;
+        case 1:
+          A->volume = 1.0f + pow(1.0f - (float)A->time / A->length[1], 1.0f) * 2.0f * A->P->punch;
+        break;
+        case 2:
+          A->volume = 1.0f - (float)A->time / A->length[2];
+        break;
+      }
+
+      A->fphase += A->dphase;
+      A->iphase = abs((int)A->fphase);
+      if (A->iphase > 1023) A->iphase = 1023;
+
+      if (A->filter[7] != 0.0f)
+      {
+        A->filter[6] *= A->filter[7];
+        if (A->filter[6] < 0.00001f) A->filter[6] = 0.00001f;
+        if (A->filter[6] > 0.1f)     A->filter[6] = 0.1f;
+      }
+
+      float ssample = 0.0f;
+      for (si = 0; si < 8; si++)
+      {
+        float sample = 0.0f;
+        A->phase++;
+        if (A->phase >= period)
+        {
+          A->phase %= period;
+          if (A->P->type == BLOOPS_NOISE)
+            for (i = 0; i < 32; i++)
+              A->noise[i] = frnd(2.0f) - 1.0f;
+        }
+
+        float fp = (float)A->phase / period;
+        switch (A->P->type)
+        {
+          case BLOOPS_SQUARE:
+            if (fp < A->square)
+              sample = 0.5f;
+            else
+              sample = -0.5f;
+          break;
+          case BLOOPS_SAWTOOTH:
+            sample = 1.0f - fp * 2;
+          break;
+          case BLOOPS_SINE:
+            sample = (float)sin(fp * 2 * PI);
+          break;
+          case BLOOPS_NOISE:
+            sample = A->noise[A->phase * 32 / period];
+          break;
+        }
+
+        float pp = A->filter[0];
+        A->filter[2] *= A->filter[3];
+        if (A->filter[2] < 0.0f) A->filter[2] = 0.0f;
+        if (A->filter[2] > 0.1f) A->filter[2] = 0.1f;
+        if (A->P->lpf != 1.0f)
+        {
+          A->filter[1] += (sample - A->filter[0]) * A->filter[2];
+          A->filter[1] -= A->filter[1] * A->filter[4];
+        }
+        else
+        {
+          A->filter[0] = sample;
+          A->filter[1] = 0.0f;
+        }
+        A->filter[0] += A->filter[1];
+
+        A->filter[5] += A->filter[0] - pp;
+        A->filter[5] -= A->filter[5] * A->filter[6];
+        sample = A->filter[5];
+
+        A->phaser[A->phasex & 1023] = sample;
+        sample += A->phaser[(A->phasex - A->iphase + 1024) & 1023];
+        A->phasex = (A->phasex + 1) & 1023;
+
+        ssample += sample * A->volume;
+      }
+      ssample = ssample / 8 * B->volume;
+      ssample *= 2.0f * A->P->volume;
+
+      if (ssample > 1.0f)  ssample = 1.0f;
+      if (ssample < -1.0f) ssample = -1.0f;
+      allsample += ssample;
+    }
+
+    if (moreframes == 0)
+      B->play = BLOOPS_STOP;
+    *buffer++ = allsample;
+  }
+}
+
+static int bloops_port_callback(const void *inputBuffer, void *outputBuffer,
+  unsigned long framesPerBuffer, const PaStreamCallbackTimeInfo* timeInfo,
+  PaStreamCallbackFlags statusFlags, void *data)
+{
+  int i;
+  float *out = (float*)outputBuffer;
+  bloops *B = (bloops *)data;
+
+  if (B->play == BLOOPS_PLAY)
+    bloops_synth(B, framesPerBuffer, out);
+  else
+    for(i = 0; i < framesPerBuffer; i++)
+      *out++ = 0.0f;
+  
+  return 0;
+}
+
+bloopsaphone *
+bloops_square()
+{
+  bloopsaphone *P = (bloopsaphone *)calloc(sizeof(bloopsaphone), 1);
+  P->type = BLOOPS_SQUARE;
+  P->volume = 0.5f;
+  P->sustain = 0.3f;
+  P->decay = 0.4f;
+  P->freq = 0.3f;
+  P->lpf = 1.0f;
+  return P;
+}
+
+bloopsaphone *
+bloops_load(char* filename)
+{
+  bloopsaphone *P = NULL;
+  FILE* file = fopen(filename, "rb");
+  if (!file) return NULL;
+
+  int version = 0;
+  fread(&version, 1, sizeof(int), file);
+  if (version != 102)
+    return NULL;
+
+  P = (bloopsaphone *)malloc(sizeof(bloopsaphone));
+  fread(&P->type,    1, sizeof(int), file);
+
+  P->volume = 0.5f;
+  fread(&P->volume,  1, sizeof(float), file);
+  fread(&P->freq,    1, sizeof(float), file);
+  fread(&P->limit,   1, sizeof(float), file);
+  fread(&P->slide,   1, sizeof(float), file);
+  fread(&P->dslide,  1, sizeof(float), file);
+  fread(&P->square,  1, sizeof(float), file);
+  fread(&P->sweep,   1, sizeof(float), file);
+
+  fread(&P->vibe,    1, sizeof(float), file);
+  fread(&P->vspeed,  1, sizeof(float), file);
+  fread(&P->vdelay,  1, sizeof(float), file);
+
+  fread(&P->attack,  1, sizeof(float), file);
+  fread(&P->sustain, 1, sizeof(float), file);
+  fread(&P->decay,   1, sizeof(float), file);
+  fread(&P->punch,   1, sizeof(float), file);
+
+  fread(&P->resonance, 1, sizeof(float), file);
+  fread(&P->lpf,     1, sizeof(float), file);
+  fread(&P->lsweep,  1, sizeof(float), file);
+  fread(&P->hpf,     1, sizeof(float), file);
+  fread(&P->hsweep,  1, sizeof(float), file);
+  
+  fread(&P->phase,   1, sizeof(float), file);
+  fread(&P->psweep,  1, sizeof(float), file);
+
+  fread(&P->repeat,  1, sizeof(float), file);
+  fread(&P->arp,     1, sizeof(float), file);
+  fread(&P->aspeed,  1, sizeof(float), file);
+
+  fclose(file);
+  return P;
+}
+
+static int bloops_open = 0;
+
+bloops *
+bloops_new()
+{
+  bloops *B = (bloops *)malloc(sizeof(bloops));
+  B->volume = 0.10f;
+  B->tempo = 120;
+  B->play = BLOOPS_STOP;
+  bloops_clear(B);
+
+  if (!bloops_open++)
+  {
+    srand(time(NULL));
+    Pa_Initialize();
+  }
+
+  Pa_OpenDefaultStream(&B->stream, 0, 1, paFloat32,
+    SAMPLE_RATE, 512, bloops_port_callback, B);
+  Pa_StartStream(B->stream);
+  return B;
+}
+
+void
+bloops_destroy(bloops *B)
+{
+  Pa_StopStream(B->stream);
+  Pa_CloseStream(B->stream);
+  free((void *)B);
+
+  if (!--bloops_open)
+    Pa_Terminate();
+}
+
+void
+bloops_track_destroy(bloopsatrack *track)
+{
+  if (track->notes != NULL)
+    free(track->notes);
+  free(track);
+}