Changeset 529 for ocaml-remix/trunk

Timestamp:

11/19/07 15:39:53 (1 year ago)

Author:

shans

Message:

Replacing sound implementation - WAS ocaml int arrays, IS native float
arrays. This has not yet been completely been debugged!

Files:

• ocaml-remix/trunk/FB.ml (modified) (1 diff)
• ocaml-remix/trunk/FB.mli (modified) (1 diff)
• ocaml-remix/trunk/FB_impl.c (modified) (3 diffs)
• ocaml-remix/trunk/Makefile (modified) (2 diffs)
• ocaml-remix/trunk/deck.ml (modified) (1 diff)
• ocaml-remix/trunk/envelope.ml (modified) (2 diffs)
• ocaml-remix/trunk/ladspa_raw.ml (modified) (1 diff)
• ocaml-remix/trunk/ladspa_raw.mli (modified) (1 diff)
• ocaml-remix/trunk/layer.ml (modified) (2 diffs)
• ocaml-remix/trunk/layer_test_sins.ml (modified) (1 diff)
• ocaml-remix/trunk/note.ml (modified) (3 diffs)
• ocaml-remix/trunk/oss.ml (modified) (1 diff)
• ocaml-remix/trunk/oss.mli (modified) (1 diff)
• ocaml-remix/trunk/oss_impl.c (modified) (2 diffs)
• ocaml-remix/trunk/sound.ml (modified) (3 diffs)
• ocaml-remix/trunk/sound.mli (modified) (1 diff)
• ocaml-remix/trunk/track.ml (modified) (1 diff)
• ocaml-remix/trunk/track_test_sins.ml (modified) (1 diff)
• ocaml-remix/trunk/transparency.ml (modified) (3 diffs)
• ocaml-remix/trunk/transparency.mli (modified) (1 diff)
• ocaml-remix/trunk/wave.ml (modified) (1 diff)
• ocaml-remix/trunk/wave.mli (modified) (1 diff)

ocaml-remix/trunk/FB.ml

@@ -4 +4 @@
-external create_raw : int -> int -> buffer_raw = "c_FB_new_buffer";;
-external free_raw : buffer_raw -> unit = "c_FB_free_buffer";;
-(int -> float) -> int
+int -> (int -> float)
-      "c_FB_fill_buffer";;
+external fill_from_raw : buffer_raw -> int -> buffer_raw -> int -> int -> unit =
+      "c_FB_fill_buffer_from_buffer";;
-external add_raw : buffer_raw -> buffer_raw -> int -> buffer_raw =
-      "c_FB_add_buffers";;
+external mult_raw : buffer_raw -> buffer_raw -> int -> buffer_raw = 
+      "c_FB_mult_buffers";;
+external at_raw : buffer_raw -> int -> float = "c_FB_at";;
+external short_at_raw : buffer_raw -> int -> int = "c_FB_short_at";;
+external split_raw : buffer_raw -> buffer_raw array -> int -> unit = 
+      "c_FB_split_into_channels";;
+external merge_raw : buffer_raw array -> buffer_raw -> int -> unit =
+      "c_FB_merge_channels";;
+external blit_raw : buffer_raw -> int -> buffer_raw -> int -> int -> unit =
+      "c_FB_blit";;
+external transparency_raw : buffer_raw -> buffer_raw -> buffer_raw -> int ->
+      buffer_raw = "c_FB_transparency";;
+external average_raw : buffer_raw array -> int -> buffer_raw = "c_FB_average";;
-
-exception ChannelsMismatch;;
+exception BlitOutOfBounds;;
-
-let create l c = (create_raw l c, l, c);;
-let free (b,l,c) = free_raw b;;
-
+
+
+
+
-let add (b1,l1,c1) (b2,l2,c2) = 
-  if c1 != c2 then raise ChannelsMismatch;
-  let l = min l1 l2 in (add_raw b1 b2 (l*c1), l, c1);;
+let mult (b1,l1,c1) (b2,l2,c2) = 
+  if c1 != c2 then raise ChannelsMismatch;
+  let l = min l1 l2 in (mult_raw b1 b2 (l*c1), l, c1);;
+let at (b,l,c) p = at_raw b p;;
+let short_at (b,l,c) p = short_at_raw b p;;
+let split (b,l,c) =
+  let raw_arr = Array.init c (fun i -> create_raw l 1) in
+  split_raw b raw_arr l;
+  Array.init c (fun i -> (raw_arr.(i), l, 1));;
+let merge arr = 
+  let raw_arr = Array.init (Array.length arr) 
+    (fun i -> (match arr.(i) with | (b,_,_) -> b)) in
+  let len = (match arr.(0) with | (_,l,_) -> l) in
+  let out_arr = create_raw len (Array.length arr) in
+  merge_raw raw_arr out_arr len;
+  (out_arr, len, (Array.length arr));;
+let blit (bs, ls, cs) spos (bd, ld, cd) dpos len =
+  if cs != cd then raise ChannelsMismatch;
+  if spos < 0 then raise BlitOutOfBounds;
+  if dpos < 0 then raise BlitOutOfBounds;
+  if (spos + len) > ls then raise BlitOutOfBounds;
+  if (dpos + len) > ld then raise BlitOutOfBounds;
+  blit_raw bs (spos * cs) bd (dpos * cd) (len * cd);;
+let transparency (b1,l1,c1) (b2,l2,c2) (bt,lt,ct) =
+  if c1 != c2 then raise ChannelsMismatch;
+  if c1 != ct then raise ChannelsMismatch;
+  let len = min (min l1 l2) lt in
+  (transparency_raw b1 b2 bt (len * c1), len, c1);;
+let average arr =
+  let raw_arr = Array.init (Array.length arr)
+    (fun i -> (match arr.(i) with | (b,_,_) -> b)) in
+  let (len,chans) = (match arr.(0) with | (_,l,c) -> (l,c)) in
+  (average_raw raw_arr (len * chans), len, chans);;
+let length (b,l,c) = l;;
+let size (b,l,c) = l * c;;
+
+let fun_cache = ref [];;
+let create_with_caching func period length channels offset =
+  let b = create length channels in
+  (
+    try 
+      let r = List.assoc (func, channels) (!fun_cache) in
+      fill_from_buffer b r offset
+    with Not_found -> 
+    (
+      let cache = create period channels in
+      fill cache func;
+      fill_from_buffer b cache offset;
+      fun_cache := ((func, channels), cache)::(!fun_cache)
+    )
+  );
+  b;;

