root/ocaml-remix/trunk/track.ml

type tcache_elem = {
    tce_raw_start: Time.raw_time;
    tce_start: Time.time;
    tce_length:Time.time;
    tce_transparency: Transparency.transparency};;

type track = {mutable tr_layers : 
                (Layer.layer * (tcache_elem list * Remix.remix) option) array};;

let gen_tcache_elem remix (start, length) trans =
  {tce_raw_start = Time.time_to_raw_time remix start;
   tce_start = start;
   tce_length = length;
   tce_transparency = trans};;

let regen_tcache track idx remix = 
  let _ttr (extent, trans) = gen_tcache_elem remix extent trans in
  let _cmp a b = compare a.tce_raw_start b.tce_raw_start in
  let (layer, _) = track.tr_layers.(idx) in
    track.tr_layers.(idx) <- 
     (layer, Some (List.sort _cmp 
        (List.map _ttr (Layer.transparency_list layer)), remix))

let maybe_gen_tcache track idx remix = match track.tr_layers.(idx) with
  | (_, None) -> regen_tcache track idx remix
  | (_, Some (_, r)) -> if r != remix then regen_tcache track idx remix

exception CantStrip;;

let strip x = match x with
  | None -> raise CantStrip
  | Some a -> a;;

let empty _ = {tr_layers=[||]};;

let add_layer track layer = 
  track.tr_layers <- Array.append track.tr_layers [|(layer, None)|];;

exception OutOfBounds;;
let apply_transparency sound1 extent1 sound2 extent2 transparency text 
      remix start rext =
  let raw_sound1 = sound1 remix extent1 rext in
  let raw_sound2 = sound2 remix extent2 rext in
  let raw_trans = transparency remix text rext in
  FB.transparency raw_sound2 raw_sound1 raw_trans;;

(* 
 * render by transparencies, and gaps between.  Here are our 6 cases:
 *
 * 1. render window completely before first transparency:
 *    <--render-->                   start=render.start   trans=None     DONE
 *                   <--trans-->     length=render.length
 *
 * 2. render window overlaps with first transparency:
 *   <--render-------...             start=render.start   trans=None     ITER
 *              <----trans-->        length=trans.start - render.start
 *
 * 3. render window starts with transparency and ends before:
 *  <-----render---->                start=render.start   trans=Trans    DONE
 *  <--------trans--------->         length=render.length
 *
 * 4. render window starts with transparency and ends after:
 *  <---------render------...        start=render.start   trans=Trans    ITER
 *  <---trans--->                    length=trans.length
 *
 * 5. render window starts after transparency and ends before:
 *        <--render-->              start=render.start    trans=Trans    DONE
 *  <--------trans----------->      length=render.length
 *
 * 6. render window starts after transparency and ends after:
 *        <----------render----...  start=render.start    trans=Trans    ITER
 *  <----trans---->                 length=trans.start+trans.length-render.start
 *
 * generalising: start=render.start
 * trans.end = trans.start+trans.length
 * render.end = render.start+render.length
 * case 1,2: length=min(trans.start-render.start, render.length)
 * case 3,4,5,6: length=min(trans.end, render.end)-start
 *)
let to_note track undersound remix extent (start, length)  =
  let layers = track.tr_layers in
  let rec _render_at pos remix extent (start, length) =
    maybe_gen_tcache track pos remix;
    let olayer = Layer.empty () in
    let _add_s_to_out sound raw_start raw_length = Layer.add_note olayer 
                            (Note.from_sound sound)
                          (Time.Samples raw_start, Time.Samples raw_length) in
    let (layer, pretrans) = layers.(pos) in
    let (translist, _) = strip pretrans in
    let rec _render_at_2 raw_start raw_length l = 
      if raw_length == 0 then () else match l with
      | [] -> (
        let sound2 = _render_at (pos + 1) in
        let sound1 = Layer.to_note layer sound2 in
        _add_s_to_out sound1 raw_start raw_length
        (*_add_l_to_out layer raw_start raw_length*)
      )
      | elem::r -> (
          if raw_start < elem.tce_raw_start then (
            (* case 1,2 *)
            let diff = min (elem.tce_raw_start - raw_start) raw_length in
            let sound2 = _render_at (pos + 1) in
            let sound1 = Layer.to_note layer sound2 in
            _add_s_to_out sound1 raw_start diff; 
            (* _add_l_to_out layer raw_start diff; *)
            _render_at_2 elem.tce_raw_start (raw_length - diff) (elem::r)
          ) else (
            (* case 3,4,5,6 *)
            let ext = Time.overlap remix (elem.tce_start, elem.tce_length)
                        (Time.Samples raw_start, Time.Samples raw_length) in
            let sound2 = _render_at (pos + 1) in
            let sound1 = (Layer.to_note layer sound2) in
            let trans = elem.tce_transparency in 
            let raw_start, l = Time.extent_to_raw_time remix ext in
            _add_s_to_out (apply_transparency sound1 (fst ext) sound2 (fst ext) 
                trans (elem.tce_start, elem.tce_length)) raw_start l;
            _render_at_2 (raw_start + l) (raw_length - l) r
          )
        ) in
    let raw_start = Time.time_to_raw_time remix start in
    let raw_length = Time.time_to_raw_time remix length in
    _render_at_2 raw_start raw_length translist;
    Layer.to_note olayer undersound remix extent (start, length) in
  _render_at 0 remix extent (start,length);;