alsa_ioctl 0.1.0

use crate::bitfield_unit::BitfieldUnit;

#[repr(C)]
#[derive(Debug, Copy, Clone)]
pub struct SndTimerId {
    pub dev_class: ::std::os::raw::c_int,
    pub dev_sclass: ::std::os::raw::c_int,
    pub card: ::std::os::raw::c_int,
    pub device: ::std::os::raw::c_int,
    pub subdevice: ::std::os::raw::c_int,
}

pub type SndSeqEventTypeT = ::std::os::raw::c_uchar;

#[doc = " event address"]
#[repr(C)]
#[derive(Debug, Copy, Clone)]
pub struct SndSeqAddr {
    #[doc = "< Client number:         0..255, 255 = broadcast to all clients"]
    pub client: ::std::os::raw::c_uchar,
    #[doc = "< Port within client:    0..255, 255 = broadcast to all ports"]
    pub port: ::std::os::raw::c_uchar,
}

#[doc = " port connection"]
#[repr(C)]
#[derive(Debug, Copy, Clone)]
pub struct SndSeqConnect {
    pub sender: SndSeqAddr,
    pub dest: SndSeqAddr,
}

#[repr(C)]
#[derive(Debug, Copy, Clone)]
pub struct SndSeqEvNote {
    pub channel: ::std::os::raw::c_uchar,
    pub note: ::std::os::raw::c_uchar,
    pub velocity: ::std::os::raw::c_uchar,
    pub off_velocity: ::std::os::raw::c_uchar,
    pub duration: ::std::os::raw::c_uint,
}

#[repr(C)]
#[derive(Debug, Copy, Clone)]
pub struct SndSeqEvCtrl {
    pub channel: ::std::os::raw::c_uchar,
    pub unused1: ::std::os::raw::c_uchar,
    pub unused2: ::std::os::raw::c_uchar,
    pub unused3: ::std::os::raw::c_uchar,
    pub param: ::std::os::raw::c_uint,
    pub value: ::std::os::raw::c_int,
}

#[repr(C)]
#[derive(Debug, Copy, Clone)]
pub struct SndSeqEvRaw8 {
    pub d: [::std::os::raw::c_uchar; 12usize],
}

#[repr(C)]
#[derive(Debug, Copy, Clone)]
pub struct SndSeqEvRaw32 {
    pub d: [::std::os::raw::c_uint; 3usize],
}

#[repr(C, packed)]
#[derive(Debug, Copy, Clone)]
pub struct SndSeqEvExt {
    pub len: ::std::os::raw::c_uint,
    pub ptr: *mut ::std::os::raw::c_void,
}

#[repr(C)]
#[derive(Debug, Copy, Clone)]
pub struct SndSeqResult {
    pub event: ::std::os::raw::c_int,
    pub result: ::std::os::raw::c_int,
}

#[repr(C)]
#[derive(Debug, Copy, Clone)]
pub struct SndSeqRealTime {
    pub tv_sec: ::std::os::raw::c_uint,
    pub tv_nsec: ::std::os::raw::c_uint,
}

pub type SndSeqTickTimeT = ::std::os::raw::c_uint;
#[repr(C)]
#[derive(Copy, Clone)]
pub union SndSeqTimestamp {
    pub tick: SndSeqTickTimeT,
    pub time: SndSeqRealTime,
}

#[repr(C)]
#[derive(Debug, Copy, Clone)]
pub struct SndSeqQueueSkew {
    pub value: ::std::os::raw::c_uint,
    pub base: ::std::os::raw::c_uint,
}

#[repr(C)]
#[derive(Copy, Clone)]
pub struct SndSeqEvQueueControl {
    pub queue: ::std::os::raw::c_uchar,
    pub pad: [::std::os::raw::c_uchar; 3usize],
    pub param: SndSeqEvQueueControlParam,
}

#[repr(C)]
#[derive(Copy, Clone)]
pub union SndSeqEvQueueControlParam {
    pub value: ::std::os::raw::c_int,
    pub time: SndSeqTimestamp,
    pub position: ::std::os::raw::c_uint,
    pub skew: SndSeqQueueSkew,
    pub d32: [::std::os::raw::c_uint; 2usize],
    pub d8: [::std::os::raw::c_uchar; 8usize],
}

#[repr(C, packed)]
#[derive(Debug, Copy, Clone)]
pub struct SndSeqEvQuote {
    pub origin: SndSeqAddr,
    pub value: ::std::os::raw::c_ushort,
    pub event: *mut SndSeqEvent,
}