ocaml-remix/trunk/FB.mli

@@ -1 @@
-
+
+
-
-val create : int -> int -> buffer;;
-val free : buffer -> unit;;
-
+
+
-val add : buffer -> buffer -> buffer;;
+val mult : buffer -> buffer -> buffer;;
+val at : buffer -> int -> float;;
+val short_at : buffer -> int -> int;;
+val split : buffer -> buffer array;;
+val merge : buffer array -> buffer;;
+val blit : buffer -> int -> buffer -> int -> int -> unit;;
+val transparency : buffer -> buffer -> buffer -> buffer;;
+val average : buffer array -> buffer;;
+
+val length : buffer -> int;;
+val size : buffer -> int;;
+
+val create_with_caching : (int -> float) -> int -> int -> int -> int -> buffer;;

ocaml-remix/trunk/FB_impl.c

@@ -6 +6 @@
-#include <caml/mlvalues.h>
-
+#include <string.h>
+#include <stdlib.h>
+
-static void finalize_buffer(value block) {
-  float *data = (float *)Field(block, 1);
@@ -40 +43 @@
-};
-
-size, value ml_callback,
-value ml_period
-
-size, ml_callback, ml_period
+length, value ml_channels, 
+                                value ml_callback
+
+length, ml_channels, ml_callback
-
-  float *buffer = POINTER_FROM_BUFFER(ml_buf);
-
-
-
-
-
-
-
-
-
-
-
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
-
-CAMLprim c_FB_add_buffers(value ml_bufa, value ml_bufb, value ml_size) {
@@ -75 +116 @@
-
-}
+
+CAMLprim c_FB_mult_buffers(value ml_bufa, value ml_bufb, value ml_size) {
+
+  CAMLparam3(ml_bufa, ml_bufb, ml_size);
+
+  int size = Int_val(ml_size);
+  float *bufa = POINTER_FROM_BUFFER(ml_bufa);
+  float *bufb = POINTER_FROM_BUFFER(ml_bufb);
+  float *data = malloc(sizeof(float) * size);
+  int i;
+
+  for (i = 0; i < size; i++) {
+    data[i] = bufa[i] * bufb[i];
+  }
+
+  RETURN_NEW_BUFFER(data);
+
+}
+
+CAMLprim c_FB_transparency(value ml_bufa, value ml_bufb, value ml_trans, value
+    ml_size) {
+
+  CAMLparam4(ml_bufa, ml_bufb, ml_trans, ml_size);
+
+  int size = Int_val(ml_size);
+  float *bufa = POINTER_FROM_BUFFER(ml_bufa);
+  float *bufb = POINTER_FROM_BUFFER(ml_bufb);
+  float *trans = POINTER_FROM_BUFFER(ml_trans);
+  float *data = malloc(sizeof(float) * size);
+  int i;
+
+  for (i = 0; i < size; i++) {
+    data[i] = bufa[i] * trans[i] + bufb[i] * (1 - trans[i]);
+  }
+
+  RETURN_NEW_BUFFER(data);
+}
+
+CAMLprim c_FB_at(value ml_buffer, value ml_position) {
+
+  CAMLparam2(ml_buffer, ml_position);
+
+  float *buffer = POINTER_FROM_BUFFER(ml_buffer);
+  int position = Int_val(ml_position);
+
+  CAMLreturn(copy_double(buffer[position]));
+
+}
+
+CAMLprim c_FB_short_at(value ml_buffer, value ml_position) {
+
+  CAMLparam2(ml_buffer, ml_position);
+
+  float *buffer = POINTER_FROM_BUFFER(ml_buffer);
+  int position = Int_val(ml_position);
+
+  CAMLreturn(Val_int((int)(buffer[position]*32767)));
+
+}
+
+CAMLprim c_FB_split_into_channels(value ml_buffer, value ml_buffers, value ml_length) {
+
+  CAMLparam3(ml_buffer, ml_buffers, ml_length);
+
+  float *buffer = POINTER_FROM_BUFFER(ml_buffer);
+  int channels = Wosize_val(ml_buffers);
+  int length = Int_val(ml_length);
+  int i;
+
+  float **odata = malloc(channels * sizeof(float *));
+
+  for (i = 0; i < channels; i++) {
+    value b = (value)Field(ml_buffers, i);
+    odata[i] = POINTER_FROM_BUFFER(b);
+  }
+
+  length *= channels;
+
+  for (i = 0; i < length; i++) {
+    odata[i % channels][i / channels] = buffer[i];
+  }
+
+  free(odata);
+
+  CAMLreturn(Val_unit);
+
+}
+
+CAMLprim c_FB_merge_channels(value ml_buffers, value ml_buffer, value ml_length) {
+  
+  CAMLparam3(ml_buffers, ml_buffer, ml_length);
+  
+  int channels = Wosize_val(ml_buffers);
+  int length = Int_val(ml_length);
+  int i;
+
+  float **idata = malloc(channels * sizeof(float *));
+  float *odata = POINTER_FROM_BUFFER(ml_buffer);
+
+  for (i = 0; i < channels; i++) {
+    value b = (value)Field(ml_buffers, i);
+    idata[i] = POINTER_FROM_BUFFER(b);
+  }
+
+  length *= channels;
+
+  for(i = 0; i < length; i++) {
+    odata[i] = idata[i % channels][i / channels];
+  }
+
+  free(idata);
+
+  CAMLreturn(Val_unit);
+
+}
+
+CAMLprim c_FB_average(value ml_buffers, value ml_size) {
+
+  CAMLparam2(ml_buffers, ml_size);
+  int num_buffers = Wosize_val(ml_buffers);
+  int size = Int_val(ml_size);
+  int i, j;
+
+  float **idata = malloc(num_buffers * sizeof(float *));
+  float *odata = malloc(size * sizeof(float));
+
+  for (i = 0; i < num_buffers; i++) {
+    value b = (value)Field(ml_buffers, i);
+    idata[i] = POINTER_FROM_BUFFER(b);
+  }
+
+  for (i = 0; i < size; i++) {
+    odata[i] = 0;
+    for (j = 0; j < num_buffers; j++) {
+      odata[i] += idata[j][i];
+    }
+    odata[i] /= num_buffers;
+  }
+
+  free(idata);
+
+  RETURN_NEW_BUFFER(odata);
+
+}
+
+CAMLprim c_FB_blit(value ml_src, value ml_srcpos, value ml_dst, value ml_dstpos,
+                      value ml_length) {
+
+  CAMLparam5(ml_src, ml_srcpos, ml_dst, ml_dstpos, ml_length);
+
+  float *src = POINTER_FROM_BUFFER(ml_src);
+  float *dst = POINTER_FROM_BUFFER(ml_dst);
+  int srcpos = Int_val(ml_srcpos);
+  int dstpos = Int_val(ml_dstpos);
+  int length = Int_val(ml_length);
+
+  memcpy(dst + dstpos, src + srcpos, length * sizeof(float));
+
+  CAMLreturn(Val_unit);
+
+}

