Source file scene_format_b.ml

(* Auto-generated from "scene_format.atd" *)
[@@@ocaml.warning "-27-32-33-35-39"]

type bpm_operation = Scene_format_t.bpm_operation

type id = Scene_format_t.id

type midi_event = Scene_format_t.midi_event = {
  port: int;
  status: int;
  channel: int;
  data1: int;
  data2: int option
}

type event = Scene_format_t.event = 
    Track_ends of id
  | Track_starts of id
  | Midi_input of midi_event


type action = Scene_format_t.action = 
    Raw_midi of midi_event
  | Track_on of (id * int)
  | Track_off of id
  | Bpm_operation of bpm_operation
  | Add_event_handler of event_handler
  | Remove_event_handler of event_handler
  | Remove_event_handler_by_event of event
  | All_tracks_off
  | Stop


and event_handler = Scene_format_t.event_handler = {
  name: string;
  events: event list;
  actions: action list
}

type ticked_action = Scene_format_t.ticked_action = {
  tick: int;
  action: action
}

type track = Scene_format_t.track = {
  id: id;
  events: ticked_action list;
  length: int;
  name: string
}

type scene = Scene_format_t.scene = {
  active: id list;
  handlers: event_handler list;
  bpm: int;
  ppqn: int;
  tracks: track list
}

let _1_tag = Bi_io.num_variant_tag
let write_untagged__1 = (
  Atdgen_runtime.Ob_run.write_untagged_option (
    Bi_io.write_svint
  )
)
let write__1 ob x =
  Bi_io.write_tag ob Bi_io.num_variant_tag;
  write_untagged__1 ob x
let string_of__1 ?(len = 1024) x =
  let ob = Bi_outbuf.create len in
  write__1 ob x;
  Bi_outbuf.contents ob
let get__1_reader = (
  fun tag ->
    if tag <> 22 then Atdgen_runtime.Ob_run.read_error () else
      fun ib ->
        match Char.code (Bi_inbuf.read_char ib) with
          | 0 -> None
          | 0x80 ->
            Some (
              (
                Atdgen_runtime.Ob_run.read_int
              )
                ib
            )
          | _ -> Atdgen_runtime.Ob_run.read_error_at ib
)
let read__1 = (
  fun ib ->
    if Bi_io.read_tag ib <> 22 then Atdgen_runtime.Ob_run.read_error_at ib;
    match Char.code (Bi_inbuf.read_char ib) with
      | 0 -> None
      | 0x80 ->
        Some (
          (
            Atdgen_runtime.Ob_run.read_int
          )
            ib
        )
      | _ -> Atdgen_runtime.Ob_run.read_error_at ib
)
let _1_of_string ?pos s =
  read__1 (Bi_inbuf.from_string ?pos s)
let bpm_operation_tag = Bi_io.variant_tag
let write_untagged_bpm_operation = (
  fun ob x ->
    match x with
      | `Set x ->
        Bi_outbuf.add_char4 ob '\128' '?' 'S' '\130';
        (
          Bi_io.write_svint
        ) ob x
      | `Incr x ->
        Bi_outbuf.add_char4 ob '\176' '\148' 'a' '\244';
        (
          Bi_io.write_svint
        ) ob x
      | `Decr x ->
        Bi_outbuf.add_char4 ob '\173' '?' '|' '\144';
        (
          Bi_io.write_svint
        ) ob x
      | `Mul x ->
        Bi_outbuf.add_char4 ob '\128' ':' '\211' '\228';
        (
          Bi_io.write_float64
        ) ob x
)
let write_bpm_operation ob x =
  Bi_io.write_tag ob Bi_io.variant_tag;
  write_untagged_bpm_operation ob x
let string_of_bpm_operation ?(len = 1024) x =
  let ob = Bi_outbuf.create len in
  write_bpm_operation ob x;
  Bi_outbuf.contents ob
let get_bpm_operation_reader = (
  fun tag ->
    if tag <> 23 then Atdgen_runtime.Ob_run.read_error () else
      fun ib ->
        Bi_io.read_hashtag ib (fun ib h has_arg ->
          match h, has_arg with
            | 4150146, true -> (`Set (
                (
                  Atdgen_runtime.Ob_run.read_int
                ) ib
              ))
            | 815030772, true -> (`Incr (
                (
                  Atdgen_runtime.Ob_run.read_int
                ) ib
              ))
            | 759135376, true -> (`Decr (
                (
                  Atdgen_runtime.Ob_run.read_int
                ) ib
              ))
            | 3855332, true -> (`Mul (
                (
                  Atdgen_runtime.Ob_run.read_float64
                ) ib
              ))
            | _ -> Atdgen_runtime.Ob_run.unsupported_variant h has_arg
        )
)
let read_bpm_operation = (
  fun ib ->
    if Bi_io.read_tag ib <> 23 then Atdgen_runtime.Ob_run.read_error_at ib;
    Bi_io.read_hashtag ib (fun ib h has_arg ->
      match h, has_arg with
        | 4150146, true -> (`Set (
            (
              Atdgen_runtime.Ob_run.read_int
            ) ib
          ))
        | 815030772, true -> (`Incr (
            (
              Atdgen_runtime.Ob_run.read_int
            ) ib
          ))
        | 759135376, true -> (`Decr (
            (
              Atdgen_runtime.Ob_run.read_int
            ) ib
          ))
        | 3855332, true -> (`Mul (
            (
              Atdgen_runtime.Ob_run.read_float64
            ) ib
          ))
        | _ -> Atdgen_runtime.Ob_run.unsupported_variant h has_arg
    )
)
let bpm_operation_of_string ?pos s =
  read_bpm_operation (Bi_inbuf.from_string ?pos s)