#[repr(C)]
#[derive(Copy, Clone)]
pub struct SndSeqEvent {
    pub type_: SndSeqEventTypeT,
    pub flags: ::std::os::raw::c_uchar,
    pub tag: ::std::os::raw::c_char,
    pub queue: ::std::os::raw::c_uchar,
    pub time: SndSeqTimestamp,
    pub source: SndSeqAddr,
    pub dest: SndSeqAddr,
    pub data: SndSeqEventData,
}

#[repr(C)]
#[derive(Copy, Clone)]
pub union SndSeqEventData {
    pub note: SndSeqEvNote,
    pub control: SndSeqEvCtrl,
    pub raw8: SndSeqEvRaw8,
    pub raw32: SndSeqEvRaw32,
    pub ext: SndSeqEvExt,
    pub queue: SndSeqEvQueueControl,
    pub time: SndSeqTimestamp,
    pub addr: SndSeqAddr,
    pub connect: SndSeqConnect,
    pub result: SndSeqResult,
    pub quote: SndSeqEvQuote,
}

#[repr(C)]
#[derive(Copy, Clone)]
pub struct SndSeqEventBounce {
    pub err: ::std::os::raw::c_int,
    pub event: SndSeqEvent,
}

#[repr(C)]
#[derive(Debug, Copy, Clone)]
pub struct SndSeqSystemInfo {
    pub queues: ::std::os::raw::c_int,
    pub clients: ::std::os::raw::c_int,
    pub ports: ::std::os::raw::c_int,
    pub channels: ::std::os::raw::c_int,
    pub cur_clients: ::std::os::raw::c_int,
    pub cur_queues: ::std::os::raw::c_int,
    pub reserved: [::std::os::raw::c_char; 24usize],
}

#[repr(C)]
#[derive(Debug, Copy, Clone)]
pub struct SndSeqRunningInfo {
    pub client: ::std::os::raw::c_uchar,
    pub big_endian: ::std::os::raw::c_uchar,
    pub cpu_mode: ::std::os::raw::c_uchar,
    pub pad: ::std::os::raw::c_uchar,
    pub reserved: [::std::os::raw::c_uchar; 12usize],
}

pub type SndSeqClientTypeT = ::std::os::raw::c_int;

#[repr(C)]
#[derive(Debug, Copy, Clone)]
pub struct SndSeqClientInfo {
    pub client: ::std::os::raw::c_int,
    pub type_: SndSeqClientTypeT,
    pub name: [::std::os::raw::c_char; 64usize],
    pub filter: ::std::os::raw::c_uint,
    pub multicast_filter: [::std::os::raw::c_uchar; 8usize],
    pub event_filter: [::std::os::raw::c_uchar; 32usize],
    pub num_ports: ::std::os::raw::c_int,
    pub event_lost: ::std::os::raw::c_int,
    pub card: ::std::os::raw::c_int,
    pub pid: ::std::os::raw::c_int,
    pub reserved: [::std::os::raw::c_char; 56usize],
}

#[repr(C)]
#[derive(Debug, Copy, Clone)]
pub struct SndSeqClientPool {
    pub client: ::std::os::raw::c_int,
    pub output_pool: ::std::os::raw::c_int,
    pub input_pool: ::std::os::raw::c_int,
    pub output_room: ::std::os::raw::c_int,
    pub output_free: ::std::os::raw::c_int,
    pub input_free: ::std::os::raw::c_int,
    pub reserved: [::std::os::raw::c_char; 64usize],
}

#[repr(C)]
#[derive(Copy, Clone)]
pub struct SndSeqRemoveEvents {
    pub remove_mode: ::std::os::raw::c_uint,
    pub time: SndSeqTimestamp,
    pub queue: ::std::os::raw::c_uchar,
    pub dest: SndSeqAddr,
    pub channel: ::std::os::raw::c_uchar,
    pub type_: ::std::os::raw::c_int,
    pub tag: ::std::os::raw::c_char,
    pub reserved: [::std::os::raw::c_int; 10usize],
}

#[repr(C)]
#[derive(Debug, Copy, Clone)]
pub struct SndSeqPortInfo {
    pub addr: SndSeqAddr,
    pub name: [::std::os::raw::c_char; 64usize],
    pub capability: ::std::os::raw::c_uint,
    pub type_: ::std::os::raw::c_uint,
    pub midi_channels: ::std::os::raw::c_int,
    pub midi_voices: ::std::os::raw::c_int,
    pub synth_voices: ::std::os::raw::c_int,
    pub read_use: ::std::os::raw::c_int,
    pub write_use: ::std::os::raw::c_int,
    pub kernel: *mut ::std::os::raw::c_void,
    pub flags: ::std::os::raw::c_uint,
    pub time_queue: ::std::os::raw::c_uchar,
    pub reserved: [::std::os::raw::c_char; 59usize],
}