ocaml-remix/trunk/Makefile

@@ -6 +6 @@
-                        continuous_sound_test
-INCLUDES=-I +extlib
-oss ladspa_raw FB
+FB oss ladspa_raw
-
-INTERFACES = $(patsubst %, %.mli, $(COMPONENTS))
-SOURCES = $(patsubst %, %.ml, $(COMPONENTS))
-OBJECTS_CMA = $(patsubst %, %.cma, $(OBJECTS))
-OBJECTS_CMXA = $(patsubst %, %.cmxa, $(OBJECTS))
-
-BINTESTS = $(patsubst %, %.bin, $(TESTS))
-OPTTESTS = $(patsubst %, %.opt, $(TESTS))
-
-OCAMLPP = -pp "camlp4o ./pa_operators.cmo"
-OCAMLCARGS = $(INCLUDES) $(OBJECTS_CMA) -w s -g $(OCAMLPP)
-OCAMLOPTARGS = $(INCLUDES) $(OBJECTS_CMXA) -w s -g $(OCAMLPP)
-
-
-pa_operators.cmo: pa_operators.ml
-        ocamlc -I +camlp4 camlp4lib.cma -pp camlp4of pa_operators.ml
-
-remix.cma: $(INTERFACES) $(SOURCES) oss.cma ladspa_raw.cma
-        ocamlc -c $(OCAMLCARGS) $(INTERFACES) $(SOURCES)
-        ocamlc -a -g -o remix.cma $(SOURCES) oss.cma ladspa_raw.cma
-
-remix.cmxa: $(INTERFACES) $(SOURCES) oss.cmxa ladspa_raw.cmxa FB.cmxa
@@ -32 +24 @@
-        ocamlopt -a -o remix.cmxa $(SOURCES)
-
-
-
-
-
+
-        ocamlopt oss_impl.c oss.mli oss.ml -a -o oss.cmxa
-
-ladspa_raw.cma: ladspa_raw.mli ladspa_raw.ml ladspa_impl.c
-        ocamlc -custom ladspa_impl.c ladspa_raw.mli ladspa_raw.ml -a \
-                                                        -o ladspa_raw.cma
-
-ladspa_raw.cmxa: ladspa_raw.mli ladspa_raw.ml ladspa_impl.c
-        ocamlopt ladspa_impl.c ladspa_raw.mli ladspa_raw.ml -a \
-                                                        -o ladspa_raw.cmxa
-
-FB.cmxa: FB.mli FB.ml FB_impl.c
-        ocamlopt FB_impl.c FB.mli FB.ml -a -o FB.cmxa
-
-%.bin: remix.cma %.ml
-        ocamlc $(OCAMLCARGS) $^ -o $@
-
-%.opt: remix.cmxa %.ml
-        ocamlopt $(OCAMLOPTARGS) $^ -o $@
-
-all: pa_operators.cmo remix.cma $(BINTESTS)
-
-all.opt: pa_operators.cmo remix.cmxa $(OPTTESTS)

