root/ocaml-remix/trunk/ladspa.ml

(* map a set of output buffers from a tree to a set of input ports.  Outputs
   can be ignored and also duplicated.  Input ports past the valid port range
   have buffers copied across directly *)
type mapping = (int * int) list;;

(* a plugin has a list of trees which plug into the input/output slots, and 
   an int list which refers to the output slots which the tree represents.  If
   the output slots are not empty, then their trees are rendered and added
   to *)
type tree = 
  | Control of float
  | Audio of Sound.sound
  | Plugin of (string * (tree * mapping) list * bool * int list)
  | EmptySlot;;

exception InvalidChannel;;

let rec perform_mapping arrmaplist len pos =
  let rec perform_inner_mapping oarray map pos = match map with
      | (frompos, topos)::rest -> 
          (
            if topos = pos 
            then Some oarray.(frompos)
            else perform_inner_mapping oarray rest pos
          )
      | [] -> None in
  match arrmaplist with
      | (oarray, map)::rest -> 
          (
            match (perform_inner_mapping oarray map pos) with
              | Some v -> v
              | None -> perform_mapping rest len pos
          )
      | [] -> Ladspa_raw.empty_buffer len;;

let render_tree tree remix (s_s, s_l) (r_s, r_l) = 
  let length_in_samples = Time.time_to_raw_samples remix r_l in
  let rec _render_tree tree = match tree with
    | EmptySlot -> [| Ladspa_raw.empty_buffer length_in_samples |]
    | Control f -> [| Ladspa_raw.control_value_to_buffer f |]
    | Audio s   -> 
      (
        let channels = Remix.channels remix in
        let rs = s remix s_s (r_s, r_l) in
        let len = (Array.length rs) / channels in
        let out_arr = 
              Array.init channels (fun _ -> Ladspa_raw.empty_buffer len) in
        Ladspa_raw.raw_sound_to_buffers rs out_arr len;
        out_arr
      )
    | Plugin (name, trees, adding, outputs) ->
      (
        let p = Ladspa_raw.open_plugin name in
        let h = Ladspa_raw.instantiate p (Remix.samplerate remix) in
        let n_channels = Ladspa_raw.port_count p in
        let outs = List.map (fun (a,b) -> _render_tree a, b) trees in
        let lmax2 l = List.fold_right (fun (a,b) m -> max b m) l 0 in
        let omax = (List.fold_right (fun (a,b) m -> max (lmax2 b) m) outs 0) + 1
        in
        let oarray = Array.init omax (perform_mapping outs length_in_samples) in
        Array.iteri 
          (fun n b -> if n < n_channels then Ladspa_raw.connect_port p h n b) 
          oarray; 
        Ladspa_raw.activate p h;
        if adding 
        then Ladspa_raw.run_adding p h length_in_samples
        else Ladspa_raw.run p h length_in_samples;
        Array.init (List.length outputs) 
          (fun pos -> let o = List.nth outputs pos in oarray.(o)) 
      ) in
  let result = _render_tree tree in
  Ladspa_raw.buffers_to_raw_sound result length_in_samples;;

(* compiled pipeline approach.  What's a compiled ladpsa pipeline look like? 
 *
 * We'll need a list of input buffers to fill, a list of plugins to run in 
 * order, a list of output buffers to return, and a maximum length in samples.
 * We'll also need a list of all used buffers for deallocation and cleanup
 * purposes.
 *)
type compiledPipeline =
      { inputs : Ladspa_raw.buffer list;
        plugins : Ladspa_raw.plugin list;
        handles : Ladspa_raw.handle list;
        outputs : Ladspa_raw.buffer list;
        maxlength : int;
        samplerate : int option;
        allbuffers : Ladspa_raw.buffer list
      };;

(*let run_compiled_pipeline pipeline rawsoundlist =*)