let id_tag = Bi_io.string_tag
let write_untagged_id = (
  Bi_io.write_untagged_string
)
let write_id ob x =
  Bi_io.write_tag ob Bi_io.string_tag;
  write_untagged_id ob x
let string_of_id ?(len = 1024) x =
  let ob = Bi_outbuf.create len in
  write_id ob x;
  Bi_outbuf.contents ob
let get_id_reader = (
  Atdgen_runtime.Ob_run.get_string_reader
)
let read_id = (
  Atdgen_runtime.Ob_run.read_string
)
let id_of_string ?pos s =
  read_id (Bi_inbuf.from_string ?pos s)
let midi_event_tag = Bi_io.record_tag
let write_untagged_midi_event : Bi_outbuf.t -> midi_event -> unit = (
  fun ob x ->
    Bi_vint.write_uvint ob 5;
    Bi_outbuf.add_char4 ob '\202' '\\' '\131' '\129';
    (
      Bi_io.write_svint
    ) ob x.port;
    Bi_outbuf.add_char4 ob '\133' '\251' '\231' '2';
    (
      Bi_io.write_svint
    ) ob x.status;
    Bi_outbuf.add_char4 ob '\204' '\210' '\000' '\195';
    (
      Bi_io.write_svint
    ) ob x.channel;
    Bi_outbuf.add_char4 ob '\212' '\136' '\014' '\199';
    (
      Bi_io.write_svint
    ) ob x.data1;
    Bi_outbuf.add_char4 ob '\212' '\136' '\014' '\200';
    (
      write__1
    ) ob x.data2;
)
let write_midi_event ob x =
  Bi_io.write_tag ob Bi_io.record_tag;
  write_untagged_midi_event ob x
let string_of_midi_event ?(len = 1024) x =
  let ob = Bi_outbuf.create len in
  write_midi_event ob x;
  Bi_outbuf.contents ob
let get_midi_event_reader = (
  fun tag ->
    if tag <> 21 then Atdgen_runtime.Ob_run.read_error () else
      fun ib ->
        let field_port = ref (Obj.magic (Sys.opaque_identity 0.0)) in
        let field_status = ref (Obj.magic (Sys.opaque_identity 0.0)) in
        let field_channel = ref (Obj.magic (Sys.opaque_identity 0.0)) in
        let field_data1 = ref (Obj.magic (Sys.opaque_identity 0.0)) in
        let field_data2 = ref (Obj.magic (Sys.opaque_identity 0.0)) in
        let bits0 = ref 0 in
        let len = Bi_vint.read_uvint ib in
        for i = 1 to len do
          match Bi_io.read_field_hashtag ib with
            | -899906687 ->
              field_port := (
                (
                  Atdgen_runtime.Ob_run.read_int
                ) ib
              );
              bits0 := !bits0 lor 0x1;
            | 100394802 ->
              field_status := (
                (
                  Atdgen_runtime.Ob_run.read_int
                ) ib
              );
              bits0 := !bits0 lor 0x2;
            | -858652477 ->
              field_channel := (
                (
                  Atdgen_runtime.Ob_run.read_int
                ) ib
              );
              bits0 := !bits0 lor 0x4;
            | -729280825 ->
              field_data1 := (
                (
                  Atdgen_runtime.Ob_run.read_int
                ) ib
              );
              bits0 := !bits0 lor 0x8;
            | -729280824 ->
              field_data2 := (
                (
                  read__1
                ) ib
              );
              bits0 := !bits0 lor 0x10;
            | _ -> Bi_io.skip ib
        done;
        if !bits0 <> 0x1f then Atdgen_runtime.Ob_run.missing_fields [| !bits0 |] [| "port"; "status"; "channel"; "data1"; "data2" |];
        (
          {
            port = !field_port;
            status = !field_status;
            channel = !field_channel;
            data1 = !field_data1;
            data2 = !field_data2;
          }
         : midi_event)
)
let read_midi_event = (
  fun ib ->
    if Bi_io.read_tag ib <> 21 then Atdgen_runtime.Ob_run.read_error_at ib;
    let field_port = ref (Obj.magic (Sys.opaque_identity 0.0)) in
    let field_status = ref (Obj.magic (Sys.opaque_identity 0.0)) in
    let field_channel = ref (Obj.magic (Sys.opaque_identity 0.0)) in
    let field_data1 = ref (Obj.magic (Sys.opaque_identity 0.0)) in
    let field_data2 = ref (Obj.magic (Sys.opaque_identity 0.0)) in
    let bits0 = ref 0 in
    let len = Bi_vint.read_uvint ib in
    for i = 1 to len do
      match Bi_io.read_field_hashtag ib with
        | -899906687 ->
          field_port := (
            (
              Atdgen_runtime.Ob_run.read_int
            ) ib
          );
          bits0 := !bits0 lor 0x1;
        | 100394802 ->
          field_status := (
            (
              Atdgen_runtime.Ob_run.read_int
            ) ib
          );
          bits0 := !bits0 lor 0x2;
        | -858652477 ->
          field_channel := (
            (
              Atdgen_runtime.Ob_run.read_int
            ) ib
          );
          bits0 := !bits0 lor 0x4;
        | -729280825 ->
          field_data1 := (
            (
              Atdgen_runtime.Ob_run.read_int
            ) ib
          );
          bits0 := !bits0 lor 0x8;
        | -729280824 ->
          field_data2 := (
            (
              read__1
            ) ib
          );
          bits0 := !bits0 lor 0x10;
        | _ -> Bi_io.skip ib
    done;
    if !bits0 <> 0x1f then Atdgen_runtime.Ob_run.missing_fields [| !bits0 |] [| "port"; "status"; "channel"; "data1"; "data2" |];
    (
      {
        port = !field_port;
        status = !field_status;
        channel = !field_channel;
        data1 = !field_data1;
        data2 = !field_data2;
      }
     : midi_event)
)
let midi_event_of_string ?pos s =
  read_midi_event (Bi_inbuf.from_string ?pos s)