ocaml-remix/trunk/deck.ml

@@ -5 +5 @@
-let add_track deck track = deck.tracks <- track::deck.tracks;;
-
-let rec l_to_s l p = match l with
-  | h::t -> (l_to_s t p) +. float_of_int h.(p)
-  | []   -> 0.;;
-
-let to_note deck undersound remix extent (st,le) =
-  let raws = List.map 
-    (fun l -> Track.to_note l undersound remix extent (st,le)) deck.tracks in
-
-
-
-
+
-    

ocaml-remix/trunk/envelope.ml

@@ -1 +1 @@
-type envelope = Remix.remix -> Time.time -> int -> float;;
-
-
-
-
-
-
-
-
+
-  if pos <= a 
-  then float_of_int pos /. float_of_int a
@@ -16 +10 @@
-  else s *. float_of_int (raw_length - pos) /. float_of_int r;;
-
+let adsr length a d s r remix start =
+  let a = Time.time_to_raw_time remix a in
+  let d = Time.time_to_raw_time remix d in
+  let r = Time.time_to_raw_time remix r in
+  if length = Time.Forever then
+    Printf.printf "can't create a non-terminating adsr envelope\n%!";
+  let raw_length = Time.time_to_raw_time remix length in
+  _adsr a d s r raw_length;;
+
-let apply envelope sound remix sound_start render_extent =
-
-
-
+
+
+
+
-  let raw_sound = sound remix sound_start render_extent in
-
-
-
-
-
-
+
+

