add geomusic.scales

This module contains the base class `Scale' as well as a couple
of scales implementations (LogScale for standard temperate scale
and HarmonicScale based on harmonic fifths).  They provide
convenient ways of computing note frequencies.
_geomusic.c: add Fragment.import_bytes method

This method takes a `bytearray' object and converts it to the
internal floating point data format of the Fragment.  No
re-sampling or channel conversion can be made, so both the sample
rate and the number of channels of the input data and the
Fragment instance must match.  The sample width must be 16 bits
for now.  (Future versions may perform conversions and other
sample widths...).

Note: The Fragment is automatically resized to hold the data
      being imported, although it's more efficient when importing
      many small pieces to pre-size the buffer in the client code
      where the final length should be known.
geomusic/data.py: add Fragment.open class method

* add AudioFile abstract factory class to define interface to
  audio file
* add WaveFile to implement the AudioFile interface for Wave
* add Fragment.open class method to create a Fragment using an
  input audio file (via the AudioFile factory class and
  Fragment.import_bytes)
* add Fragment.n2s and Fragment.s2n to respectively convert
  sample number index to time (seconds as floating point) index
  and reverse, based on the fragment sample rate
* remove noisy print statements
geomusic/data.py: add slice args to Fragment.save_to_file

* Fragment.save_to_file: add `start' and `end' arguments to only
  save a piece of the Fragment data to the output file
_geomusic.c: set exceptions and PyMem_* functions

* replace all `fprintf(stderr, ...)' calls with PyErr_* to set
  exceptions when returning an error
* use PyMem_* functions instead of libc malloc, realloc and free
* add tests for negative indexes
* remove unwanted comments
_geomusic.c: fix `normalize' algorithm

* compute average progressively with (1 / frag->length) instead
  of sum of a series of numbers of an undetermined length
* use standard `fabsf' function to compute absolute value of
  positive and negative extrema
* initialise pos and neg with -1.0 and +1.0 respectively
* substract each channel's average when normalizing
_geomusic: return `bytearray' from `Fragment.as_bytes'

The PyBuffer API and associated object type is now deprecated.
The _geomusic.Fragment.as_bytes method now returns a `bytearray'
object instead.
_geomusic.c: check tuple size in Fragment_sq_ass_item

The size of the tuple must be equal to the number of
channels in the fragment.  An exception is raised
otherwise.
geomusic/filters.py: simplify syntax in linear_fade
geomusic/scales.py: get note freq. with Scale.__getitem__

Add Scale.__getitem__ to get a note freqency for a given
string as in scale['A'].  This is a shorthand for
scale.get_note_freq() (scale is a Scale instance).
dew_drop.py: use LogScale instead of hard-coded freqs

Instead of manually calculated frequencies, use LogScale
and note names to get them.  The original frequencies were
approximations of a harmonic scale, so this sounds slightly
more consonent.

The notes frequences for the scale over 3 octaves are also
printed for illustration purposes.  It's easy to change the
basic pitch or use a different scale without re-writing all
the `sine' calls.
_geomusic.c: check sample rate in Fragment.mix

If the sample rate of the 2 fragments don't match,
throw an exception.
geomusic.c: default start time to 0 in Fragment.mix

If the start time is not specified, the default behaviour
is to mix the 2 fragments from the beginning.
_geomusic.c: add `_geomusic.overtones' source function

This is a new source which generates a sum of sine waves
(overtones) using a dictionary and a fudamental frequency.
It is supposed to be more efficient than calling `sine' in
a loop as it does only one pass on the output fragment.
geomusic: add SineGenerator and OvertonesGenerator

* rename Generator.run -> Generator._run and define unimplemented
  method Geomusic.run for sub-classes
* add SineGenerator and OvertonesGenerator classes to
  respectively generate sine waves and overtones (need to
  manually define the overtones dictionary for now...)
* remove Generator.sine method, use SineGenerator class instead
_geomusic.c: use dB levels + add lin <-> dB functions

* add lin2dB and dB2lin macros and functions to convert levels from/to
  linear and dB in C and Python
* use dB for all levels in sine, overtones, normalize
geomusic/__init__.py: add lin2dB and dB2lin
OvertonesGenerator: add ot_decexp method

This method sets defines overtones following a decreasing
exponential.  The number of harmonics and the ratio applied to
the exponential are passed as arguments.  A small ratio will
create louder high harmonics.  The computation time will increase
with the number of harmonics to generate (default is 24) although
the resulting spectrum will be more detailed.

+ set default overtones for pure sine wave in __init__
dew_drop.py: use OvertonesGenerator + tidy-up

* adjust fade time for each part, longer fade for lower notes
* use OvertonesGenerator and use OvertonesGenerator.ot_decexp to
  set the overtones for each part
* use levels in dB instead of linear scale
* print some messages to follow the progression
* add 0.5s silence padding at the beginning and end before saving
add `doc' sub-directory with empty Sphinx files

This is the initial files from the Sphinx quick-start.