let event_tag = Bi_io.variant_tag
let write_untagged_event : Bi_outbuf.t -> event -> unit = (
  fun ob x ->
    match x with
      | Track_ends x ->
        Bi_outbuf.add_char4 ob '\135' '1' 'U' '\204';
        (
          write_id
        ) ob x
      | Track_starts x ->
        Bi_outbuf.add_char4 ob '\193' '\245' '\232' 'e';
        (
          write_id
        ) ob x
      | Midi_input x ->
        Bi_outbuf.add_char4 ob '\251' 'q' 't' '\012';
        (
          write_midi_event
        ) ob x
)
let write_event ob x =
  Bi_io.write_tag ob Bi_io.variant_tag;
  write_untagged_event ob x
let string_of_event ?(len = 1024) x =
  let ob = Bi_outbuf.create len in
  write_event ob x;
  Bi_outbuf.contents ob
let get_event_reader = (
  fun tag ->
    if tag <> 23 then Atdgen_runtime.Ob_run.read_error () else
      fun ib ->
        Bi_io.read_hashtag ib (fun ib h has_arg ->
          match h, has_arg with
            | 120673740, true -> (Track_ends (
                (
                  read_id
                ) ib
              ) : event)
            | -1040848795, true -> (Track_starts (
                (
                  read_id
                ) ib
              ) : event)
            | -76450804, true -> (Midi_input (
                (
                  read_midi_event
                ) ib
              ) : event)
            | _ -> Atdgen_runtime.Ob_run.unsupported_variant h has_arg
        )
)
let read_event = (
  fun ib ->
    if Bi_io.read_tag ib <> 23 then Atdgen_runtime.Ob_run.read_error_at ib;
    Bi_io.read_hashtag ib (fun ib h has_arg ->
      match h, has_arg with
        | 120673740, true -> (Track_ends (
            (
              read_id
            ) ib
          ) : event)
        | -1040848795, true -> (Track_starts (
            (
              read_id
            ) ib
          ) : event)
        | -76450804, true -> (Midi_input (
            (
              read_midi_event
            ) ib
          ) : event)
        | _ -> Atdgen_runtime.Ob_run.unsupported_variant h has_arg
    )
)
let event_of_string ?pos s =
  read_event (Bi_inbuf.from_string ?pos s)
let _2_tag = Bi_io.array_tag
let write_untagged__2 = (
  Atdgen_runtime.Ob_run.write_untagged_list
    event_tag
    (
      write_untagged_event
    )
)
let write__2 ob x =
  Bi_io.write_tag ob Bi_io.array_tag;
  write_untagged__2 ob x
let string_of__2 ?(len = 1024) x =
  let ob = Bi_outbuf.create len in
  write__2 ob x;
  Bi_outbuf.contents ob
let get__2_reader = (
  Atdgen_runtime.Ob_run.get_list_reader (
    get_event_reader
  )
)
let read__2 = (
  Atdgen_runtime.Ob_run.read_list (
    get_event_reader
  )
)
let _2_of_string ?pos s =
  read__2 (Bi_inbuf.from_string ?pos s)
let rec _3_tag = Bi_io.array_tag
and write_untagged__3 ob x = (
  Atdgen_runtime.Ob_run.write_untagged_list
    action_tag
    (
      write_untagged_action
    )
) ob x
and write__3 ob x =
  Bi_io.write_tag ob Bi_io.array_tag;
  write_untagged__3 ob x
and string_of__3 ?(len = 1024) x =
  let ob = Bi_outbuf.create len in
  write__3 ob x;
  Bi_outbuf.contents ob