ocaml-remix/trunk/ladspa_raw.ml

@@ -1 +1 @@
-type plugin;;
-type handle;;
-
+ = FB.buffer_raw
-
-type portDirection = Input | Output;;

ocaml-remix/trunk/ladspa_raw.mli

@@ -3 +3 @@
-type plugin;;
-type handle;;
-
+ = FB.buffer_raw
-
-type portDirection = Input | Output;;

ocaml-remix/trunk/layer.ml

@@ -60 +60 @@
-  let (raw_render_start, raw_render_length) = 
-      Time.extent_to_raw_time remix render_extent in
-Array.create (raw_render_length * Remix.channels remix) 0
+FB.create raw_render_length (Remix.channels remix)
-  let rec _layer_to_sound laylist = match laylist with
-    | []                    -> ()
@@ -68 +68 @@
-        if rl > 0 then (
-          let raw_sound = (ss undersound) remix start (s, l) in
-
-
-
+
-        _layer_to_sound t) in
-  _layer_to_sound layer.la_notes;

ocaml-remix/trunk/layer_test_sins.ml

@@ -8 +8 @@
-
-let a t    = Note.from_sound 
-30000
+1
-let hi_a t = Note.from_sound 
-20000.
+0.7
-let e t    = Note.from_sound
-20000.
+0.7
-
-let layer = Layer.empty ();;

ocaml-remix/trunk/note.ml

@@ -63 +63 @@
-  let num_in = List.length inAudioPorts in
-  let num_out = List.length outAudioPorts in 
-  let create_in_buffers n sound length =
-    let b = Array.init n (function _ -> Ladspa_raw.empty_buffer length) in
-    Ladspa_raw.raw_sound_to_buffers sound b length; b in
-  let create_out_buffers n length = 
-
-
+
+
+
-    Ladspa_raw.connect_port ladspa h.(i) (fst (List.nth portlist portpos)) 
-.(i)
+uf
-  if num_in = 1 && num_out = 1 then (
-    let raw_insound = insound remix extent render_extent in
-    let channels = Remix.channels remix in
-create_in_buffers channels raw_insound raw_length
+FB.split raw_insound
-    let outbuffers = create_out_buffers channels raw_length in
-    for i = 0 to (channels - 1) do (
@@ -81 +79 @@
-      Ladspa_raw.run ladspa handles.(i) raw_length
-    ) done;
-Ladspa_raw.buffers_to_raw_sound outbuffers raw_length
+FB.merge outbuffers
-  ) else if num_in = 0 && num_out = 1 then (
-    let channels = Remix.channels remix in
@@ -89 +87 @@
-      Ladspa_raw.run ladspa handles.(i) raw_length
-    ) done;
-Ladspa_raw.buffers_to_raw_sound outbuffers raw_length
+FB.merge outbuffers
-  ) else raise InappropriatePlugin;;
-

ocaml-remix/trunk/oss.ml

@@ -6 +6 @@
-                                                    "c_ex_sound_set_parms";;
-
-
+
+
+
+
-
-external sound_close : soundDevice -> unit = "c_ex_sound_close";;

ocaml-remix/trunk/oss.mli

@@ -3 +3 @@
-val sound_open : unit -> soundDevice;;
-val sound_set_parms : soundDevice -> int -> int -> unit;;
-int array
+FB.buffer
-val sound_close : soundDevice -> unit;;

ocaml-remix/trunk/oss_impl.c