#[repr(C)]
#[derive(Debug, Copy, Clone)]
pub struct SndSeqQueueInfo {
    pub queue: ::std::os::raw::c_int,
    pub owner: ::std::os::raw::c_int,
    pub _bitfield_align_1: [u8; 0],
    pub _bitfield_1: BitfieldUnit<[u8; 1usize]>,
    pub name: [::std::os::raw::c_char; 64usize],
    pub flags: ::std::os::raw::c_uint,
    pub reserved: [::std::os::raw::c_char; 60usize],
}

impl SndSeqQueueInfo {
    #[inline]
    pub fn locked(&self) -> ::std::os::raw::c_uint {
        unsafe { ::std::mem::transmute(self._bitfield_1.get(0usize, 1u8) as u32) }
    }
    #[inline]
    pub fn set_locked(&mut self, val: ::std::os::raw::c_uint) {
        unsafe {
            let val: u32 = ::std::mem::transmute(val);
            self._bitfield_1.set(0usize, 1u8, val as u64)
        }
    }
    #[inline]
    pub fn new_bitfield_1(locked: ::std::os::raw::c_uint) -> BitfieldUnit<[u8; 1usize]> {
        let mut __bindgen_bitfield_unit: BitfieldUnit<[u8; 1usize]> = Default::default();
        __bindgen_bitfield_unit.set(0usize, 1u8, {
            let locked: u32 = unsafe { ::std::mem::transmute(locked) };
            locked as u64
        });
        __bindgen_bitfield_unit
    }
}

#[repr(C)]
#[derive(Debug, Copy, Clone)]
pub struct SndSeqQueueStatus {
    pub queue: ::std::os::raw::c_int,
    pub events: ::std::os::raw::c_int,
    pub tick: SndSeqTickTimeT,
    pub time: SndSeqRealTime,
    pub running: ::std::os::raw::c_int,
    pub flags: ::std::os::raw::c_int,
    pub reserved: [::std::os::raw::c_char; 64usize],
}

#[repr(C)]
#[derive(Debug, Copy, Clone)]
pub struct SndSeqQueueTempo {
    pub queue: ::std::os::raw::c_int,
    pub tempo: ::std::os::raw::c_uint,
    pub ppq: ::std::os::raw::c_int,
    pub skew_value: ::std::os::raw::c_uint,
    pub skew_base: ::std::os::raw::c_uint,
    pub reserved: [::std::os::raw::c_char; 24usize],
}

#[repr(C)]
#[derive(Copy, Clone)]
pub struct SndSeqQueueTimer {
    pub queue: ::std::os::raw::c_int,
    pub type_: ::std::os::raw::c_int,
    pub u: SndSeqQueueTimerUnion,
    pub reserved: [::std::os::raw::c_char; 64usize],
}

#[repr(C)]
#[derive(Copy, Clone)]
pub union SndSeqQueueTimerUnion {
    pub alsa: SndSeqQueueTimerAlsa,
}

#[repr(C)]
#[derive(Debug, Copy, Clone)]
pub struct SndSeqQueueTimerAlsa {
    pub id: SndTimerId,
    pub resolution: ::std::os::raw::c_uint,
}

#[repr(C)]
#[derive(Debug, Copy, Clone)]
pub struct SndSeqQueueClient {
    pub queue: ::std::os::raw::c_int,
    pub client: ::std::os::raw::c_int,
    pub used: ::std::os::raw::c_int,
    pub reserved: [::std::os::raw::c_char; 64usize],
}

#[repr(C)]
#[derive(Debug, Copy, Clone)]
pub struct SndSeqPortSubscribe {
    pub sender: SndSeqAddr,
    pub dest: SndSeqAddr,
    pub voices: ::std::os::raw::c_uint,
    pub flags: ::std::os::raw::c_uint,
    pub queue: ::std::os::raw::c_uchar,
    pub pad: [::std::os::raw::c_uchar; 3usize],
    pub reserved: [::std::os::raw::c_char; 64usize],
}

#[repr(C)]
#[derive(Debug, Copy, Clone)]
pub struct SndSeqQuerySubs {
    pub root: SndSeqAddr,
    pub type_: ::std::os::raw::c_int,
    pub index: ::std::os::raw::c_int,
    pub num_subs: ::std::os::raw::c_int,
    pub addr: SndSeqAddr,
    pub queue: ::std::os::raw::c_uchar,
    pub flags: ::std::os::raw::c_uint,
    pub reserved: [::std::os::raw::c_char; 64usize],
}