and action_tag = Bi_io.variant_tag
and write_untagged_action : Bi_outbuf.t -> action -> unit = (
  fun ob x ->
    match x with
      | Raw_midi x ->
        Bi_outbuf.add_char4 ob '\163' '\175' '\222' '\248';
        (
          write_midi_event
        ) ob x
      | Track_on x ->
        Bi_outbuf.add_char4 ob '\217' 'h' '\r' '\179';
        (
          fun ob x ->
            Bi_io.write_tag ob Bi_io.tuple_tag;
            Bi_vint.write_uvint ob 2;
            (
              let x, _ = x in (
                write_id
              ) ob x
            );
            (
              let _, x = x in (
                Bi_io.write_svint
              ) ob x
            );
        ) ob x
      | Track_off x ->
        Bi_outbuf.add_char4 ob '\225' '\163' '\232' '[';
        (
          write_id
        ) ob x
      | Bpm_operation x ->
        Bi_outbuf.add_char4 ob '\153' '\246' '\251' 'g';
        (
          write_bpm_operation
        ) ob x
      | Add_event_handler x ->
        Bi_outbuf.add_char4 ob '\223' '4' '5' 'g';
        (
          write_event_handler
        ) ob x
      | Remove_event_handler x ->
        Bi_outbuf.add_char4 ob '\156' 'T' '\227' '\n';
        (
          write_event_handler
        ) ob x
      | Remove_event_handler_by_event x ->
        Bi_outbuf.add_char4 ob '\138' '\150' 'C' '\135';
        (
          write_event
        ) ob x
      | All_tracks_off -> Bi_outbuf.add_char4 ob '{' '\016' '\145' '\182'
      | Stop -> Bi_outbuf.add_char4 ob '7' '5' '\028' '"'
)
and write_action ob x =
  Bi_io.write_tag ob Bi_io.variant_tag;
  write_untagged_action ob x
and string_of_action ?(len = 1024) x =
  let ob = Bi_outbuf.create len in
  write_action ob x;
  Bi_outbuf.contents ob
and event_handler_tag = Bi_io.record_tag
and write_untagged_event_handler : Bi_outbuf.t -> event_handler -> unit = (
  fun ob x ->
    Bi_vint.write_uvint ob 3;
    Bi_outbuf.add_char4 ob '\200' '\255' 'r' 'K';
    (
      Bi_io.write_string
    ) ob x.name;
    Bi_outbuf.add_char4 ob '\150' 'j' 'O' '\025';
    (
      write__2
    ) ob x.events;
    Bi_outbuf.add_char4 ob '\231' '.' '\003' '\253';
    (
      write__3
    ) ob x.actions;
)
and write_event_handler ob x =
  Bi_io.write_tag ob Bi_io.record_tag;
  write_untagged_event_handler ob x
and string_of_event_handler ?(len = 1024) x =
  let ob = Bi_outbuf.create len in
  write_event_handler ob x;
  Bi_outbuf.contents ob
let rec get__3_reader tag = (
  Atdgen_runtime.Ob_run.get_list_reader (
    get_action_reader
  )
) tag
and read__3 ib = (
  Atdgen_runtime.Ob_run.read_list (
    get_action_reader
  )
) ib
and _3_of_string ?pos s =
  read__3 (Bi_inbuf.from_string ?pos s)
and get_action_reader = (
  fun tag ->
    if tag <> 23 then Atdgen_runtime.Ob_run.read_error () else
      fun ib ->
        Bi_io.read_hashtag ib (fun ib h has_arg ->
          match h, has_arg with
            | 598728440, true -> (Raw_midi (
                (
                  read_midi_event
                ) ib
              ) : action)
            | -647492173, true -> (Track_on (
                (
                  fun ib ->
                    if Bi_io.read_tag ib <> 20 then Atdgen_runtime.Ob_run.read_error_at ib;
                    let len = Bi_vint.read_uvint ib in
                    if len < 2 then Atdgen_runtime.Ob_run.missing_tuple_fields len [ 0; 1 ];
                    let x0 =
                      (
                        read_id
                      ) ib
                    in
                    let x1 =
                      (
                        Atdgen_runtime.Ob_run.read_int
                      ) ib
                    in
                    for i = 2 to len - 1 do Bi_io.skip ib done;
                    (x0, x1)
                ) ib
              ) : action)
            | -509351845, true -> (Track_off (
                (
                  read_id
                ) ib
              ) : action)
            | 435616615, true -> (Bpm_operation (
                (
                  read_bpm_operation
                ) ib
              ) : action)
            | -550226585, true -> (Add_event_handler (
                (
                  read_event_handler
                ) ib
              ) : action)
            | 475325194, true -> (Remove_event_handler (
                (
                  read_event_handler
                ) ib
              ) : action)
            | 177619847, true -> (Remove_event_handler_by_event (
                (
                  read_event
                ) ib
              ) : action)
            | -82800202, false -> (All_tracks_off : action)
            | 926227490, false -> (Stop : action)
            | _ -> Atdgen_runtime.Ob_run.unsupported_variant h has_arg
        )
)
and read_action = (
  fun ib ->
    if Bi_io.read_tag ib <> 23 then Atdgen_runtime.Ob_run.read_error_at ib;
    Bi_io.read_hashtag ib (fun ib h has_arg ->
      match h, has_arg with
        | 598728440, true -> (Raw_midi (
            (
              read_midi_event
            ) ib
          ) : action)
        | -647492173, true -> (Track_on (
            (
              fun ib ->
                if Bi_io.read_tag ib <> 20 then Atdgen_runtime.Ob_run.read_error_at ib;
                let len = Bi_vint.read_uvint ib in
                if len < 2 then Atdgen_runtime.Ob_run.missing_tuple_fields len [ 0; 1 ];
                let x0 =
                  (
                    read_id
                  ) ib
                in
                let x1 =
                  (
                    Atdgen_runtime.Ob_run.read_int
                  ) ib
                in
                for i = 2 to len - 1 do Bi_io.skip ib done;
                (x0, x1)
            ) ib
          ) : action)
        | -509351845, true -> (Track_off (
            (
              read_id
            ) ib
          ) : action)
        | 435616615, true -> (Bpm_operation (
            (
              read_bpm_operation
            ) ib
          ) : action)
        | -550226585, true -> (Add_event_handler (
            (
              read_event_handler
            ) ib
          ) : action)
        | 475325194, true -> (Remove_event_handler (
            (
              read_event_handler
            ) ib
          ) : action)
        | 177619847, true -> (Remove_event_handler_by_event (
            (
              read_event
            ) ib
          ) : action)
        | -82800202, false -> (All_tracks_off : action)
        | 926227490, false -> (Stop : action)
        | _ -> Atdgen_runtime.Ob_run.unsupported_variant h has_arg
    )
)
and action_of_string ?pos s =
  read_action (Bi_inbuf.from_string ?pos s)