@@ -89 +89 @@
-}
-
-
+, value ml_length
-
-  CAMLparam2(ml_dev, ml_data);
@@ -97 +97 @@
-  int i;
-  short *data;
+  float *indata;
-
-  dev = (SoundDevice *)Field(ml_dev, 0);
-Wosize_val(ml_data
+Int_val(ml_length
-  data = malloc(length * sizeof(short));
+  indata = ((float *)Field(ml_data, 1));
-  
-  for (i = 0; i < length; i++) {
-Int_val(Field(ml_data, i)
+(indata[i] * 32767
-  }
- 

ocaml-remix/trunk/sound.ml

@@ -1 +1 @@
-(* a raw sound is an array of int values *)
-int array
+FB.buffer
-
-(* but sounds have a start, a rendered start, and a rendered length *)
@@ -6 +6 @@
-
-let silence r e (s,l) =
-raw_length = Time.time_to_raw_samples
-Array.create raw_length 0
+length = Time.time_to_raw_time
+FB.create length (Remix.channels r)
-
-(* note: length applies to raw sounds *)
-
+
+
+
-
-(* note: ignore start time when writing raw sounds *)
-let write_raw_sound r out snd =
-  IO.nwrite out "RIFF";
-Array.length
+size
-  IO.nwrite out "WAVE";
-  IO.nwrite out "fmt "; (* format chunk *)
@@ -26 +28 @@
-  IO.write_i16 out 16; (* bits per sample - always 16 *)
-  IO.nwrite out "data"; (* data chunk *)
-Array.length
-Array.length snd - 1) do IO.write_i16 out snd.(
+size
+size snd - 1) do IO.write_i16 out (FB.short_at snd 
-
-let write output remix snd start render_extent =

ocaml-remix/trunk/sound.mli

@@ -1 @@
-int array
+FB.buffer
-
-(** a sound takes a remix, a start time, and a render extent, and generates raw

ocaml-remix/trunk/track.ml

@@ -43 +43 @@
-  let raw_sound2 = sound2 remix extent2 rext in
-  let raw_trans = transparency remix text rext in
-
-
-
-
-
-
-
-
-
+
-
-(* 

ocaml-remix/trunk/track_test_sins.ml

@@ -4 +4 @@
-let env t = Envelope.adsr t (Time.Seconds 0.2) (Time.Seconds 0.6) 0.7 
-                                                           (Time.Seconds 0.1);;
-30000
-20000.
+1
+0.7
-let a t = Envelope.apply (env t) a;;
-let e t = Envelope.apply (env t) e;;

ocaml-remix/trunk/transparency.ml

@@ -1 @@
-float array
+FB.buffer
-
-type transparency = Remix.remix -> Time.extent -> Time.extent -> 
@@ -5 +5 @@
-
-let linear_ramp start_val end_val remix (start, length) (ostart,olength) =
-* Remix.channels remix 
+
-  let raw_start = _to_raw start in
-  if length = Time.Forever then
@@ -15 +15 @@
-      float_of_int (pos + raw_ostart - raw_start) /. 
-                      float_of_int raw_length *. (end_val -. start_val) in
-
+
+
-
-let constant value remix (start, len) (rstart, rlength) =
-
+
+
+

ocaml-remix/trunk/transparency.mli

@@ -1 @@
-float array
+FB.buffer
-
-type transparency = Remix.remix -> Time.extent -> Time.extent 

ocaml-remix/trunk/wave.ml

@@ -1 +1 @@
-type wave = Volume.volume -> float -> Sound.sound;;
-
-
-
-
+
+
-
-exception AmplitudeTooHigh;;
-
-let round_to_int f = 
-      if f >= 0. 
-      then int_of_float (f +. 0.5) 
-      else int_of_float (f -. 0.5)
-
-(* these waves are phased globally so that clicks don't occur between
-   adjacent sounds.  Hence we don't need to worry about the extent
-   of the sound, only the rendered extent *)
-channels 
-(time + start) / channels * channels
+
+time + start
-  let coef = (float_of_int stime) *. 3.142 *. 2. in
-round_to_int (amp *. (sin (coef /. period)
+amp *. (sin (coef /. period
-
-channels 
+
-  if mod_float (float_of_int (time + start)) period < period/.2. 
-int_of_float amp else 
+amp else 0.
-
-
-
-
-
+
+
+
-
-let generate generator volume rate remix ss (start, length) = 
-
-
-
-
-
+
+
+
+
-  let offset = (raw_start - raw_ss) in
-  let channels = Remix.channels remix in
-
-          ((p + offset)/Remix.channels remix)
-Array.init raw_length 
-        (fun p -> generator (vfunc p) period raw_start channels p)
+(p + offset) in
+let buffer = FB.create raw_length channels
+FB.fill buffer (fun p -> generator (vfunc p) period raw_start p);
+buffer
-
-let sin = generate sin_generator;;

ocaml-remix/trunk/wave.mli

@@ -2 +2 @@
-type wave = Volume.volume -> float -> Sound.sound;;
-
-
-
-
+
+
-
-val generate : generator -> wave;;