and get_event_handler_reader = (
  fun tag ->
    if tag <> 21 then Atdgen_runtime.Ob_run.read_error () else
      fun ib ->
        let field_name = ref (Obj.magic (Sys.opaque_identity 0.0)) in
        let field_events = ref (Obj.magic (Sys.opaque_identity 0.0)) in
        let field_actions = ref (Obj.magic (Sys.opaque_identity 0.0)) in
        let bits0 = ref 0 in
        let len = Bi_vint.read_uvint ib in
        for i = 1 to len do
          match Bi_io.read_field_hashtag ib with
            | -922783157 ->
              field_name := (
                (
                  Atdgen_runtime.Ob_run.read_string
                ) ib
              );
              bits0 := !bits0 lor 0x1;
            | 376065817 ->
              field_events := (
                (
                  read__2
                ) ib
              );
              bits0 := !bits0 lor 0x2;
            | -416414723 ->
              field_actions := (
                (
                  read__3
                ) ib
              );
              bits0 := !bits0 lor 0x4;
            | _ -> Bi_io.skip ib
        done;
        if !bits0 <> 0x7 then Atdgen_runtime.Ob_run.missing_fields [| !bits0 |] [| "name"; "events"; "actions" |];
        (
          {
            name = !field_name;
            events = !field_events;
            actions = !field_actions;
          }
         : event_handler)
)
and read_event_handler = (
  fun ib ->
    if Bi_io.read_tag ib <> 21 then Atdgen_runtime.Ob_run.read_error_at ib;
    let field_name = ref (Obj.magic (Sys.opaque_identity 0.0)) in
    let field_events = ref (Obj.magic (Sys.opaque_identity 0.0)) in
    let field_actions = ref (Obj.magic (Sys.opaque_identity 0.0)) in
    let bits0 = ref 0 in
    let len = Bi_vint.read_uvint ib in
    for i = 1 to len do
      match Bi_io.read_field_hashtag ib with
        | -922783157 ->
          field_name := (
            (
              Atdgen_runtime.Ob_run.read_string
            ) ib
          );
          bits0 := !bits0 lor 0x1;
        | 376065817 ->
          field_events := (
            (
              read__2
            ) ib
          );
          bits0 := !bits0 lor 0x2;
        | -416414723 ->
          field_actions := (
            (
              read__3
            ) ib
          );
          bits0 := !bits0 lor 0x4;
        | _ -> Bi_io.skip ib
    done;
    if !bits0 <> 0x7 then Atdgen_runtime.Ob_run.missing_fields [| !bits0 |] [| "name"; "events"; "actions" |];
    (
      {
        name = !field_name;
        events = !field_events;
        actions = !field_actions;
      }
     : event_handler)
)
and event_handler_of_string ?pos s =
  read_event_handler (Bi_inbuf.from_string ?pos s)
let ticked_action_tag = Bi_io.record_tag
let write_untagged_ticked_action : Bi_outbuf.t -> ticked_action -> unit = (
  fun ob x ->
    Bi_vint.write_uvint ob 2;
    Bi_outbuf.add_char4 ob '\204' '\252' '\195' ']';
    (
      Bi_io.write_svint
    ) ob x.tick;
    Bi_outbuf.add_char4 ob '\150' 'F' ';' '\182';
    (
      write_action
    ) ob x.action;
)
let write_ticked_action ob x =
  Bi_io.write_tag ob Bi_io.record_tag;
  write_untagged_ticked_action ob x
let string_of_ticked_action ?(len = 1024) x =
  let ob = Bi_outbuf.create len in
  write_ticked_action ob x;
  Bi_outbuf.contents ob
let get_ticked_action_reader = (
  fun tag ->
    if tag <> 21 then Atdgen_runtime.Ob_run.read_error () else
      fun ib ->
        let field_tick = ref (Obj.magic (Sys.opaque_identity 0.0)) in
        let field_action = ref (Obj.magic (Sys.opaque_identity 0.0)) in
        let bits0 = ref 0 in
        let len = Bi_vint.read_uvint ib in
        for i = 1 to len do
          match Bi_io.read_field_hashtag ib with
            | -855850147 ->
              field_tick := (
                (
                  Atdgen_runtime.Ob_run.read_int
                ) ib
              );
              bits0 := !bits0 lor 0x1;
            | 373701558 ->
              field_action := (
                (
                  read_action
                ) ib
              );
              bits0 := !bits0 lor 0x2;
            | _ -> Bi_io.skip ib
        done;
        if !bits0 <> 0x3 then Atdgen_runtime.Ob_run.missing_fields [| !bits0 |] [| "tick"; "action" |];
        (
          {
            tick = !field_tick;
            action = !field_action;
          }
         : ticked_action)
)
let read_ticked_action = (
  fun ib ->
    if Bi_io.read_tag ib <> 21 then Atdgen_runtime.Ob_run.read_error_at ib;
    let field_tick = ref (Obj.magic (Sys.opaque_identity 0.0)) in
    let field_action = ref (Obj.magic (Sys.opaque_identity 0.0)) in
    let bits0 = ref 0 in
    let len = Bi_vint.read_uvint ib in
    for i = 1 to len do
      match Bi_io.read_field_hashtag ib with
        | -855850147 ->
          field_tick := (
            (
              Atdgen_runtime.Ob_run.read_int
            ) ib
          );
          bits0 := !bits0 lor 0x1;
        | 373701558 ->
          field_action := (
            (
              read_action
            ) ib
          );
          bits0 := !bits0 lor 0x2;
        | _ -> Bi_io.skip ib
    done;
    if !bits0 <> 0x3 then Atdgen_runtime.Ob_run.missing_fields [| !bits0 |] [| "tick"; "action" |];
    (
      {
        tick = !field_tick;
        action = !field_action;
      }
     : ticked_action)
)
let ticked_action_of_string ?pos s =
  read_ticked_action (Bi_inbuf.from_string ?pos s)
let _4_tag = Bi_io.array_tag
let write_untagged__4 = (
  Atdgen_runtime.Ob_run.write_untagged_list
    ticked_action_tag
    (
      write_untagged_ticked_action
    )
)
let write__4 ob x =
  Bi_io.write_tag ob Bi_io.array_tag;
  write_untagged__4 ob x
let string_of__4 ?(len = 1024) x =
  let ob = Bi_outbuf.create len in
  write__4 ob x;
  Bi_outbuf.contents ob
let get__4_reader = (
  Atdgen_runtime.Ob_run.get_list_reader (
    get_ticked_action_reader
  )
)
let read__4 = (
  Atdgen_runtime.Ob_run.read_list (
    get_ticked_action_reader
  )
)
let _4_of_string ?pos s =
  read__4 (Bi_inbuf.from_string ?pos s)
let track_tag = Bi_io.record_tag
let write_untagged_track : Bi_outbuf.t -> track -> unit = (
  fun ob x ->
    Bi_vint.write_uvint ob 4;
    Bi_outbuf.add_char4 ob '\128' '\000' '[' '\219';
    (
      write_id
    ) ob x.id;
    Bi_outbuf.add_char4 ob '\150' 'j' 'O' '\025';
    (
      write__4
    ) ob x.events;
    Bi_outbuf.add_char4 ob '\159' '\007' '\148' '\230';
    (
      Bi_io.write_svint
    ) ob x.length;
    Bi_outbuf.add_char4 ob '\200' '\255' 'r' 'K';
    (
      Bi_io.write_string
    ) ob x.name;
)
let write_track ob x =
  Bi_io.write_tag ob Bi_io.record_tag;
  write_untagged_track ob x
let string_of_track ?(len = 1024) x =
  let ob = Bi_outbuf.create len in
  write_track ob x;
  Bi_outbuf.contents ob
let get_track_reader = (
  fun tag ->
    if tag <> 21 then Atdgen_runtime.Ob_run.read_error () else
      fun ib ->
        let field_id = ref (Obj.magic (Sys.opaque_identity 0.0)) in
        let field_events = ref (Obj.magic (Sys.opaque_identity 0.0)) in
        let field_length = ref (Obj.magic (Sys.opaque_identity 0.0)) in
        let field_name = ref (Obj.magic (Sys.opaque_identity 0.0)) in
        let bits0 = ref 0 in
        let len = Bi_vint.read_uvint ib in
        for i = 1 to len do
          match Bi_io.read_field_hashtag ib with
            | 23515 ->
              field_id := (
                (
                  read_id
                ) ib
              );
              bits0 := !bits0 lor 0x1;
            | 376065817 ->
              field_events := (
                (
                  read__4
                ) ib
              );
              bits0 := !bits0 lor 0x2;
            | 520590566 ->
              field_length := (
                (
                  Atdgen_runtime.Ob_run.read_int
                ) ib
              );
              bits0 := !bits0 lor 0x4;
            | -922783157 ->
              field_name := (
                (
                  Atdgen_runtime.Ob_run.read_string
                ) ib
              );
              bits0 := !bits0 lor 0x8;
            | _ -> Bi_io.skip ib
        done;
        if !bits0 <> 0xf then Atdgen_runtime.Ob_run.missing_fields [| !bits0 |] [| "id"; "events"; "length"; "name" |];
        (
          {
            id = !field_id;
            events = !field_events;
            length = !field_length;
            name = !field_name;
          }
         : track)
)
let read_track = (
  fun ib ->
    if Bi_io.read_tag ib <> 21 then Atdgen_runtime.Ob_run.read_error_at ib;
    let field_id = ref (Obj.magic (Sys.opaque_identity 0.0)) in
    let field_events = ref (Obj.magic (Sys.opaque_identity 0.0)) in
    let field_length = ref (Obj.magic (Sys.opaque_identity 0.0)) in
    let field_name = ref (Obj.magic (Sys.opaque_identity 0.0)) in
    let bits0 = ref 0 in
    let len = Bi_vint.read_uvint ib in
    for i = 1 to len do
      match Bi_io.read_field_hashtag ib with
        | 23515 ->
          field_id := (
            (
              read_id
            ) ib
          );
          bits0 := !bits0 lor 0x1;
        | 376065817 ->
          field_events := (
            (
              read__4
            ) ib
          );
          bits0 := !bits0 lor 0x2;
        | 520590566 ->
          field_length := (
            (
              Atdgen_runtime.Ob_run.read_int
            ) ib
          );
          bits0 := !bits0 lor 0x4;
        | -922783157 ->
          field_name := (
            (
              Atdgen_runtime.Ob_run.read_string
            ) ib
          );
          bits0 := !bits0 lor 0x8;
        | _ -> Bi_io.skip ib
    done;
    if !bits0 <> 0xf then Atdgen_runtime.Ob_run.missing_fields [| !bits0 |] [| "id"; "events"; "length"; "name" |];
    (
      {
        id = !field_id;
        events = !field_events;
        length = !field_length;
        name = !field_name;
      }
     : track)
)
let track_of_string ?pos s =
  read_track (Bi_inbuf.from_string ?pos s)
let _7_tag = Bi_io.array_tag
let write_untagged__7 = (
  Atdgen_runtime.Ob_run.write_untagged_list
    track_tag
    (
      write_untagged_track
    )
)
let write__7 ob x =
  Bi_io.write_tag ob Bi_io.array_tag;
  write_untagged__7 ob x
let string_of__7 ?(len = 1024) x =
  let ob = Bi_outbuf.create len in
  write__7 ob x;
  Bi_outbuf.contents ob
let get__7_reader = (
  Atdgen_runtime.Ob_run.get_list_reader (
    get_track_reader
  )
)
let read__7 = (
  Atdgen_runtime.Ob_run.read_list (
    get_track_reader
  )
)
let _7_of_string ?pos s =
  read__7 (Bi_inbuf.from_string ?pos s)
let _6_tag = Bi_io.array_tag
let write_untagged__6 = (
  Atdgen_runtime.Ob_run.write_untagged_list
    event_handler_tag
    (
      write_untagged_event_handler
    )
)
let write__6 ob x =
  Bi_io.write_tag ob Bi_io.array_tag;
  write_untagged__6 ob x
let string_of__6 ?(len = 1024) x =
  let ob = Bi_outbuf.create len in
  write__6 ob x;
  Bi_outbuf.contents ob
let get__6_reader = (
  Atdgen_runtime.Ob_run.get_list_reader (
    get_event_handler_reader
  )
)
let read__6 = (
  Atdgen_runtime.Ob_run.read_list (
    get_event_handler_reader
  )
)
let _6_of_string ?pos s =
  read__6 (Bi_inbuf.from_string ?pos s)
let _5_tag = Bi_io.array_tag
let write_untagged__5 = (
  Atdgen_runtime.Ob_run.write_untagged_list
    id_tag
    (
      write_untagged_id
    )
)
let write__5 ob x =
  Bi_io.write_tag ob Bi_io.array_tag;
  write_untagged__5 ob x
let string_of__5 ?(len = 1024) x =
  let ob = Bi_outbuf.create len in
  write__5 ob x;
  Bi_outbuf.contents ob
let get__5_reader = (
  Atdgen_runtime.Ob_run.get_list_reader (
    get_id_reader
  )
)
let read__5 = (
  Atdgen_runtime.Ob_run.read_list (
    get_id_reader
  )
)
let _5_of_string ?pos s =
  read__5 (Bi_inbuf.from_string ?pos s)
let scene_tag = Bi_io.record_tag
let write_untagged_scene : Bi_outbuf.t -> scene -> unit = (
  fun ob x ->
    Bi_vint.write_uvint ob 5;
    Bi_outbuf.add_char4 ob '\150' 'F' 'A' '\198';
    (
      write__5
    ) ob x.active;
    Bi_outbuf.add_char4 ob '\213' '$' '!' 'i';
    (
      write__6
    ) ob x.handlers;
    Bi_outbuf.add_char4 ob '\128' 'J' '\190' '\223';
    (
      Bi_io.write_svint
    ) ob x.bpm;
    Bi_outbuf.add_char4 ob '\202' ']' 'D' '\221';
    (
      Bi_io.write_svint
    ) ob x.ppqn;
    Bi_outbuf.add_char4 ob '\197' '}' '+' '\136';
    (
      write__7
    ) ob x.tracks;
)
let write_scene ob x =
  Bi_io.write_tag ob Bi_io.record_tag;
  write_untagged_scene ob x
let string_of_scene ?(len = 1024) x =
  let ob = Bi_outbuf.create len in
  write_scene ob x;
  Bi_outbuf.contents ob
let get_scene_reader = (
  fun tag ->
    if tag <> 21 then Atdgen_runtime.Ob_run.read_error () else
      fun ib ->
        let field_active = ref (Obj.magic (Sys.opaque_identity 0.0)) in
        let field_handlers = ref (Obj.magic (Sys.opaque_identity 0.0)) in
        let field_bpm = ref (Obj.magic (Sys.opaque_identity 0.0)) in
        let field_ppqn = ref (Obj.magic (Sys.opaque_identity 0.0)) in
        let field_tracks = ref (Obj.magic (Sys.opaque_identity 0.0)) in
        let bits0 = ref 0 in
        let len = Bi_vint.read_uvint ib in
        for i = 1 to len do
          match Bi_io.read_field_hashtag ib with
            | 373703110 ->
              field_active := (
                (
                  read__5
                ) ib
              );
              bits0 := !bits0 lor 0x1;
            | -719052439 ->
              field_handlers := (
                (
                  read__6
                ) ib
              );
              bits0 := !bits0 lor 0x2;
            | 4898527 ->
              field_bpm := (
                (
                  Atdgen_runtime.Ob_run.read_int
                ) ib
              );
              bits0 := !bits0 lor 0x4;
            | -899857187 ->
              field_ppqn := (
                (
                  Atdgen_runtime.Ob_run.read_int
                ) ib
              );
              bits0 := !bits0 lor 0x8;
            | -981652600 ->
              field_tracks := (
                (
                  read__7
                ) ib
              );
              bits0 := !bits0 lor 0x10;
            | _ -> Bi_io.skip ib
        done;
        if !bits0 <> 0x1f then Atdgen_runtime.Ob_run.missing_fields [| !bits0 |] [| "active"; "handlers"; "bpm"; "ppqn"; "tracks" |];
        (
          {
            active = !field_active;
            handlers = !field_handlers;
            bpm = !field_bpm;
            ppqn = !field_ppqn;
            tracks = !field_tracks;
          }
         : scene)
)
let read_scene = (
  fun ib ->
    if Bi_io.read_tag ib <> 21 then Atdgen_runtime.Ob_run.read_error_at ib;
    let field_active = ref (Obj.magic (Sys.opaque_identity 0.0)) in
    let field_handlers = ref (Obj.magic (Sys.opaque_identity 0.0)) in
    let field_bpm = ref (Obj.magic (Sys.opaque_identity 0.0)) in
    let field_ppqn = ref (Obj.magic (Sys.opaque_identity 0.0)) in
    let field_tracks = ref (Obj.magic (Sys.opaque_identity 0.0)) in
    let bits0 = ref 0 in
    let len = Bi_vint.read_uvint ib in
    for i = 1 to len do
      match Bi_io.read_field_hashtag ib with
        | 373703110 ->
          field_active := (
            (
              read__5
            ) ib
          );
          bits0 := !bits0 lor 0x1;
        | -719052439 ->
          field_handlers := (
            (
              read__6
            ) ib
          );
          bits0 := !bits0 lor 0x2;
        | 4898527 ->
          field_bpm := (
            (
              Atdgen_runtime.Ob_run.read_int
            ) ib
          );
          bits0 := !bits0 lor 0x4;
        | -899857187 ->
          field_ppqn := (
            (
              Atdgen_runtime.Ob_run.read_int
            ) ib
          );
          bits0 := !bits0 lor 0x8;
        | -981652600 ->
          field_tracks := (
            (
              read__7
            ) ib
          );
          bits0 := !bits0 lor 0x10;
        | _ -> Bi_io.skip ib
    done;
    if !bits0 <> 0x1f then Atdgen_runtime.Ob_run.missing_fields [| !bits0 |] [| "active"; "handlers"; "bpm"; "ppqn"; "tracks" |];
    (
      {
        active = !field_active;
        handlers = !field_handlers;
        bpm = !field_bpm;
        ppqn = !field_ppqn;
        tracks = !field_tracks;
      }
     : scene)
)
let scene_of_string ?pos s =
  read_scene (Bi_inbuf.from_string ?pos s)