1pub const SPA_TIME_INVALID: i64 = -9223372036854775808;
4pub const SPA_IDX_INVALID: u32 = 4294967295;
5pub const SPA_ID_INVALID: u32 = 4294967295;
6pub const SPA_NSEC_PER_SEC: u32 = 1000000000;
7pub const SPA_NSEC_PER_MSEC: u32 = 1000000;
8pub const SPA_NSEC_PER_USEC: u32 = 1000;
9pub const SPA_USEC_PER_SEC: u32 = 1000000;
10pub const SPA_USEC_PER_MSEC: u32 = 1000;
11pub const SPA_MSEC_PER_SEC: u32 = 1000;
12pub const SPA_TYPE_INFO_BASE: &[u8; 5] = b"Spa:\0";
13pub const SPA_TYPE_INFO_Flags: &[u8; 10] = b"Spa:Flags\0";
14pub const SPA_TYPE_INFO_FLAGS_BASE: &[u8; 11] = b"Spa:Flags:\0";
15pub const SPA_TYPE_INFO_Enum: &[u8; 9] = b"Spa:Enum\0";
16pub const SPA_TYPE_INFO_ENUM_BASE: &[u8; 10] = b"Spa:Enum:\0";
17pub const SPA_TYPE_INFO_Pod: &[u8; 8] = b"Spa:Pod\0";
18pub const SPA_TYPE_INFO_POD_BASE: &[u8; 9] = b"Spa:Pod:\0";
19pub const SPA_TYPE_INFO_Struct: &[u8; 15] = b"Spa:Pod:Struct\0";
20pub const SPA_TYPE_INFO_STRUCT_BASE: &[u8; 16] = b"Spa:Pod:Struct:\0";
21pub const SPA_TYPE_INFO_Object: &[u8; 15] = b"Spa:Pod:Object\0";
22pub const SPA_TYPE_INFO_OBJECT_BASE: &[u8; 16] = b"Spa:Pod:Object:\0";
23pub const SPA_TYPE_INFO_Pointer: &[u8; 12] = b"Spa:Pointer\0";
24pub const SPA_TYPE_INFO_POINTER_BASE: &[u8; 13] = b"Spa:Pointer:\0";
25pub const SPA_TYPE_INFO_Interface: &[u8; 22] = b"Spa:Pointer:Interface\0";
26pub const SPA_TYPE_INFO_INTERFACE_BASE: &[u8; 23] = b"Spa:Pointer:Interface:\0";
27pub const SPA_TYPE_INFO_Event: &[u8; 21] = b"Spa:Pod:Object:Event\0";
28pub const SPA_TYPE_INFO_EVENT_BASE: &[u8; 22] = b"Spa:Pod:Object:Event:\0";
29pub const SPA_TYPE_INFO_Command: &[u8; 23] = b"Spa:Pod:Object:Command\0";
30pub const SPA_TYPE_INFO_COMMAND_BASE: &[u8; 24] = b"Spa:Pod:Object:Command:\0";
31pub const SPA_POD_PROP_FLAG_READONLY: u32 = 1;
32pub const SPA_POD_PROP_FLAG_HARDWARE: u32 = 2;
33pub const SPA_POD_PROP_FLAG_HINT_DICT: u32 = 4;
34pub const SPA_POD_PROP_FLAG_MANDATORY: u32 = 8;
35pub const SPA_POD_PROP_FLAG_DONT_FIXATE: u32 = 16;
36pub const SPA_META_HEADER_FLAG_DISCONT: u32 = 1;
37pub const SPA_META_HEADER_FLAG_CORRUPTED: u32 = 2;
38pub const SPA_META_HEADER_FLAG_MARKER: u32 = 4;
39pub const SPA_META_HEADER_FLAG_HEADER: u32 = 8;
40pub const SPA_META_HEADER_FLAG_GAP: u32 = 16;
41pub const SPA_META_HEADER_FLAG_DELTA_UNIT: u32 = 32;
42pub const SPA_META_SYNC_TIMELINE_UNSCHEDULED_RELEASE: u32 = 1;
43pub const SPA_CHUNK_FLAG_NONE: u32 = 0;
44pub const SPA_CHUNK_FLAG_CORRUPTED: u32 = 1;
45pub const SPA_CHUNK_FLAG_EMPTY: u32 = 2;
46pub const SPA_DATA_FLAG_NONE: u32 = 0;
47pub const SPA_DATA_FLAG_READABLE: u32 = 1;
48pub const SPA_DATA_FLAG_WRITABLE: u32 = 2;
49pub const SPA_DATA_FLAG_DYNAMIC: u32 = 4;
50pub const SPA_DATA_FLAG_READWRITE: u32 = 3;
51pub const SPA_DATA_FLAG_MAPPABLE: u32 = 8;
52pub const SPA_BUFFER_ALLOC_FLAG_INLINE_META: u32 = 1;
53pub const SPA_BUFFER_ALLOC_FLAG_INLINE_CHUNK: u32 = 2;
54pub const SPA_BUFFER_ALLOC_FLAG_INLINE_DATA: u32 = 4;
55pub const SPA_BUFFER_ALLOC_FLAG_INLINE_ALL: u32 = 7;
56pub const SPA_BUFFER_ALLOC_FLAG_NO_DATA: u32 = 8;
57pub const SPA_TYPE_INFO_Buffer: &[u8; 19] = b"Spa:Pointer:Buffer\0";
58pub const SPA_TYPE_INFO_BUFFER_BASE: &[u8; 20] = b"Spa:Pointer:Buffer:\0";
59pub const SPA_TYPE_INFO_Data: &[u8; 14] = b"Spa:Enum:Data\0";
60pub const SPA_TYPE_INFO_DATA_BASE: &[u8; 15] = b"Spa:Enum:Data:\0";
61pub const SPA_TYPE_INFO_DATA_Fd: &[u8; 17] = b"Spa:Enum:Data:Fd\0";
62pub const SPA_TYPE_INFO_DATA_FD_BASE: &[u8; 18] = b"Spa:Enum:Data:Fd:\0";
63pub const SPA_TYPE_INFO_Meta: &[u8; 17] = b"Spa:Pointer:Meta\0";
64pub const SPA_TYPE_INFO_META_BASE: &[u8; 18] = b"Spa:Pointer:Meta:\0";
65pub const SPA_TYPE_INFO_META_Array: &[u8; 23] = b"Spa:Pointer:Meta:Array\0";
66pub const SPA_TYPE_INFO_META_ARRAY_BASE: &[u8; 24] = b"Spa:Pointer:Meta:Array:\0";
67pub const SPA_TYPE_INFO_META_Region: &[u8; 24] = b"Spa:Pointer:Meta:Region\0";
68pub const SPA_TYPE_INFO_META_REGION_BASE: &[u8; 25] = b"Spa:Pointer:Meta:Region:\0";
69pub const SPA_TYPE_INFO_META_ARRAY_Region: &[u8; 30] = b"Spa:Pointer:Meta:Array:Region\0";
70pub const SPA_TYPE_INFO_META_ARRAY_REGION_BASE: &[u8; 31] = b"Spa:Pointer:Meta:Array:Region:\0";
71pub const SPA_TYPE_INFO_META_Transformation: &[u8; 29] = b"Spa:Enum:Meta:Transformation\0";
72pub const SPA_TYPE_INFO_META_TRANSFORMATION_BASE: &[u8; 30] = b"Spa:Enum:Meta:Transformation:\0";
73pub const SPA_TYPE_INFO_Control: &[u8; 17] = b"Spa:Enum:Control\0";
74pub const SPA_TYPE_INFO_CONTROL_BASE: &[u8; 18] = b"Spa:Enum:Control:\0";
75pub const SPA_TYPE_INFO_Direction: &[u8; 19] = b"Spa:Enum:Direction\0";
76pub const SPA_TYPE_INFO_DIRECTION_BASE: &[u8; 20] = b"Spa:Enum:Direction:\0";
77pub const SPA_TYPE_INFO_Choice: &[u8; 16] = b"Spa:Enum:Choice\0";
78pub const SPA_TYPE_INFO_CHOICE_BASE: &[u8; 17] = b"Spa:Enum:Choice:\0";
79pub const SPA_TYPE_INFO_DeviceEvent: &[u8; 28] = b"Spa:Pod:Object:Event:Device\0";
80pub const SPA_TYPE_INFO_DEVICE_EVENT_BASE: &[u8; 29] = b"Spa:Pod:Object:Event:Device:\0";
81pub const SPA_TYPE_INFO_DeviceEventId: &[u8; 23] = b"Spa:Enum:DeviceEventId\0";
82pub const SPA_TYPE_INFO_DEVICE_EVENT_ID_BASE: &[u8; 24] = b"Spa:Enum:DeviceEventId:\0";
83pub const SPA_STATUS_OK: u32 = 0;
84pub const SPA_STATUS_NEED_DATA: u32 = 1;
85pub const SPA_STATUS_HAVE_DATA: u32 = 2;
86pub const SPA_STATUS_STOPPED: u32 = 4;
87pub const SPA_STATUS_DRAINED: u32 = 8;
88pub const SPA_IO_CLOCK_FLAG_FREEWHEEL: u32 = 1;
89pub const SPA_IO_CLOCK_FLAG_XRUN_RECOVER: u32 = 2;
90pub const SPA_IO_CLOCK_FLAG_LAZY: u32 = 4;
91pub const SPA_IO_CLOCK_FLAG_NO_RATE: u32 = 8;
92pub const SPA_IO_VIDEO_SIZE_VALID: u32 = 1;
93pub const SPA_IO_SEGMENT_BAR_FLAG_VALID: u32 = 1;
94pub const SPA_IO_SEGMENT_VIDEO_FLAG_VALID: u32 = 1;
95pub const SPA_IO_SEGMENT_VIDEO_FLAG_DROP_FRAME: u32 = 2;
96pub const SPA_IO_SEGMENT_VIDEO_FLAG_PULL_DOWN: u32 = 4;
97pub const SPA_IO_SEGMENT_VIDEO_FLAG_INTERLACED: u32 = 8;
98pub const SPA_IO_SEGMENT_FLAG_LOOPING: u32 = 1;
99pub const SPA_IO_SEGMENT_FLAG_NO_POSITION: u32 = 2;
100pub const SPA_IO_POSITION_MAX_SEGMENTS: u32 = 8;
101pub const SPA_IO_RATE_MATCH_FLAG_ACTIVE: u32 = 1;
102pub const SPA_TYPE_INFO_IO: &[u8; 12] = b"Spa:Enum:IO\0";
103pub const SPA_TYPE_INFO_IO_BASE: &[u8; 13] = b"Spa:Enum:IO:\0";
104pub const SPA_TYPE_INFO_NodeEvent: &[u8; 26] = b"Spa:Pod:Object:Event:Node\0";
105pub const SPA_TYPE_INFO_NODE_EVENT_BASE: &[u8; 27] = b"Spa:Pod:Object:Event:Node:\0";
106pub const SPA_TYPE_INFO_NodeCommand: &[u8; 28] = b"Spa:Pod:Object:Command:Node\0";
107pub const SPA_TYPE_INFO_NODE_COMMAND_BASE: &[u8; 29] = b"Spa:Pod:Object:Command:Node:\0";
108pub const SPA_PARAM_INFO_SERIAL: u32 = 1;
109pub const SPA_PARAM_INFO_READ: u32 = 2;
110pub const SPA_PARAM_INFO_WRITE: u32 = 4;
111pub const SPA_PARAM_INFO_READWRITE: u32 = 6;
112pub const SPA_KEY_FORMAT_DSP: &[u8; 11] = b"format.dsp\0";
113pub const SPA_TYPE_INFO_ParamId: &[u8; 17] = b"Spa:Enum:ParamId\0";
114pub const SPA_TYPE_INFO_PARAM_ID_BASE: &[u8; 18] = b"Spa:Enum:ParamId:\0";
115pub const SPA_TYPE_INFO_Param: &[u8; 21] = b"Spa:Pod:Object:Param\0";
116pub const SPA_TYPE_INFO_PARAM_BASE: &[u8; 22] = b"Spa:Pod:Object:Param:\0";
117pub const SPA_AUDIO_MAX_CHANNELS: u32 = 64;
118pub const SPA_AUDIO_FLAG_NONE: u32 = 0;
119pub const SPA_AUDIO_FLAG_UNPOSITIONED: u32 = 1;
120pub const SPA_KEY_AUDIO_FORMAT: &[u8; 13] = b"audio.format\0";
121pub const SPA_KEY_AUDIO_CHANNEL: &[u8; 14] = b"audio.channel\0";
122pub const SPA_KEY_AUDIO_CHANNELS: &[u8; 15] = b"audio.channels\0";
123pub const SPA_KEY_AUDIO_RATE: &[u8; 11] = b"audio.rate\0";
124pub const SPA_KEY_AUDIO_POSITION: &[u8; 15] = b"audio.position\0";
125pub const SPA_KEY_AUDIO_ALLOWED_RATES: &[u8; 20] = b"audio.allowed-rates\0";
126pub const SPA_TYPE_INFO_AudioFormat: &[u8; 21] = b"Spa:Enum:AudioFormat\0";
127pub const SPA_TYPE_INFO_AUDIO_FORMAT_BASE: &[u8; 22] = b"Spa:Enum:AudioFormat:\0";
128pub const SPA_TYPE_INFO_AudioFlags: &[u8; 21] = b"Spa:Flags:AudioFlags\0";
129pub const SPA_TYPE_INFO_AUDIO_FLAGS_BASE: &[u8; 22] = b"Spa:Flags:AudioFlags:\0";
130pub const SPA_TYPE_INFO_AudioChannel: &[u8; 22] = b"Spa:Enum:AudioChannel\0";
131pub const SPA_TYPE_INFO_AUDIO_CHANNEL_BASE: &[u8; 23] = b"Spa:Enum:AudioChannel:\0";
132pub const SPA_TYPE_INFO_AudioVolumeRampScale: &[u8; 30] = b"Spa:Enum:AudioVolumeRampScale\0";
133pub const SPA_TYPE_INFO_AUDIO_VOLUME_RAMP_SCALE_BASE: &[u8; 31] =
134 b"Spa:Enum:AudioVolumeRampScale:\0";
135pub const SPA_TYPE_INFO_AudioIEC958Codec: &[u8; 26] = b"Spa:Enum:AudioIEC958Codec\0";
136pub const SPA_TYPE_INFO_AUDIO_IEC958_CODEC_BASE: &[u8; 27] = b"Spa:Enum:AudioIEC958Codec:\0";
137pub const SPA_TYPE_INFO_AudioMP3ChannelMode: &[u8; 29] = b"Spa:Enum:AudioMP3ChannelMode\0";
138pub const SPA_TYPE_INFO_AUDIO_MP3_CHANNEL_MODE_BASE: &[u8; 30] = b"Spa:Enum:AudioMP3ChannelMode:\0";
139pub const SPA_TYPE_INFO_AudioAACStreamFormat: &[u8; 30] = b"Spa:Enum:AudioAACStreamFormat\0";
140pub const SPA_TYPE_INFO_AUDIO_AAC_STREAM_FORMAT_BASE: &[u8; 31] =
141 b"Spa:Enum:AudioAACStreamFormat:\0";
142pub const SPA_TYPE_INFO_AudioWMAProfile: &[u8; 25] = b"Spa:Enum:AudioWMAProfile\0";
143pub const SPA_TYPE_INFO_AUDIO_WMA_PROFILE_BASE: &[u8; 26] = b"Spa:Enum:AudioWMAProfile:\0";
144pub const SPA_TYPE_INFO_AudioAMRBandMode: &[u8; 26] = b"Spa:Enum:AudioAMRBandMode\0";
145pub const SPA_TYPE_INFO_AUDIO_AMR_BAND_MODE_BASE: &[u8; 27] = b"Spa:Enum:AudioAMRBandMode:\0";
146pub const SPA_TYPE_INFO_ParamBitorder: &[u8; 23] = b"Spa:Enum:ParamBitorder\0";
147pub const SPA_TYPE_INFO_PARAM_BITORDER_BASE: &[u8; 24] = b"Spa:Enum:ParamBitorder:\0";
148pub const SPA_TYPE_INFO_ParamAvailability: &[u8; 27] = b"Spa:Enum:ParamAvailability\0";
149pub const SPA_TYPE_INFO_PARAM_AVAILABILITY_BASE: &[u8; 28] = b"Spa:Enum:ParamAvailability:\0";
150pub const SPA_TYPE_INFO_PARAM_Meta: &[u8; 26] = b"Spa:Pod:Object:Param:Meta\0";
151pub const SPA_TYPE_INFO_PARAM_META_BASE: &[u8; 27] = b"Spa:Pod:Object:Param:Meta:\0";
152pub const SPA_TYPE_INFO_PARAM_IO: &[u8; 24] = b"Spa:Pod:Object:Param:IO\0";
153pub const SPA_TYPE_INFO_PARAM_IO_BASE: &[u8; 25] = b"Spa:Pod:Object:Param:IO:\0";
154pub const SPA_TYPE_INFO_PARAM_Buffers: &[u8; 29] = b"Spa:Pod:Object:Param:Buffers\0";
155pub const SPA_TYPE_INFO_PARAM_BUFFERS_BASE: &[u8; 30] = b"Spa:Pod:Object:Param:Buffers:\0";
156pub const SPA_TYPE_INFO_PARAM_BlockInfo: &[u8; 39] = b"Spa:Pod:Object:Param:Buffers:BlockInfo\0";
157pub const SPA_TYPE_INFO_PARAM_BLOCK_INFO_BASE: &[u8; 40] =
158 b"Spa:Pod:Object:Param:Buffers:BlockInfo:\0";
159pub const SPA_TYPE_INFO_BluetoothAudioCodec: &[u8; 29] = b"Spa:Enum:BluetoothAudioCodec\0";
160pub const SPA_TYPE_INFO_BLUETOOTH_AUDIO_CODEC_BASE: &[u8; 30] = b"Spa:Enum:BluetoothAudioCodec:\0";
161pub const SPA_TYPE_INFO_Props: &[u8; 27] = b"Spa:Pod:Object:Param:Props\0";
162pub const SPA_TYPE_INFO_PROPS_BASE: &[u8; 28] = b"Spa:Pod:Object:Param:Props:\0";
163pub const SPA_TYPE_INFO_PropInfo: &[u8; 30] = b"Spa:Pod:Object:Param:PropInfo\0";
164pub const SPA_TYPE_INFO_PROP_INFO_BASE: &[u8; 31] = b"Spa:Pod:Object:Param:PropInfo:\0";
165pub const SPA_VIDEO_MAX_PLANES: u32 = 4;
166pub const SPA_VIDEO_MAX_COMPONENTS: u32 = 4;
167pub const SPA_TYPE_INFO_VideoFormat: &[u8; 21] = b"Spa:Enum:VideoFormat\0";
168pub const SPA_TYPE_INFO_VIDEO_FORMAT_BASE: &[u8; 22] = b"Spa:Enum:VideoFormat:\0";
169pub const SPA_TYPE_INFO_VideoFlags: &[u8; 21] = b"Spa:Flags:VideoFlags\0";
170pub const SPA_TYPE_INFO_VIDEO_FLAGS_BASE: &[u8; 22] = b"Spa:Flags:VideoFlags:\0";
171pub const SPA_TYPE_INFO_VideoInterlaceMode: &[u8; 28] = b"Spa:Enum:VideoInterlaceMode\0";
172pub const SPA_TYPE_INFO_VIDEO_INTERLACE_MODE_BASE: &[u8; 29] = b"Spa:Enum:VideoInterlaceMode:\0";
173pub const SPA_TYPE_INFO_Format: &[u8; 28] = b"Spa:Pod:Object:Param:Format\0";
174pub const SPA_TYPE_INFO_FORMAT_BASE: &[u8; 29] = b"Spa:Pod:Object:Param:Format:\0";
175pub const SPA_TYPE_INFO_MediaType: &[u8; 19] = b"Spa:Enum:MediaType\0";
176pub const SPA_TYPE_INFO_MEDIA_TYPE_BASE: &[u8; 20] = b"Spa:Enum:MediaType:\0";
177pub const SPA_TYPE_INFO_MediaSubtype: &[u8; 22] = b"Spa:Enum:MediaSubtype\0";
178pub const SPA_TYPE_INFO_MEDIA_SUBTYPE_BASE: &[u8; 23] = b"Spa:Enum:MediaSubtype:\0";
179pub const SPA_TYPE_INFO_FormatAudio: &[u8; 34] = b"Spa:Pod:Object:Param:Format:Audio\0";
180pub const SPA_TYPE_INFO_FORMAT_AUDIO_BASE: &[u8; 35] = b"Spa:Pod:Object:Param:Format:Audio:\0";
181pub const SPA_TYPE_INFO_FORMAT_AUDIO_AAC: &[u8; 38] = b"Spa:Pod:Object:Param:Format:Audio:AAC\0";
182pub const SPA_TYPE_INFO_FORMAT_AUDIO_AAC_BASE: &[u8; 39] =
183 b"Spa:Pod:Object:Param:Format:Audio:AAC:\0";
184pub const SPA_TYPE_INFO_FORMAT_AUDIO_WMA: &[u8; 38] = b"Spa:Pod:Object:Param:Format:Audio:WMA\0";
185pub const SPA_TYPE_INFO_FORMAT_AUDIO_WMA_BASE: &[u8; 39] =
186 b"Spa:Pod:Object:Param:Format:Audio:WMA:\0";
187pub const SPA_TYPE_INFO_FORMAT_AUDIO_AMR: &[u8; 38] = b"Spa:Pod:Object:Param:Format:Audio:AMR\0";
188pub const SPA_TYPE_INFO_FORMAT_AUDIO_AMR_BASE: &[u8; 39] =
189 b"Spa:Pod:Object:Param:Format:Audio:AMR:\0";
190pub const SPA_TYPE_INFO_FormatVideo: &[u8; 34] = b"Spa:Pod:Object:Param:Format:Video\0";
191pub const SPA_TYPE_INFO_FORMAT_VIDEO_BASE: &[u8; 35] = b"Spa:Pod:Object:Param:Format:Video:\0";
192pub const SPA_TYPE_INFO_FORMAT_VIDEO_H264: &[u8; 39] = b"Spa:Pod:Object:Param:Format:Video:H264\0";
193pub const SPA_TYPE_INFO_FORMAT_VIDEO_H264_BASE: &[u8; 40] =
194 b"Spa:Pod:Object:Param:Format:Video:H264:\0";
195pub const SPA_TYPE_INFO_FormatControl: &[u8; 36] = b"Spa:Pod:Object:Param:Format:Control\0";
196pub const SPA_TYPE_INFO_FORMAT_CONTROL_BASE: &[u8; 37] = b"Spa:Pod:Object:Param:Format:Control:\0";
197pub const SPA_TYPE_INFO_PARAM_Latency: &[u8; 29] = b"Spa:Pod:Object:Param:Latency\0";
198pub const SPA_TYPE_INFO_PARAM_LATENCY_BASE: &[u8; 30] = b"Spa:Pod:Object:Param:Latency:\0";
199pub const SPA_TYPE_INFO_PARAM_ProcessLatency: &[u8; 36] = b"Spa:Pod:Object:Param:ProcessLatency\0";
200pub const SPA_TYPE_INFO_PARAM_PROCESS_LATENCY_BASE: &[u8; 37] =
201 b"Spa:Pod:Object:Param:ProcessLatency:\0";
202pub const SPA_TYPE_INFO_ParamPortConfigMode: &[u8; 29] = b"Spa:Enum:ParamPortConfigMode\0";
203pub const SPA_TYPE_INFO_PARAM_PORT_CONFIG_MODE_BASE: &[u8; 30] = b"Spa:Enum:ParamPortConfigMode:\0";
204pub const SPA_TYPE_INFO_PARAM_PortConfig: &[u8; 32] = b"Spa:Pod:Object:Param:PortConfig\0";
205pub const SPA_TYPE_INFO_PARAM_PORT_CONFIG_BASE: &[u8; 33] = b"Spa:Pod:Object:Param:PortConfig:\0";
206pub const SPA_TYPE_INFO_Profiler: &[u8; 24] = b"Spa:Pod:Object:Profiler\0";
207pub const SPA_TYPE_INFO_PROFILER_BASE: &[u8; 25] = b"Spa:Pod:Object:Profiler:\0";
208pub const SPA_TYPE_INFO_PARAM_Profile: &[u8; 29] = b"Spa:Pod:Object:Param:Profile\0";
209pub const SPA_TYPE_INFO_PARAM_PROFILE_BASE: &[u8; 30] = b"Spa:Pod:Object:Param:Profile:\0";
210pub const SPA_TYPE_INFO_PARAM_Route: &[u8; 27] = b"Spa:Pod:Object:Param:Route\0";
211pub const SPA_TYPE_INFO_PARAM_ROUTE_BASE: &[u8; 28] = b"Spa:Pod:Object:Param:Route:\0";
212pub const SPA_TYPE_INFO_PARAM_Tag: &[u8; 25] = b"Spa:Pod:Object:Param:Tag\0";
213pub const SPA_TYPE_INFO_PARAM_TAG_BASE: &[u8; 26] = b"Spa:Pod:Object:Param:Tag:\0";
214pub const SPA_DICT_FLAG_SORTED: u32 = 1;
215pub const SPA_TYPE_INTERFACE_Node: &[u8; 27] = b"Spa:Pointer:Interface:Node\0";
216pub const SPA_VERSION_NODE: u32 = 0;
217pub const SPA_NODE_CHANGE_MASK_FLAGS: u32 = 1;
218pub const SPA_NODE_CHANGE_MASK_PROPS: u32 = 2;
219pub const SPA_NODE_CHANGE_MASK_PARAMS: u32 = 4;
220pub const SPA_NODE_FLAG_RT: u32 = 1;
221pub const SPA_NODE_FLAG_IN_DYNAMIC_PORTS: u32 = 2;
222pub const SPA_NODE_FLAG_OUT_DYNAMIC_PORTS: u32 = 4;
223pub const SPA_NODE_FLAG_IN_PORT_CONFIG: u32 = 8;
224pub const SPA_NODE_FLAG_OUT_PORT_CONFIG: u32 = 16;
225pub const SPA_NODE_FLAG_NEED_CONFIGURE: u32 = 32;
226pub const SPA_NODE_FLAG_ASYNC: u32 = 64;
227pub const SPA_PORT_CHANGE_MASK_FLAGS: u32 = 1;
228pub const SPA_PORT_CHANGE_MASK_RATE: u32 = 2;
229pub const SPA_PORT_CHANGE_MASK_PROPS: u32 = 4;
230pub const SPA_PORT_CHANGE_MASK_PARAMS: u32 = 8;
231pub const SPA_PORT_FLAG_REMOVABLE: u32 = 1;
232pub const SPA_PORT_FLAG_OPTIONAL: u32 = 2;
233pub const SPA_PORT_FLAG_CAN_ALLOC_BUFFERS: u32 = 4;
234pub const SPA_PORT_FLAG_IN_PLACE: u32 = 8;
235pub const SPA_PORT_FLAG_NO_REF: u32 = 16;
236pub const SPA_PORT_FLAG_LIVE: u32 = 32;
237pub const SPA_PORT_FLAG_PHYSICAL: u32 = 64;
238pub const SPA_PORT_FLAG_TERMINAL: u32 = 128;
239pub const SPA_PORT_FLAG_DYNAMIC_DATA: u32 = 256;
240pub const SPA_RESULT_TYPE_NODE_ERROR: u32 = 1;
241pub const SPA_RESULT_TYPE_NODE_PARAMS: u32 = 2;
242pub const SPA_NODE_EVENT_INFO: u32 = 0;
243pub const SPA_NODE_EVENT_PORT_INFO: u32 = 1;
244pub const SPA_NODE_EVENT_RESULT: u32 = 2;
245pub const SPA_NODE_EVENT_EVENT: u32 = 3;
246pub const SPA_NODE_EVENT_NUM: u32 = 4;
247pub const SPA_VERSION_NODE_EVENTS: u32 = 0;
248pub const SPA_NODE_CALLBACK_READY: u32 = 0;
249pub const SPA_NODE_CALLBACK_REUSE_BUFFER: u32 = 1;
250pub const SPA_NODE_CALLBACK_XRUN: u32 = 2;
251pub const SPA_NODE_CALLBACK_NUM: u32 = 3;
252pub const SPA_VERSION_NODE_CALLBACKS: u32 = 0;
253pub const SPA_NODE_PARAM_FLAG_TEST_ONLY: u32 = 1;
254pub const SPA_NODE_PARAM_FLAG_FIXATE: u32 = 2;
255pub const SPA_NODE_PARAM_FLAG_NEAREST: u32 = 4;
256pub const SPA_NODE_BUFFERS_FLAG_ALLOC: u32 = 1;
257pub const SPA_NODE_METHOD_ADD_LISTENER: u32 = 0;
258pub const SPA_NODE_METHOD_SET_CALLBACKS: u32 = 1;
259pub const SPA_NODE_METHOD_SYNC: u32 = 2;
260pub const SPA_NODE_METHOD_ENUM_PARAMS: u32 = 3;
261pub const SPA_NODE_METHOD_SET_PARAM: u32 = 4;
262pub const SPA_NODE_METHOD_SET_IO: u32 = 5;
263pub const SPA_NODE_METHOD_SEND_COMMAND: u32 = 6;
264pub const SPA_NODE_METHOD_ADD_PORT: u32 = 7;
265pub const SPA_NODE_METHOD_REMOVE_PORT: u32 = 8;
266pub const SPA_NODE_METHOD_PORT_ENUM_PARAMS: u32 = 9;
267pub const SPA_NODE_METHOD_PORT_SET_PARAM: u32 = 10;
268pub const SPA_NODE_METHOD_PORT_USE_BUFFERS: u32 = 11;
269pub const SPA_NODE_METHOD_PORT_SET_IO: u32 = 12;
270pub const SPA_NODE_METHOD_PORT_REUSE_BUFFER: u32 = 13;
271pub const SPA_NODE_METHOD_PROCESS: u32 = 14;
272pub const SPA_NODE_METHOD_NUM: u32 = 15;
273pub const SPA_VERSION_NODE_METHODS: u32 = 0;
274pub const SPA_VERSION_GRAPH_NODE_CALLBACKS: u32 = 0;
275pub const SPA_TYPE_INTERFACE_Device: &[u8; 29] = b"Spa:Pointer:Interface:Device\0";
276pub const SPA_VERSION_DEVICE: u32 = 0;
277pub const SPA_VERSION_DEVICE_INFO: u32 = 0;
278pub const SPA_DEVICE_CHANGE_MASK_FLAGS: u32 = 1;
279pub const SPA_DEVICE_CHANGE_MASK_PROPS: u32 = 2;
280pub const SPA_DEVICE_CHANGE_MASK_PARAMS: u32 = 4;
281pub const SPA_VERSION_DEVICE_OBJECT_INFO: u32 = 0;
282pub const SPA_DEVICE_OBJECT_CHANGE_MASK_FLAGS: u32 = 1;
283pub const SPA_DEVICE_OBJECT_CHANGE_MASK_PROPS: u32 = 2;
284pub const SPA_RESULT_TYPE_DEVICE_PARAMS: u32 = 1;
285pub const SPA_DEVICE_EVENT_INFO: u32 = 0;
286pub const SPA_DEVICE_EVENT_RESULT: u32 = 1;
287pub const SPA_DEVICE_EVENT_EVENT: u32 = 2;
288pub const SPA_DEVICE_EVENT_OBJECT_INFO: u32 = 3;
289pub const SPA_DEVICE_EVENT_NUM: u32 = 4;
290pub const SPA_VERSION_DEVICE_EVENTS: u32 = 0;
291pub const SPA_DEVICE_METHOD_ADD_LISTENER: u32 = 0;
292pub const SPA_DEVICE_METHOD_SYNC: u32 = 1;
293pub const SPA_DEVICE_METHOD_ENUM_PARAMS: u32 = 2;
294pub const SPA_DEVICE_METHOD_SET_PARAM: u32 = 3;
295pub const SPA_DEVICE_METHOD_NUM: u32 = 4;
296pub const SPA_VERSION_DEVICE_METHODS: u32 = 0;
297pub const SPA_KEY_DEVICE_ENUM_API: &[u8; 16] = b"device.enum.api\0";
298pub const SPA_KEY_DEVICE_API: &[u8; 11] = b"device.api\0";
299pub const SPA_KEY_DEVICE_NAME: &[u8; 12] = b"device.name\0";
300pub const SPA_KEY_DEVICE_ALIAS: &[u8; 13] = b"device.alias\0";
301pub const SPA_KEY_DEVICE_NICK: &[u8; 12] = b"device.nick\0";
302pub const SPA_KEY_DEVICE_DESCRIPTION: &[u8; 19] = b"device.description\0";
303pub const SPA_KEY_DEVICE_ICON: &[u8; 12] = b"device.icon\0";
304pub const SPA_KEY_DEVICE_ICON_NAME: &[u8; 17] = b"device.icon-name\0";
305pub const SPA_KEY_DEVICE_PLUGGED_USEC: &[u8; 20] = b"device.plugged.usec\0";
306pub const SPA_KEY_DEVICE_BUS_ID: &[u8; 14] = b"device.bus-id\0";
307pub const SPA_KEY_DEVICE_BUS_PATH: &[u8; 16] = b"device.bus-path\0";
308pub const SPA_KEY_DEVICE_BUS: &[u8; 11] = b"device.bus\0";
309pub const SPA_KEY_DEVICE_SUBSYSTEM: &[u8; 17] = b"device.subsystem\0";
310pub const SPA_KEY_DEVICE_SYSFS_PATH: &[u8; 18] = b"device.sysfs.path\0";
311pub const SPA_KEY_DEVICE_VENDOR_ID: &[u8; 17] = b"device.vendor.id\0";
312pub const SPA_KEY_DEVICE_VENDOR_NAME: &[u8; 19] = b"device.vendor.name\0";
313pub const SPA_KEY_DEVICE_PRODUCT_ID: &[u8; 18] = b"device.product.id\0";
314pub const SPA_KEY_DEVICE_PRODUCT_NAME: &[u8; 20] = b"device.product.name\0";
315pub const SPA_KEY_DEVICE_SERIAL: &[u8; 14] = b"device.serial\0";
316pub const SPA_KEY_DEVICE_CLASS: &[u8; 13] = b"device.class\0";
317pub const SPA_KEY_DEVICE_CAPABILITIES: &[u8; 20] = b"device.capabilities\0";
318pub const SPA_KEY_DEVICE_FORM_FACTOR: &[u8; 19] = b"device.form-factor\0";
319pub const SPA_KEY_DEVICE_PROFILE: &[u8; 15] = b"device.profile\0";
320pub const SPA_KEY_DEVICE_PROFILE_SET: &[u8; 19] = b"device.profile-set\0";
321pub const SPA_KEY_DEVICE_STRING: &[u8; 14] = b"device.string\0";
322pub const SPA_KEY_DEVICE_DEVIDS: &[u8; 14] = b"device.devids\0";
323pub const SPA_POD_BUILDER_FLAG_BODY: u32 = 1;
324pub const SPA_POD_BUILDER_FLAG_FIRST: u32 = 2;
325pub const SPA_VERSION_POD_BUILDER_CALLBACKS: u32 = 0;
326pub const SPA_KEY_NODE_NAME: &[u8; 10] = b"node.name\0";
327pub const SPA_KEY_NODE_DESCRIPTION: &[u8; 17] = b"node.description\0";
328pub const SPA_KEY_NODE_LATENCY: &[u8; 13] = b"node.latency\0";
329pub const SPA_KEY_NODE_MAX_LATENCY: &[u8; 17] = b"node.max-latency\0";
330pub const SPA_KEY_NODE_DRIVER: &[u8; 12] = b"node.driver\0";
331pub const SPA_KEY_NODE_ALWAYS_PROCESS: &[u8; 20] = b"node.always-process\0";
332pub const SPA_KEY_NODE_PAUSE_ON_IDLE: &[u8; 19] = b"node.pause-on-idle\0";
333pub const SPA_KEY_NODE_MONITOR: &[u8; 13] = b"node.monitor\0";
334pub const SPA_KEY_PORT_NAME: &[u8; 10] = b"port.name\0";
335pub const SPA_KEY_PORT_ALIAS: &[u8; 11] = b"port.alias\0";
336pub const SPA_KEY_PORT_MONITOR: &[u8; 13] = b"port.monitor\0";
337pub const SPA_KEY_PORT_IGNORE_LATENCY: &[u8; 20] = b"port.ignore-latency\0";
338pub const SPA_KEY_PORT_GROUP: &[u8; 11] = b"port.group\0";
339pub const SPA_AUDIO_DSD_FLAG_NONE: u32 = 0;
340pub const SPA_TYPE_INTERFACE_CPU: &[u8; 26] = b"Spa:Pointer:Interface:CPU\0";
341pub const SPA_VERSION_CPU: u32 = 0;
342pub const SPA_CPU_FLAG_MMX: u32 = 1;
343pub const SPA_CPU_FLAG_MMXEXT: u32 = 2;
344pub const SPA_CPU_FLAG_3DNOW: u32 = 4;
345pub const SPA_CPU_FLAG_SSE: u32 = 8;
346pub const SPA_CPU_FLAG_SSE2: u32 = 16;
347pub const SPA_CPU_FLAG_3DNOWEXT: u32 = 32;
348pub const SPA_CPU_FLAG_SSE3: u32 = 64;
349pub const SPA_CPU_FLAG_SSSE3: u32 = 128;
350pub const SPA_CPU_FLAG_SSE41: u32 = 256;
351pub const SPA_CPU_FLAG_SSE42: u32 = 512;
352pub const SPA_CPU_FLAG_AESNI: u32 = 1024;
353pub const SPA_CPU_FLAG_AVX: u32 = 2048;
354pub const SPA_CPU_FLAG_XOP: u32 = 4096;
355pub const SPA_CPU_FLAG_FMA4: u32 = 8192;
356pub const SPA_CPU_FLAG_CMOV: u32 = 16384;
357pub const SPA_CPU_FLAG_AVX2: u32 = 32768;
358pub const SPA_CPU_FLAG_FMA3: u32 = 65536;
359pub const SPA_CPU_FLAG_BMI1: u32 = 131072;
360pub const SPA_CPU_FLAG_BMI2: u32 = 262144;
361pub const SPA_CPU_FLAG_AVX512: u32 = 524288;
362pub const SPA_CPU_FLAG_SLOW_UNALIGNED: u32 = 1048576;
363pub const SPA_CPU_FLAG_ALTIVEC: u32 = 1;
364pub const SPA_CPU_FLAG_VSX: u32 = 2;
365pub const SPA_CPU_FLAG_POWER8: u32 = 4;
366pub const SPA_CPU_FLAG_ARMV5TE: u32 = 1;
367pub const SPA_CPU_FLAG_ARMV6: u32 = 2;
368pub const SPA_CPU_FLAG_ARMV6T2: u32 = 4;
369pub const SPA_CPU_FLAG_VFP: u32 = 8;
370pub const SPA_CPU_FLAG_VFPV3: u32 = 16;
371pub const SPA_CPU_FLAG_NEON: u32 = 32;
372pub const SPA_CPU_FLAG_ARMV8: u32 = 64;
373pub const SPA_CPU_FLAG_RISCV_V: u32 = 1;
374pub const SPA_CPU_FORCE_AUTODETECT: u32 = 4294967295;
375pub const SPA_CPU_VM_NONE: u32 = 0;
376pub const SPA_CPU_VM_OTHER: u32 = 1;
377pub const SPA_CPU_VM_KVM: u32 = 2;
378pub const SPA_CPU_VM_QEMU: u32 = 4;
379pub const SPA_CPU_VM_BOCHS: u32 = 8;
380pub const SPA_CPU_VM_XEN: u32 = 16;
381pub const SPA_CPU_VM_UML: u32 = 32;
382pub const SPA_CPU_VM_VMWARE: u32 = 64;
383pub const SPA_CPU_VM_ORACLE: u32 = 128;
384pub const SPA_CPU_VM_MICROSOFT: u32 = 256;
385pub const SPA_CPU_VM_ZVM: u32 = 512;
386pub const SPA_CPU_VM_PARALLELS: u32 = 1024;
387pub const SPA_CPU_VM_BHYVE: u32 = 2048;
388pub const SPA_CPU_VM_QNX: u32 = 4096;
389pub const SPA_CPU_VM_ACRN: u32 = 8192;
390pub const SPA_CPU_VM_POWERVM: u32 = 16384;
391pub const SPA_VERSION_CPU_METHODS: u32 = 2;
392pub const SPA_KEY_CPU_FORCE: &[u8; 10] = b"cpu.force\0";
393pub const SPA_KEY_CPU_VM_TYPE: &[u8; 12] = b"cpu.vm.type\0";
394pub const SPA_KEY_CPU_ZERO_DENORMALS: &[u8; 19] = b"cpu.zero.denormals\0";
395pub const SPA_TYPE_INTERFACE_System: &[u8; 29] = b"Spa:Pointer:Interface:System\0";
396pub const SPA_TYPE_INTERFACE_DataSystem: &[u8; 33] = b"Spa:Pointer:Interface:DataSystem\0";
397pub const SPA_VERSION_SYSTEM: u32 = 0;
398pub const SPA_IO_IN: u32 = 1;
399pub const SPA_IO_OUT: u32 = 4;
400pub const SPA_IO_ERR: u32 = 8;
401pub const SPA_IO_HUP: u32 = 16;
402pub const SPA_FD_CLOEXEC: u32 = 1;
403pub const SPA_FD_NONBLOCK: u32 = 2;
404pub const SPA_FD_EVENT_SEMAPHORE: u32 = 4;
405pub const SPA_FD_TIMER_ABSTIME: u32 = 8;
406pub const SPA_FD_TIMER_CANCEL_ON_SET: u32 = 16;
407pub const SPA_VERSION_SYSTEM_METHODS: u32 = 0;
408pub const SPA_TYPE_INTERFACE_Loop: &[u8; 27] = b"Spa:Pointer:Interface:Loop\0";
409pub const SPA_TYPE_INTERFACE_DataLoop: &[u8; 31] = b"Spa:Pointer:Interface:DataLoop\0";
410pub const SPA_VERSION_LOOP: u32 = 0;
411pub const SPA_TYPE_INTERFACE_LoopControl: &[u8; 34] = b"Spa:Pointer:Interface:LoopControl\0";
412pub const SPA_VERSION_LOOP_CONTROL: u32 = 1;
413pub const SPA_TYPE_INTERFACE_LoopUtils: &[u8; 32] = b"Spa:Pointer:Interface:LoopUtils\0";
414pub const SPA_VERSION_LOOP_UTILS: u32 = 0;
415pub const SPA_VERSION_LOOP_METHODS: u32 = 0;
416pub const SPA_VERSION_LOOP_CONTROL_HOOKS: u32 = 0;
417pub const SPA_VERSION_LOOP_CONTROL_METHODS: u32 = 1;
418pub const SPA_VERSION_LOOP_UTILS_METHODS: u32 = 0;
419pub const SPA_TYPE_INTERFACE_DBus: &[u8; 27] = b"Spa:Pointer:Interface:DBus\0";
420pub const SPA_VERSION_DBUS: u32 = 0;
421pub const SPA_DBUS_CONNECTION_EVENT_DESTROY: u32 = 0;
422pub const SPA_DBUS_CONNECTION_EVENT_DISCONNECTED: u32 = 1;
423pub const SPA_DBUS_CONNECTION_EVENT_NUM: u32 = 2;
424pub const SPA_VERSION_DBUS_CONNECTION_EVENTS: u32 = 0;
425pub const SPA_VERSION_DBUS_CONNECTION: u32 = 1;
426pub const SPA_VERSION_DBUS_METHODS: u32 = 0;
427pub const SPA_TYPE_INTERFACE_I18N: &[u8; 27] = b"Spa:Pointer:Interface:I18N\0";
428pub const SPA_VERSION_I18N: u32 = 0;
429pub const SPA_VERSION_I18N_METHODS: u32 = 0;
430pub const SPA_TYPE_INTERFACE_Log: &[u8; 26] = b"Spa:Pointer:Interface:Log\0";
431pub const SPA_VERSION_LOG: u32 = 0;
432pub const SPA_VERSION_LOG_TOPIC: u32 = 0;
433pub const SPA_VERSION_LOG_TOPIC_ENUM: u32 = 0;
434pub const SPA_VERSION_LOG_METHODS: u32 = 1;
435pub const SPA_LOG_TOPIC_ENUM_NAME: &[u8; 19] = b"spa_log_topic_enum\0";
436pub const SPA_KEY_LOG_LEVEL: &[u8; 10] = b"log.level\0";
437pub const SPA_KEY_LOG_COLORS: &[u8; 11] = b"log.colors\0";
438pub const SPA_KEY_LOG_FILE: &[u8; 9] = b"log.file\0";
439pub const SPA_KEY_LOG_TIMESTAMP: &[u8; 14] = b"log.timestamp\0";
440pub const SPA_KEY_LOG_LINE: &[u8; 9] = b"log.line\0";
441pub const SPA_KEY_LOG_PATTERNS: &[u8; 13] = b"log.patterns\0";
442pub const SPA_TYPE_INTERFACE_PluginLoader: &[u8; 35] = b"Spa:Pointer:Interface:PluginLoader\0";
443pub const SPA_VERSION_PLUGIN_LOADER: u32 = 0;
444pub const SPA_VERSION_PLUGIN_LOADER_METHODS: u32 = 0;
445pub const SPA_VERSION_HANDLE: u32 = 0;
446pub const SPA_VERSION_HANDLE_FACTORY: u32 = 1;
447pub const SPA_HANDLE_FACTORY_ENUM_FUNC_NAME: &[u8; 24] = b"spa_handle_factory_enum\0";
448pub const SPA_KEY_FACTORY_NAME: &[u8; 13] = b"factory.name\0";
449pub const SPA_KEY_FACTORY_AUTHOR: &[u8; 15] = b"factory.author\0";
450pub const SPA_KEY_FACTORY_DESCRIPTION: &[u8; 20] = b"factory.description\0";
451pub const SPA_KEY_FACTORY_USAGE: &[u8; 14] = b"factory.usage\0";
452pub const SPA_KEY_LIBRARY_NAME: &[u8; 13] = b"library.name\0";
453pub const SPA_TYPE_INFO_Thread: &[u8; 19] = b"Spa:Pointer:Thread\0";
454pub const SPA_TYPE_INTERFACE_ThreadUtils: &[u8; 34] = b"Spa:Pointer:Interface:ThreadUtils\0";
455pub const SPA_VERSION_THREAD_UTILS: u32 = 0;
456pub const SPA_VERSION_THREAD_UTILS_METHODS: u32 = 0;
457pub const SPA_KEY_THREAD_NAME: &[u8; 12] = b"thread.name\0";
458pub const SPA_KEY_THREAD_STACK_SIZE: &[u8; 18] = b"thread.stack-size\0";
459pub const SPA_KEY_THREAD_AFFINITY: &[u8; 16] = b"thread.affinity\0";
460pub const SPA_KEY_THREAD_CREATOR: &[u8; 15] = b"thread.creator\0";
461pub const SPA_ANSI_RESET: &[u8; 5] = b"\x1B[0m\0";
462pub const SPA_ANSI_BOLD: &[u8; 5] = b"\x1B[1m\0";
463pub const SPA_ANSI_ITALIC: &[u8; 5] = b"\x1B[3m\0";
464pub const SPA_ANSI_UNDERLINE: &[u8; 5] = b"\x1B[4m\0";
465pub const SPA_ANSI_BLACK: &[u8; 8] = b"\x1B[0;30m\0";
466pub const SPA_ANSI_RED: &[u8; 8] = b"\x1B[0;31m\0";
467pub const SPA_ANSI_GREEN: &[u8; 8] = b"\x1B[0;32m\0";
468pub const SPA_ANSI_YELLOW: &[u8; 8] = b"\x1B[0;33m\0";
469pub const SPA_ANSI_BLUE: &[u8; 8] = b"\x1B[0;34m\0";
470pub const SPA_ANSI_MAGENTA: &[u8; 8] = b"\x1B[0;35m\0";
471pub const SPA_ANSI_CYAN: &[u8; 8] = b"\x1B[0;36m\0";
472pub const SPA_ANSI_WHITE: &[u8; 8] = b"\x1B[0;37m\0";
473pub const SPA_ANSI_BRIGHT_BLACK: &[u8; 6] = b"\x1B[90m\0";
474pub const SPA_ANSI_BRIGHT_RED: &[u8; 6] = b"\x1B[91m\0";
475pub const SPA_ANSI_BRIGHT_GREEN: &[u8; 6] = b"\x1B[92m\0";
476pub const SPA_ANSI_BRIGHT_YELLOW: &[u8; 6] = b"\x1B[93m\0";
477pub const SPA_ANSI_BRIGHT_BLUE: &[u8; 6] = b"\x1B[94m\0";
478pub const SPA_ANSI_BRIGHT_MAGENTA: &[u8; 6] = b"\x1B[95m\0";
479pub const SPA_ANSI_BRIGHT_CYAN: &[u8; 6] = b"\x1B[96m\0";
480pub const SPA_ANSI_BRIGHT_WHITE: &[u8; 6] = b"\x1B[97m\0";
481pub const SPA_ANSI_BOLD_BLACK: &[u8; 8] = b"\x1B[1;30m\0";
482pub const SPA_ANSI_BOLD_RED: &[u8; 8] = b"\x1B[1;31m\0";
483pub const SPA_ANSI_BOLD_GREEN: &[u8; 8] = b"\x1B[1;32m\0";
484pub const SPA_ANSI_BOLD_YELLOW: &[u8; 8] = b"\x1B[1;33m\0";
485pub const SPA_ANSI_BOLD_BLUE: &[u8; 8] = b"\x1B[1;34m\0";
486pub const SPA_ANSI_BOLD_MAGENTA: &[u8; 8] = b"\x1B[1;35m\0";
487pub const SPA_ANSI_BOLD_CYAN: &[u8; 8] = b"\x1B[1;36m\0";
488pub const SPA_ANSI_BOLD_WHITE: &[u8; 8] = b"\x1B[1;37m\0";
489pub const SPA_ANSI_DARK_BLACK: &[u8; 8] = b"\x1B[2;30m\0";
490pub const SPA_ANSI_DARK_RED: &[u8; 8] = b"\x1B[2;31m\0";
491pub const SPA_ANSI_DARK_GREEN: &[u8; 8] = b"\x1B[2;32m\0";
492pub const SPA_ANSI_DARK_YELLOW: &[u8; 8] = b"\x1B[2;33m\0";
493pub const SPA_ANSI_DARK_BLUE: &[u8; 8] = b"\x1B[2;34m\0";
494pub const SPA_ANSI_DARK_MAGENTA: &[u8; 8] = b"\x1B[2;35m\0";
495pub const SPA_ANSI_DARK_CYAN: &[u8; 8] = b"\x1B[2;36m\0";
496pub const SPA_ANSI_DARK_WHITE: &[u8; 8] = b"\x1B[2;37m\0";
497pub const SPA_ANSI_BG_BLACK: &[u8; 8] = b"\x1B[0;40m\0";
498pub const SPA_ANSI_BG_RED: &[u8; 8] = b"\x1B[0;41m\0";
499pub const SPA_ANSI_BG_GREEN: &[u8; 8] = b"\x1B[0;42m\0";
500pub const SPA_ANSI_BG_YELLOW: &[u8; 8] = b"\x1B[0;43m\0";
501pub const SPA_ANSI_BG_BLUE: &[u8; 8] = b"\x1B[0;44m\0";
502pub const SPA_ANSI_BG_MAGENTA: &[u8; 8] = b"\x1B[0;45m\0";
503pub const SPA_ANSI_BG_CYAN: &[u8; 8] = b"\x1B[0;46m\0";
504pub const SPA_ANSI_BG_WHITE: &[u8; 8] = b"\x1B[0;47m\0";
505pub const SPA_ANSI_BG_BRIGHT_BLACK: &[u8; 7] = b"\x1B[100m\0";
506pub const SPA_ANSI_BG_BRIGHT_RED: &[u8; 7] = b"\x1B[101m\0";
507pub const SPA_ANSI_BG_BRIGHT_GREEN: &[u8; 7] = b"\x1B[102m\0";
508pub const SPA_ANSI_BG_BRIGHT_YELLOW: &[u8; 7] = b"\x1B[103m\0";
509pub const SPA_ANSI_BG_BRIGHT_BLUE: &[u8; 7] = b"\x1B[104m\0";
510pub const SPA_ANSI_BG_BRIGHT_MAGENTA: &[u8; 7] = b"\x1B[105m\0";
511pub const SPA_ANSI_BG_BRIGHT_CYAN: &[u8; 7] = b"\x1B[106m\0";
512pub const SPA_ANSI_BG_BRIGHT_WHITE: &[u8; 7] = b"\x1B[107m\0";
513pub const SPA_JSON_ERROR_FLAG: u32 = 256;
514pub const SPA_KEY_OBJECT_PATH: &[u8; 12] = b"object.path\0";
515pub const SPA_KEY_MEDIA_CLASS: &[u8; 12] = b"media.class\0";
516pub const SPA_KEY_MEDIA_ROLE: &[u8; 11] = b"media.role\0";
517pub const SPA_KEY_API_UDEV: &[u8; 9] = b"api.udev\0";
518pub const SPA_KEY_API_UDEV_MATCH: &[u8; 15] = b"api.udev.match\0";
519pub const SPA_KEY_API_ALSA: &[u8; 9] = b"api.alsa\0";
520pub const SPA_KEY_API_ALSA_PATH: &[u8; 14] = b"api.alsa.path\0";
521pub const SPA_KEY_API_ALSA_CARD: &[u8; 14] = b"api.alsa.card\0";
522pub const SPA_KEY_API_ALSA_USE_UCM: &[u8; 17] = b"api.alsa.use-ucm\0";
523pub const SPA_KEY_API_ALSA_IGNORE_DB: &[u8; 19] = b"api.alsa.ignore-dB\0";
524pub const SPA_KEY_API_ALSA_OPEN_UCM: &[u8; 18] = b"api.alsa.open.ucm\0";
525pub const SPA_KEY_API_ALSA_DISABLE_LONGNAME: &[u8; 26] = b"api.alsa.disable-longname\0";
526pub const SPA_KEY_API_ALSA_BIND_CTLS: &[u8; 19] = b"api.alsa.bind-ctls\0";
527pub const SPA_KEY_API_ALSA_SPLIT_ENABLE: &[u8; 22] = b"api.alsa.split-enable\0";
528pub const SPA_KEY_API_ALSA_SPLIT_PARENT: &[u8; 22] = b"api.alsa.split.parent\0";
529pub const SPA_KEY_API_ALSA_CARD_ID: &[u8; 17] = b"api.alsa.card.id\0";
530pub const SPA_KEY_API_ALSA_CARD_COMPONENTS: &[u8; 25] = b"api.alsa.card.components\0";
531pub const SPA_KEY_API_ALSA_CARD_DRIVER: &[u8; 21] = b"api.alsa.card.driver\0";
532pub const SPA_KEY_API_ALSA_CARD_NAME: &[u8; 19] = b"api.alsa.card.name\0";
533pub const SPA_KEY_API_ALSA_CARD_LONGNAME: &[u8; 23] = b"api.alsa.card.longname\0";
534pub const SPA_KEY_API_ALSA_CARD_MIXERNAME: &[u8; 24] = b"api.alsa.card.mixername\0";
535pub const SPA_KEY_API_ALSA_PCM_ID: &[u8; 16] = b"api.alsa.pcm.id\0";
536pub const SPA_KEY_API_ALSA_PCM_CARD: &[u8; 18] = b"api.alsa.pcm.card\0";
537pub const SPA_KEY_API_ALSA_PCM_NAME: &[u8; 18] = b"api.alsa.pcm.name\0";
538pub const SPA_KEY_API_ALSA_PCM_SUBNAME: &[u8; 21] = b"api.alsa.pcm.subname\0";
539pub const SPA_KEY_API_ALSA_PCM_STREAM: &[u8; 20] = b"api.alsa.pcm.stream\0";
540pub const SPA_KEY_API_ALSA_PCM_CLASS: &[u8; 19] = b"api.alsa.pcm.class\0";
541pub const SPA_KEY_API_ALSA_PCM_DEVICE: &[u8; 20] = b"api.alsa.pcm.device\0";
542pub const SPA_KEY_API_ALSA_PCM_SUBDEVICE: &[u8; 23] = b"api.alsa.pcm.subdevice\0";
543pub const SPA_KEY_API_ALSA_PCM_SUBCLASS: &[u8; 22] = b"api.alsa.pcm.subclass\0";
544pub const SPA_KEY_API_ALSA_PCM_SYNC_ID: &[u8; 21] = b"api.alsa.pcm.sync-id\0";
545pub const SPA_KEY_API_ALSA_SPLIT_POSITION: &[u8; 24] = b"api.alsa.split.position\0";
546pub const SPA_KEY_API_ALSA_SPLIT_HW_POSITION: &[u8; 27] = b"api.alsa.split.hw-position\0";
547pub const SPA_KEY_API_V4L2: &[u8; 9] = b"api.v4l2\0";
548pub const SPA_KEY_API_V4L2_PATH: &[u8; 14] = b"api.v4l2.path\0";
549pub const SPA_KEY_API_LIBCAMERA: &[u8; 14] = b"api.libcamera\0";
550pub const SPA_KEY_API_LIBCAMERA_PATH: &[u8; 19] = b"api.libcamera.path\0";
551pub const SPA_KEY_API_LIBCAMERA_LOCATION: &[u8; 23] = b"api.libcamera.location\0";
552pub const SPA_KEY_API_LIBCAMERA_ROTATION: &[u8; 23] = b"api.libcamera.rotation\0";
553pub const SPA_KEY_API_LIBCAMERA_CAP_DRIVER: &[u8; 25] = b"api.libcamera.cap.driver\0";
554pub const SPA_KEY_API_LIBCAMERA_CAP_CARD: &[u8; 23] = b"api.libcamera.cap.card\0";
555pub const SPA_KEY_API_LIBCAMERA_CAP_BUS_INFO: &[u8; 27] = b"api.libcamera.cap.bus_info\0";
556pub const SPA_KEY_API_LIBCAMERA_CAP_VERSION: &[u8; 26] = b"api.libcamera.cap.version\0";
557pub const SPA_KEY_API_LIBCAMERA_CAP_CAPABILITIES: &[u8; 31] = b"api.libcamera.cap.capabilities\0";
558pub const SPA_KEY_API_LIBCAMERA_CAP_DEVICE_CAPS: &[u8; 30] = b"api.libcamera.cap.device-caps\0";
559pub const SPA_KEY_API_V4L2_CAP_DRIVER: &[u8; 20] = b"api.v4l2.cap.driver\0";
560pub const SPA_KEY_API_V4L2_CAP_CARD: &[u8; 18] = b"api.v4l2.cap.card\0";
561pub const SPA_KEY_API_V4L2_CAP_BUS_INFO: &[u8; 22] = b"api.v4l2.cap.bus_info\0";
562pub const SPA_KEY_API_V4L2_CAP_VERSION: &[u8; 21] = b"api.v4l2.cap.version\0";
563pub const SPA_KEY_API_V4L2_CAP_CAPABILITIES: &[u8; 26] = b"api.v4l2.cap.capabilities\0";
564pub const SPA_KEY_API_V4L2_CAP_DEVICE_CAPS: &[u8; 25] = b"api.v4l2.cap.device-caps\0";
565pub const SPA_KEY_API_BLUEZ5: &[u8; 11] = b"api.bluez5\0";
566pub const SPA_KEY_API_BLUEZ5_PATH: &[u8; 16] = b"api.bluez5.path\0";
567pub const SPA_KEY_API_BLUEZ5_DEVICE: &[u8; 18] = b"api.bluez5.device\0";
568pub const SPA_KEY_API_BLUEZ5_CONNECTION: &[u8; 22] = b"api.bluez5.connection\0";
569pub const SPA_KEY_API_BLUEZ5_TRANSPORT: &[u8; 21] = b"api.bluez5.transport\0";
570pub const SPA_KEY_API_BLUEZ5_PROFILE: &[u8; 19] = b"api.bluez5.profile\0";
571pub const SPA_KEY_API_BLUEZ5_ADDRESS: &[u8; 19] = b"api.bluez5.address\0";
572pub const SPA_KEY_API_BLUEZ5_CODEC: &[u8; 17] = b"api.bluez5.codec\0";
573pub const SPA_KEY_API_BLUEZ5_CLASS: &[u8; 17] = b"api.bluez5.class\0";
574pub const SPA_KEY_API_BLUEZ5_ICON: &[u8; 16] = b"api.bluez5.icon\0";
575pub const SPA_KEY_API_BLUEZ5_ROLE: &[u8; 16] = b"api.bluez5.role\0";
576pub const SPA_KEY_API_JACK: &[u8; 9] = b"api.jack\0";
577pub const SPA_KEY_API_JACK_SERVER: &[u8; 16] = b"api.jack.server\0";
578pub const SPA_KEY_API_JACK_CLIENT: &[u8; 16] = b"api.jack.client\0";
579pub const SPA_KEY_API_GLIB_MAINLOOP: &[u8; 18] = b"api.glib.mainloop\0";
580pub const SPA_NAME_SUPPORT_CPU: &[u8; 12] = b"support.cpu\0";
581pub const SPA_NAME_SUPPORT_DBUS: &[u8; 13] = b"support.dbus\0";
582pub const SPA_NAME_SUPPORT_LOG: &[u8; 12] = b"support.log\0";
583pub const SPA_NAME_SUPPORT_LOOP: &[u8; 13] = b"support.loop\0";
584pub const SPA_NAME_SUPPORT_SYSTEM: &[u8; 15] = b"support.system\0";
585pub const SPA_NAME_SUPPORT_NODE_DRIVER: &[u8; 20] = b"support.node.driver\0";
586pub const SPA_NAME_CONTROL_MIXER: &[u8; 14] = b"control.mixer\0";
587pub const SPA_NAME_AUDIO_MIXER: &[u8; 12] = b"audio.mixer\0";
588pub const SPA_NAME_AUDIO_MIXER_DSP: &[u8; 16] = b"audio.mixer.dsp\0";
589pub const SPA_NAME_AUDIO_PROCESS_FORMAT: &[u8; 21] = b"audio.process.format\0";
590pub const SPA_NAME_AUDIO_PROCESS_CHANNELMIX: &[u8; 25] = b"audio.process.channelmix\0";
591pub const SPA_NAME_AUDIO_PROCESS_RESAMPLE: &[u8; 23] = b"audio.process.resample\0";
592pub const SPA_NAME_AUDIO_PROCESS_DEINTERLEAVE: &[u8; 27] = b"audio.process.deinterleave\0";
593pub const SPA_NAME_AUDIO_PROCESS_INTERLEAVE: &[u8; 25] = b"audio.process.interleave\0";
594pub const SPA_NAME_AUDIO_CONVERT: &[u8; 14] = b"audio.convert\0";
595pub const SPA_NAME_AUDIO_ADAPT: &[u8; 12] = b"audio.adapt\0";
596pub const SPA_NAME_AEC: &[u8; 10] = b"audio.aec\0";
597pub const SPA_NAME_VIDEO_PROCESS_FORMAT: &[u8; 21] = b"video.process.format\0";
598pub const SPA_NAME_VIDEO_PROCESS_SCALE: &[u8; 20] = b"video.process.scale\0";
599pub const SPA_NAME_VIDEO_CONVERT: &[u8; 14] = b"video.convert\0";
600pub const SPA_NAME_VIDEO_CONVERT_DUMMY: &[u8; 20] = b"video.convert.dummy\0";
601pub const SPA_NAME_VIDEO_ADAPT: &[u8; 12] = b"video.adapt\0";
602pub const SPA_NAME_API_ALSA_ENUM_UDEV: &[u8; 19] = b"api.alsa.enum.udev\0";
603pub const SPA_NAME_API_ALSA_PCM_DEVICE: &[u8; 20] = b"api.alsa.pcm.device\0";
604pub const SPA_NAME_API_ALSA_PCM_SOURCE: &[u8; 20] = b"api.alsa.pcm.source\0";
605pub const SPA_NAME_API_ALSA_PCM_SINK: &[u8; 18] = b"api.alsa.pcm.sink\0";
606pub const SPA_NAME_API_ALSA_SEQ_DEVICE: &[u8; 20] = b"api.alsa.seq.device\0";
607pub const SPA_NAME_API_ALSA_SEQ_SOURCE: &[u8; 20] = b"api.alsa.seq.source\0";
608pub const SPA_NAME_API_ALSA_SEQ_SINK: &[u8; 18] = b"api.alsa.seq.sink\0";
609pub const SPA_NAME_API_ALSA_SEQ_BRIDGE: &[u8; 20] = b"api.alsa.seq.bridge\0";
610pub const SPA_NAME_API_ALSA_ACP_DEVICE: &[u8; 20] = b"api.alsa.acp.device\0";
611pub const SPA_NAME_API_ALSA_COMPRESS_OFFLOAD_DEVICE: &[u8; 33] =
612 b"api.alsa.compress.offload.device\0";
613pub const SPA_NAME_API_ALSA_COMPRESS_OFFLOAD_SINK: &[u8; 31] = b"api.alsa.compress.offload.sink\0";
614pub const SPA_NAME_API_BLUEZ5_ENUM_DBUS: &[u8; 21] = b"api.bluez5.enum.dbus\0";
615pub const SPA_NAME_API_BLUEZ5_DEVICE: &[u8; 18] = b"api.bluez5.device\0";
616pub const SPA_NAME_API_BLUEZ5_MEDIA_SINK: &[u8; 22] = b"api.bluez5.media.sink\0";
617pub const SPA_NAME_API_BLUEZ5_MEDIA_SOURCE: &[u8; 24] = b"api.bluez5.media.source\0";
618pub const SPA_NAME_API_BLUEZ5_A2DP_SINK: &[u8; 21] = b"api.bluez5.a2dp.sink\0";
619pub const SPA_NAME_API_BLUEZ5_A2DP_SOURCE: &[u8; 23] = b"api.bluez5.a2dp.source\0";
620pub const SPA_NAME_API_BLUEZ5_SCO_SINK: &[u8; 20] = b"api.bluez5.sco.sink\0";
621pub const SPA_NAME_API_BLUEZ5_SCO_SOURCE: &[u8; 22] = b"api.bluez5.sco.source\0";
622pub const SPA_NAME_API_BLUEZ5_MIDI_ENUM: &[u8; 21] = b"api.bluez5.midi.enum\0";
623pub const SPA_NAME_API_BLUEZ5_MIDI_NODE: &[u8; 21] = b"api.bluez5.midi.node\0";
624pub const SPA_NAME_API_CODEC_BLUEZ5_MEDIA: &[u8; 23] = b"api.codec.bluez5.media\0";
625pub const SPA_NAME_API_V4L2_ENUM_UDEV: &[u8; 19] = b"api.v4l2.enum.udev\0";
626pub const SPA_NAME_API_V4L2_DEVICE: &[u8; 16] = b"api.v4l2.device\0";
627pub const SPA_NAME_API_V4L2_SOURCE: &[u8; 16] = b"api.v4l2.source\0";
628pub const SPA_NAME_API_LIBCAMERA_ENUM_CLIENT: &[u8; 26] = b"api.libcamera.enum.client\0";
629pub const SPA_NAME_API_LIBCAMERA_ENUM_MANAGER: &[u8; 27] = b"api.libcamera.enum.manager\0";
630pub const SPA_NAME_API_LIBCAMERA_DEVICE: &[u8; 21] = b"api.libcamera.device\0";
631pub const SPA_NAME_API_LIBCAMERA_SOURCE: &[u8; 21] = b"api.libcamera.source\0";
632pub const SPA_NAME_API_JACK_DEVICE: &[u8; 16] = b"api.jack.device\0";
633pub const SPA_NAME_API_JACK_SOURCE: &[u8; 16] = b"api.jack.source\0";
634pub const SPA_NAME_API_JACK_SINK: &[u8; 14] = b"api.jack.sink\0";
635pub const SPA_NAME_API_VULKAN_COMPUTE_SOURCE: &[u8; 26] = b"api.vulkan.compute.source\0";
636pub const SPA_NAME_API_VULKAN_COMPUTE_FILTER: &[u8; 26] = b"api.vulkan.compute.filter\0";
637pub const SPA_NAME_API_VULKAN_BLIT_FILTER: &[u8; 23] = b"api.vulkan.blit.filter\0";
638pub const SPA_NAME_API_VULKAN_BLIT_DSP_FILTER: &[u8; 27] = b"api.vulkan.blit.dsp-filter\0";
639pub const SPA_ASYNC_BIT: u32 = 1073741824;
640pub const SPA_ASYNC_SEQ_MASK: u32 = 1073741823;
641pub const SPA_ASYNC_MASK: i32 = -1073741824;
642pub type __off_t = ::std::os::raw::c_long;
643pub type __time_t = ::std::os::raw::c_long;
644pub type __syscall_slong_t = ::std::os::raw::c_long;
645#[repr(C)]
646#[derive(Debug, Copy, Clone, PartialEq, Eq)]
647pub struct timespec {
648 pub tv_sec: __time_t,
649 pub tv_nsec: __syscall_slong_t,
650}
651#[allow(clippy::unnecessary_operation, clippy::identity_op)]
652const _: () = {
653 ["Size of timespec"][::std::mem::size_of::<timespec>() - 16usize];
654 ["Alignment of timespec"][::std::mem::align_of::<timespec>() - 8usize];
655 ["Offset of field: timespec::tv_sec"][::std::mem::offset_of!(timespec, tv_sec) - 0usize];
656 ["Offset of field: timespec::tv_nsec"][::std::mem::offset_of!(timespec, tv_nsec) - 8usize];
657};
658pub type off_t = __off_t;
659pub type __gnuc_va_list = __builtin_va_list;
660pub type va_list = __gnuc_va_list;
661pub const SPA_DIRECTION_INPUT: spa_direction = 0;
662pub const SPA_DIRECTION_OUTPUT: spa_direction = 1;
663pub type spa_direction = ::std::os::raw::c_uint;
664#[repr(C)]
665#[derive(Debug, Copy, Clone, PartialEq, Eq)]
666pub struct spa_rectangle {
667 pub width: u32,
668 pub height: u32,
669}
670#[allow(clippy::unnecessary_operation, clippy::identity_op)]
671const _: () = {
672 ["Size of spa_rectangle"][::std::mem::size_of::<spa_rectangle>() - 8usize];
673 ["Alignment of spa_rectangle"][::std::mem::align_of::<spa_rectangle>() - 4usize];
674 ["Offset of field: spa_rectangle::width"]
675 [::std::mem::offset_of!(spa_rectangle, width) - 0usize];
676 ["Offset of field: spa_rectangle::height"]
677 [::std::mem::offset_of!(spa_rectangle, height) - 4usize];
678};
679#[repr(C)]
680#[derive(Debug, Copy, Clone, PartialEq, Eq)]
681pub struct spa_point {
682 pub x: i32,
683 pub y: i32,
684}
685#[allow(clippy::unnecessary_operation, clippy::identity_op)]
686const _: () = {
687 ["Size of spa_point"][::std::mem::size_of::<spa_point>() - 8usize];
688 ["Alignment of spa_point"][::std::mem::align_of::<spa_point>() - 4usize];
689 ["Offset of field: spa_point::x"][::std::mem::offset_of!(spa_point, x) - 0usize];
690 ["Offset of field: spa_point::y"][::std::mem::offset_of!(spa_point, y) - 4usize];
691};
692#[repr(C)]
693#[derive(Debug, Copy, Clone, PartialEq, Eq)]
694pub struct spa_region {
695 pub position: spa_point,
696 pub size: spa_rectangle,
697}
698#[allow(clippy::unnecessary_operation, clippy::identity_op)]
699const _: () = {
700 ["Size of spa_region"][::std::mem::size_of::<spa_region>() - 16usize];
701 ["Alignment of spa_region"][::std::mem::align_of::<spa_region>() - 4usize];
702 ["Offset of field: spa_region::position"]
703 [::std::mem::offset_of!(spa_region, position) - 0usize];
704 ["Offset of field: spa_region::size"][::std::mem::offset_of!(spa_region, size) - 8usize];
705};
706#[repr(C)]
707#[derive(Debug, Copy, Clone, PartialEq, Eq)]
708pub struct spa_fraction {
709 pub num: u32,
710 pub denom: u32,
711}
712#[allow(clippy::unnecessary_operation, clippy::identity_op)]
713const _: () = {
714 ["Size of spa_fraction"][::std::mem::size_of::<spa_fraction>() - 8usize];
715 ["Alignment of spa_fraction"][::std::mem::align_of::<spa_fraction>() - 4usize];
716 ["Offset of field: spa_fraction::num"][::std::mem::offset_of!(spa_fraction, num) - 0usize];
717 ["Offset of field: spa_fraction::denom"][::std::mem::offset_of!(spa_fraction, denom) - 4usize];
718};
719unsafe extern "C" {
720 #[link_name = "spa_ptrinside_libspa_rs"]
721 pub fn spa_ptrinside(
722 p1: *const ::std::os::raw::c_void,
723 s1: usize,
724 p2: *const ::std::os::raw::c_void,
725 s2: usize,
726 remaining: *mut usize,
727 ) -> bool;
728}
729unsafe extern "C" {
730 #[link_name = "spa_ptr_inside_and_aligned_libspa_rs"]
731 pub fn spa_ptr_inside_and_aligned(
732 p1: *const ::std::os::raw::c_void,
733 s1: usize,
734 p2: *const ::std::os::raw::c_void,
735 s2: usize,
736 align: usize,
737 remaining: *mut usize,
738 ) -> bool;
739}
740#[repr(C)]
741#[derive(Debug, Copy, Clone, PartialEq, Eq)]
742pub struct spa_error_location {
743 pub line: ::std::os::raw::c_int,
744 pub col: ::std::os::raw::c_int,
745 pub len: usize,
746 pub location: *const ::std::os::raw::c_char,
747 pub reason: *const ::std::os::raw::c_char,
748}
749#[allow(clippy::unnecessary_operation, clippy::identity_op)]
750const _: () = {
751 ["Size of spa_error_location"][::std::mem::size_of::<spa_error_location>() - 32usize];
752 ["Alignment of spa_error_location"][::std::mem::align_of::<spa_error_location>() - 8usize];
753 ["Offset of field: spa_error_location::line"]
754 [::std::mem::offset_of!(spa_error_location, line) - 0usize];
755 ["Offset of field: spa_error_location::col"]
756 [::std::mem::offset_of!(spa_error_location, col) - 4usize];
757 ["Offset of field: spa_error_location::len"]
758 [::std::mem::offset_of!(spa_error_location, len) - 8usize];
759 ["Offset of field: spa_error_location::location"]
760 [::std::mem::offset_of!(spa_error_location, location) - 16usize];
761 ["Offset of field: spa_error_location::reason"]
762 [::std::mem::offset_of!(spa_error_location, reason) - 24usize];
763};
764unsafe extern "C" {
765 #[doc = " \\return true if the two strings are equal, false otherwise\n\n If both \\a a and \\a b are NULL, the two are considered equal.\n"]
766 #[link_name = "spa_streq_libspa_rs"]
767 pub fn spa_streq(s1: *const ::std::os::raw::c_char, s2: *const ::std::os::raw::c_char) -> bool;
768}
769unsafe extern "C" {
770 #[doc = " \\return true if the two strings are equal, false otherwise\n\n If both \\a a and \\a b are NULL, the two are considered equal."]
771 #[link_name = "spa_strneq_libspa_rs"]
772 pub fn spa_strneq(
773 s1: *const ::std::os::raw::c_char,
774 s2: *const ::std::os::raw::c_char,
775 len: usize,
776 ) -> bool;
777}
778unsafe extern "C" {
779 #[doc = " \\return true if \\a s starts with the \\a prefix or false otherwise.\n A \\a s is NULL, it never starts with the given \\a prefix. A \\a prefix of\n NULL is a bug in the caller."]
780 #[link_name = "spa_strstartswith_libspa_rs"]
781 pub fn spa_strstartswith(
782 s: *const ::std::os::raw::c_char,
783 prefix: *const ::std::os::raw::c_char,
784 ) -> bool;
785}
786unsafe extern "C" {
787 #[doc = " \\return true if \\a s ends with the \\a suffix or false otherwise.\n A \\a s is NULL, it never ends with the given \\a suffix. A \\a suffix of\n NULL is a bug in the caller."]
788 #[link_name = "spa_strendswith_libspa_rs"]
789 pub fn spa_strendswith(
790 s: *const ::std::os::raw::c_char,
791 suffix: *const ::std::os::raw::c_char,
792 ) -> bool;
793}
794unsafe extern "C" {
795 #[doc = " Convert \\a str to an int32_t with the given \\a base and store the\n result in \\a val.\n\n On failure, the value of \\a val is unmodified.\n\n \\return true on success, false otherwise"]
796 #[link_name = "spa_atoi32_libspa_rs"]
797 pub fn spa_atoi32(
798 str_: *const ::std::os::raw::c_char,
799 val: *mut i32,
800 base: ::std::os::raw::c_int,
801 ) -> bool;
802}
803unsafe extern "C" {
804 #[doc = " Convert \\a str to an uint32_t with the given \\a base and store the\n result in \\a val.\n\n On failure, the value of \\a val is unmodified.\n\n \\return true on success, false otherwise"]
805 #[link_name = "spa_atou32_libspa_rs"]
806 pub fn spa_atou32(
807 str_: *const ::std::os::raw::c_char,
808 val: *mut u32,
809 base: ::std::os::raw::c_int,
810 ) -> bool;
811}
812unsafe extern "C" {
813 #[doc = " Convert \\a str to an int64_t with the given \\a base and store the\n result in \\a val.\n\n On failure, the value of \\a val is unmodified.\n\n \\return true on success, false otherwise"]
814 #[link_name = "spa_atoi64_libspa_rs"]
815 pub fn spa_atoi64(
816 str_: *const ::std::os::raw::c_char,
817 val: *mut i64,
818 base: ::std::os::raw::c_int,
819 ) -> bool;
820}
821unsafe extern "C" {
822 #[doc = " Convert \\a str to an uint64_t with the given \\a base and store the\n result in \\a val.\n\n On failure, the value of \\a val is unmodified.\n\n \\return true on success, false otherwise"]
823 #[link_name = "spa_atou64_libspa_rs"]
824 pub fn spa_atou64(
825 str_: *const ::std::os::raw::c_char,
826 val: *mut u64,
827 base: ::std::os::raw::c_int,
828 ) -> bool;
829}
830unsafe extern "C" {
831 #[doc = " Convert \\a str to a boolean. Allowed boolean values are \"true\" and a\n literal \"1\", anything else is false.\n\n \\return true on success, false otherwise"]
832 #[link_name = "spa_atob_libspa_rs"]
833 pub fn spa_atob(str_: *const ::std::os::raw::c_char) -> bool;
834}
835unsafe extern "C" {
836 #[doc = " \"Safe\" version of vsnprintf. Exactly the same as vsnprintf but the\n returned value is clipped to `size - 1` and a negative or zero size\n will abort() the program.\n\n \\return The number of bytes printed, capped to `size-1`, or a negative\n number on error."]
837 #[link_name = "spa_vscnprintf_libspa_rs"]
838 pub fn spa_vscnprintf(
839 buffer: *mut ::std::os::raw::c_char,
840 size: usize,
841 format: *const ::std::os::raw::c_char,
842 args: *mut __va_list_tag,
843 ) -> ::std::os::raw::c_int;
844}
845unsafe extern "C" {
846 #[doc = " Convert \\a str to a float in the C locale.\n\n If \\a endptr is not NULL, a pointer to the character after the last character\n used in the conversion is stored in the location referenced by endptr.\n\n \\return the result float."]
847 #[link_name = "spa_strtof_libspa_rs"]
848 pub fn spa_strtof(
849 str_: *const ::std::os::raw::c_char,
850 endptr: *mut *mut ::std::os::raw::c_char,
851 ) -> f32;
852}
853unsafe extern "C" {
854 #[doc = " Convert \\a str to a float and store the result in \\a val.\n\n On failure, the value of \\a val is unmodified.\n\n \\return true on success, false otherwise"]
855 #[link_name = "spa_atof_libspa_rs"]
856 pub fn spa_atof(str_: *const ::std::os::raw::c_char, val: *mut f32) -> bool;
857}
858unsafe extern "C" {
859 #[doc = " Convert \\a str to a double in the C locale.\n\n If \\a endptr is not NULL, a pointer to the character after the last character\n used in the conversion is stored in the location referenced by endptr.\n\n \\return the result float."]
860 #[link_name = "spa_strtod_libspa_rs"]
861 pub fn spa_strtod(
862 str_: *const ::std::os::raw::c_char,
863 endptr: *mut *mut ::std::os::raw::c_char,
864 ) -> f64;
865}
866unsafe extern "C" {
867 #[doc = " Convert \\a str to a double and store the result in \\a val.\n\n On failure, the value of \\a val is unmodified.\n\n \\return true on success, false otherwise"]
868 #[link_name = "spa_atod_libspa_rs"]
869 pub fn spa_atod(str_: *const ::std::os::raw::c_char, val: *mut f64) -> bool;
870}
871unsafe extern "C" {
872 #[link_name = "spa_dtoa_libspa_rs"]
873 pub fn spa_dtoa(
874 str_: *mut ::std::os::raw::c_char,
875 size: usize,
876 val: f64,
877 ) -> *mut ::std::os::raw::c_char;
878}
879#[repr(C)]
880#[derive(Debug, Copy, Clone, PartialEq, Eq)]
881pub struct spa_strbuf {
882 pub buffer: *mut ::std::os::raw::c_char,
883 pub maxsize: usize,
884 pub pos: usize,
885}
886#[allow(clippy::unnecessary_operation, clippy::identity_op)]
887const _: () = {
888 ["Size of spa_strbuf"][::std::mem::size_of::<spa_strbuf>() - 24usize];
889 ["Alignment of spa_strbuf"][::std::mem::align_of::<spa_strbuf>() - 8usize];
890 ["Offset of field: spa_strbuf::buffer"][::std::mem::offset_of!(spa_strbuf, buffer) - 0usize];
891 ["Offset of field: spa_strbuf::maxsize"][::std::mem::offset_of!(spa_strbuf, maxsize) - 8usize];
892 ["Offset of field: spa_strbuf::pos"][::std::mem::offset_of!(spa_strbuf, pos) - 16usize];
893};
894unsafe extern "C" {
895 #[link_name = "spa_strbuf_init_libspa_rs"]
896 pub fn spa_strbuf_init(
897 buf: *mut spa_strbuf,
898 buffer: *mut ::std::os::raw::c_char,
899 maxsize: usize,
900 );
901}
902pub const SPA_TYPE_START: _bindgen_ty_10 = 0;
903pub const SPA_TYPE_None: _bindgen_ty_10 = 1;
904pub const SPA_TYPE_Bool: _bindgen_ty_10 = 2;
905pub const SPA_TYPE_Id: _bindgen_ty_10 = 3;
906pub const SPA_TYPE_Int: _bindgen_ty_10 = 4;
907pub const SPA_TYPE_Long: _bindgen_ty_10 = 5;
908pub const SPA_TYPE_Float: _bindgen_ty_10 = 6;
909pub const SPA_TYPE_Double: _bindgen_ty_10 = 7;
910pub const SPA_TYPE_String: _bindgen_ty_10 = 8;
911pub const SPA_TYPE_Bytes: _bindgen_ty_10 = 9;
912pub const SPA_TYPE_Rectangle: _bindgen_ty_10 = 10;
913pub const SPA_TYPE_Fraction: _bindgen_ty_10 = 11;
914pub const SPA_TYPE_Bitmap: _bindgen_ty_10 = 12;
915pub const SPA_TYPE_Array: _bindgen_ty_10 = 13;
916pub const SPA_TYPE_Struct: _bindgen_ty_10 = 14;
917pub const SPA_TYPE_Object: _bindgen_ty_10 = 15;
918pub const SPA_TYPE_Sequence: _bindgen_ty_10 = 16;
919pub const SPA_TYPE_Pointer: _bindgen_ty_10 = 17;
920pub const SPA_TYPE_Fd: _bindgen_ty_10 = 18;
921pub const SPA_TYPE_Choice: _bindgen_ty_10 = 19;
922pub const SPA_TYPE_Pod: _bindgen_ty_10 = 20;
923#[doc = "< not part of ABI"]
924pub const _SPA_TYPE_LAST: _bindgen_ty_10 = 21;
925pub const SPA_TYPE_POINTER_START: _bindgen_ty_10 = 65536;
926pub const SPA_TYPE_POINTER_Buffer: _bindgen_ty_10 = 65537;
927pub const SPA_TYPE_POINTER_Meta: _bindgen_ty_10 = 65538;
928pub const SPA_TYPE_POINTER_Dict: _bindgen_ty_10 = 65539;
929#[doc = "< not part of ABI"]
930pub const _SPA_TYPE_POINTER_LAST: _bindgen_ty_10 = 65540;
931pub const SPA_TYPE_EVENT_START: _bindgen_ty_10 = 131072;
932pub const SPA_TYPE_EVENT_Device: _bindgen_ty_10 = 131073;
933pub const SPA_TYPE_EVENT_Node: _bindgen_ty_10 = 131074;
934#[doc = "< not part of ABI"]
935pub const _SPA_TYPE_EVENT_LAST: _bindgen_ty_10 = 131075;
936pub const SPA_TYPE_COMMAND_START: _bindgen_ty_10 = 196608;
937pub const SPA_TYPE_COMMAND_Device: _bindgen_ty_10 = 196609;
938pub const SPA_TYPE_COMMAND_Node: _bindgen_ty_10 = 196610;
939#[doc = "< not part of ABI"]
940pub const _SPA_TYPE_COMMAND_LAST: _bindgen_ty_10 = 196611;
941pub const SPA_TYPE_OBJECT_START: _bindgen_ty_10 = 262144;
942pub const SPA_TYPE_OBJECT_PropInfo: _bindgen_ty_10 = 262145;
943pub const SPA_TYPE_OBJECT_Props: _bindgen_ty_10 = 262146;
944pub const SPA_TYPE_OBJECT_Format: _bindgen_ty_10 = 262147;
945pub const SPA_TYPE_OBJECT_ParamBuffers: _bindgen_ty_10 = 262148;
946pub const SPA_TYPE_OBJECT_ParamMeta: _bindgen_ty_10 = 262149;
947pub const SPA_TYPE_OBJECT_ParamIO: _bindgen_ty_10 = 262150;
948pub const SPA_TYPE_OBJECT_ParamProfile: _bindgen_ty_10 = 262151;
949pub const SPA_TYPE_OBJECT_ParamPortConfig: _bindgen_ty_10 = 262152;
950pub const SPA_TYPE_OBJECT_ParamRoute: _bindgen_ty_10 = 262153;
951pub const SPA_TYPE_OBJECT_Profiler: _bindgen_ty_10 = 262154;
952pub const SPA_TYPE_OBJECT_ParamLatency: _bindgen_ty_10 = 262155;
953pub const SPA_TYPE_OBJECT_ParamProcessLatency: _bindgen_ty_10 = 262156;
954pub const SPA_TYPE_OBJECT_ParamTag: _bindgen_ty_10 = 262157;
955#[doc = "< not part of ABI"]
956pub const _SPA_TYPE_OBJECT_LAST: _bindgen_ty_10 = 262158;
957pub const SPA_TYPE_VENDOR_PipeWire: _bindgen_ty_10 = 33554432;
958pub const SPA_TYPE_VENDOR_Other: _bindgen_ty_10 = 2130706432;
959#[doc = " \\addtogroup spa_types\n \\{"]
960pub type _bindgen_ty_10 = ::std::os::raw::c_uint;
961#[repr(C)]
962#[derive(Debug, Copy, Clone, PartialEq, Eq)]
963pub struct spa_type_info {
964 pub type_: u32,
965 pub parent: u32,
966 pub name: *const ::std::os::raw::c_char,
967 pub values: *const spa_type_info,
968}
969#[allow(clippy::unnecessary_operation, clippy::identity_op)]
970const _: () = {
971 ["Size of spa_type_info"][::std::mem::size_of::<spa_type_info>() - 24usize];
972 ["Alignment of spa_type_info"][::std::mem::align_of::<spa_type_info>() - 8usize];
973 ["Offset of field: spa_type_info::type_"]
974 [::std::mem::offset_of!(spa_type_info, type_) - 0usize];
975 ["Offset of field: spa_type_info::parent"]
976 [::std::mem::offset_of!(spa_type_info, parent) - 4usize];
977 ["Offset of field: spa_type_info::name"][::std::mem::offset_of!(spa_type_info, name) - 8usize];
978 ["Offset of field: spa_type_info::values"]
979 [::std::mem::offset_of!(spa_type_info, values) - 16usize];
980};
981unsafe extern "C" {
982 #[link_name = "spa_type_is_a_libspa_rs"]
983 pub fn spa_type_is_a(
984 type_: *const ::std::os::raw::c_char,
985 parent: *const ::std::os::raw::c_char,
986 ) -> bool;
987}
988unsafe extern "C" {
989 #[link_name = "spa_type_short_name_libspa_rs"]
990 pub fn spa_type_short_name(
991 name: *const ::std::os::raw::c_char,
992 ) -> *const ::std::os::raw::c_char;
993}
994unsafe extern "C" {
995 #[link_name = "spa_type_from_short_name_libspa_rs"]
996 pub fn spa_type_from_short_name(
997 name: *const ::std::os::raw::c_char,
998 info: *const spa_type_info,
999 unknown: u32,
1000 ) -> u32;
1001}
1002unsafe extern "C" {
1003 #[link_name = "spa_type_to_name_libspa_rs"]
1004 pub fn spa_type_to_name(
1005 type_: u32,
1006 info: *const spa_type_info,
1007 unknown: *const ::std::os::raw::c_char,
1008 ) -> *const ::std::os::raw::c_char;
1009}
1010unsafe extern "C" {
1011 #[link_name = "spa_type_to_short_name_libspa_rs"]
1012 pub fn spa_type_to_short_name(
1013 type_: u32,
1014 info: *const spa_type_info,
1015 unknown: *const ::std::os::raw::c_char,
1016 ) -> *const ::std::os::raw::c_char;
1017}
1018#[repr(C)]
1019#[derive(Debug, Copy, Clone, PartialEq, Eq)]
1020pub struct spa_pod {
1021 pub size: u32,
1022 pub type_: u32,
1023}
1024#[allow(clippy::unnecessary_operation, clippy::identity_op)]
1025const _: () = {
1026 ["Size of spa_pod"][::std::mem::size_of::<spa_pod>() - 8usize];
1027 ["Alignment of spa_pod"][::std::mem::align_of::<spa_pod>() - 4usize];
1028 ["Offset of field: spa_pod::size"][::std::mem::offset_of!(spa_pod, size) - 0usize];
1029 ["Offset of field: spa_pod::type_"][::std::mem::offset_of!(spa_pod, type_) - 4usize];
1030};
1031#[repr(C)]
1032#[derive(Debug, Copy, Clone, PartialEq, Eq)]
1033pub struct spa_pod_bool {
1034 pub pod: spa_pod,
1035 pub value: i32,
1036 pub _padding: i32,
1037}
1038#[allow(clippy::unnecessary_operation, clippy::identity_op)]
1039const _: () = {
1040 ["Size of spa_pod_bool"][::std::mem::size_of::<spa_pod_bool>() - 16usize];
1041 ["Alignment of spa_pod_bool"][::std::mem::align_of::<spa_pod_bool>() - 4usize];
1042 ["Offset of field: spa_pod_bool::pod"][::std::mem::offset_of!(spa_pod_bool, pod) - 0usize];
1043 ["Offset of field: spa_pod_bool::value"][::std::mem::offset_of!(spa_pod_bool, value) - 8usize];
1044 ["Offset of field: spa_pod_bool::_padding"]
1045 [::std::mem::offset_of!(spa_pod_bool, _padding) - 12usize];
1046};
1047#[repr(C)]
1048#[derive(Debug, Copy, Clone, PartialEq, Eq)]
1049pub struct spa_pod_id {
1050 pub pod: spa_pod,
1051 pub value: u32,
1052 pub _padding: i32,
1053}
1054#[allow(clippy::unnecessary_operation, clippy::identity_op)]
1055const _: () = {
1056 ["Size of spa_pod_id"][::std::mem::size_of::<spa_pod_id>() - 16usize];
1057 ["Alignment of spa_pod_id"][::std::mem::align_of::<spa_pod_id>() - 4usize];
1058 ["Offset of field: spa_pod_id::pod"][::std::mem::offset_of!(spa_pod_id, pod) - 0usize];
1059 ["Offset of field: spa_pod_id::value"][::std::mem::offset_of!(spa_pod_id, value) - 8usize];
1060 ["Offset of field: spa_pod_id::_padding"]
1061 [::std::mem::offset_of!(spa_pod_id, _padding) - 12usize];
1062};
1063#[repr(C)]
1064#[derive(Debug, Copy, Clone, PartialEq, Eq)]
1065pub struct spa_pod_int {
1066 pub pod: spa_pod,
1067 pub value: i32,
1068 pub _padding: i32,
1069}
1070#[allow(clippy::unnecessary_operation, clippy::identity_op)]
1071const _: () = {
1072 ["Size of spa_pod_int"][::std::mem::size_of::<spa_pod_int>() - 16usize];
1073 ["Alignment of spa_pod_int"][::std::mem::align_of::<spa_pod_int>() - 4usize];
1074 ["Offset of field: spa_pod_int::pod"][::std::mem::offset_of!(spa_pod_int, pod) - 0usize];
1075 ["Offset of field: spa_pod_int::value"][::std::mem::offset_of!(spa_pod_int, value) - 8usize];
1076 ["Offset of field: spa_pod_int::_padding"]
1077 [::std::mem::offset_of!(spa_pod_int, _padding) - 12usize];
1078};
1079#[repr(C)]
1080#[derive(Debug, Copy, Clone, PartialEq, Eq)]
1081pub struct spa_pod_long {
1082 pub pod: spa_pod,
1083 pub value: i64,
1084}
1085#[allow(clippy::unnecessary_operation, clippy::identity_op)]
1086const _: () = {
1087 ["Size of spa_pod_long"][::std::mem::size_of::<spa_pod_long>() - 16usize];
1088 ["Alignment of spa_pod_long"][::std::mem::align_of::<spa_pod_long>() - 8usize];
1089 ["Offset of field: spa_pod_long::pod"][::std::mem::offset_of!(spa_pod_long, pod) - 0usize];
1090 ["Offset of field: spa_pod_long::value"][::std::mem::offset_of!(spa_pod_long, value) - 8usize];
1091};
1092#[repr(C)]
1093#[derive(Debug, Copy, Clone, PartialEq)]
1094pub struct spa_pod_float {
1095 pub pod: spa_pod,
1096 pub value: f32,
1097 pub _padding: i32,
1098}
1099#[allow(clippy::unnecessary_operation, clippy::identity_op)]
1100const _: () = {
1101 ["Size of spa_pod_float"][::std::mem::size_of::<spa_pod_float>() - 16usize];
1102 ["Alignment of spa_pod_float"][::std::mem::align_of::<spa_pod_float>() - 4usize];
1103 ["Offset of field: spa_pod_float::pod"][::std::mem::offset_of!(spa_pod_float, pod) - 0usize];
1104 ["Offset of field: spa_pod_float::value"]
1105 [::std::mem::offset_of!(spa_pod_float, value) - 8usize];
1106 ["Offset of field: spa_pod_float::_padding"]
1107 [::std::mem::offset_of!(spa_pod_float, _padding) - 12usize];
1108};
1109#[repr(C)]
1110#[derive(Debug, Copy, Clone, PartialEq)]
1111pub struct spa_pod_double {
1112 pub pod: spa_pod,
1113 pub value: f64,
1114}
1115#[allow(clippy::unnecessary_operation, clippy::identity_op)]
1116const _: () = {
1117 ["Size of spa_pod_double"][::std::mem::size_of::<spa_pod_double>() - 16usize];
1118 ["Alignment of spa_pod_double"][::std::mem::align_of::<spa_pod_double>() - 8usize];
1119 ["Offset of field: spa_pod_double::pod"][::std::mem::offset_of!(spa_pod_double, pod) - 0usize];
1120 ["Offset of field: spa_pod_double::value"]
1121 [::std::mem::offset_of!(spa_pod_double, value) - 8usize];
1122};
1123#[repr(C)]
1124#[derive(Debug, Copy, Clone, PartialEq, Eq)]
1125pub struct spa_pod_string {
1126 pub pod: spa_pod,
1127}
1128#[allow(clippy::unnecessary_operation, clippy::identity_op)]
1129const _: () = {
1130 ["Size of spa_pod_string"][::std::mem::size_of::<spa_pod_string>() - 8usize];
1131 ["Alignment of spa_pod_string"][::std::mem::align_of::<spa_pod_string>() - 4usize];
1132 ["Offset of field: spa_pod_string::pod"][::std::mem::offset_of!(spa_pod_string, pod) - 0usize];
1133};
1134#[repr(C)]
1135#[derive(Debug, Copy, Clone, PartialEq, Eq)]
1136pub struct spa_pod_bytes {
1137 pub pod: spa_pod,
1138}
1139#[allow(clippy::unnecessary_operation, clippy::identity_op)]
1140const _: () = {
1141 ["Size of spa_pod_bytes"][::std::mem::size_of::<spa_pod_bytes>() - 8usize];
1142 ["Alignment of spa_pod_bytes"][::std::mem::align_of::<spa_pod_bytes>() - 4usize];
1143 ["Offset of field: spa_pod_bytes::pod"][::std::mem::offset_of!(spa_pod_bytes, pod) - 0usize];
1144};
1145#[repr(C)]
1146#[derive(Debug, Copy, Clone, PartialEq, Eq)]
1147pub struct spa_pod_rectangle {
1148 pub pod: spa_pod,
1149 pub value: spa_rectangle,
1150}
1151#[allow(clippy::unnecessary_operation, clippy::identity_op)]
1152const _: () = {
1153 ["Size of spa_pod_rectangle"][::std::mem::size_of::<spa_pod_rectangle>() - 16usize];
1154 ["Alignment of spa_pod_rectangle"][::std::mem::align_of::<spa_pod_rectangle>() - 4usize];
1155 ["Offset of field: spa_pod_rectangle::pod"]
1156 [::std::mem::offset_of!(spa_pod_rectangle, pod) - 0usize];
1157 ["Offset of field: spa_pod_rectangle::value"]
1158 [::std::mem::offset_of!(spa_pod_rectangle, value) - 8usize];
1159};
1160#[repr(C)]
1161#[derive(Debug, Copy, Clone, PartialEq, Eq)]
1162pub struct spa_pod_fraction {
1163 pub pod: spa_pod,
1164 pub value: spa_fraction,
1165}
1166#[allow(clippy::unnecessary_operation, clippy::identity_op)]
1167const _: () = {
1168 ["Size of spa_pod_fraction"][::std::mem::size_of::<spa_pod_fraction>() - 16usize];
1169 ["Alignment of spa_pod_fraction"][::std::mem::align_of::<spa_pod_fraction>() - 4usize];
1170 ["Offset of field: spa_pod_fraction::pod"]
1171 [::std::mem::offset_of!(spa_pod_fraction, pod) - 0usize];
1172 ["Offset of field: spa_pod_fraction::value"]
1173 [::std::mem::offset_of!(spa_pod_fraction, value) - 8usize];
1174};
1175#[repr(C)]
1176#[derive(Debug, Copy, Clone, PartialEq, Eq)]
1177pub struct spa_pod_bitmap {
1178 pub pod: spa_pod,
1179}
1180#[allow(clippy::unnecessary_operation, clippy::identity_op)]
1181const _: () = {
1182 ["Size of spa_pod_bitmap"][::std::mem::size_of::<spa_pod_bitmap>() - 8usize];
1183 ["Alignment of spa_pod_bitmap"][::std::mem::align_of::<spa_pod_bitmap>() - 4usize];
1184 ["Offset of field: spa_pod_bitmap::pod"][::std::mem::offset_of!(spa_pod_bitmap, pod) - 0usize];
1185};
1186#[repr(C)]
1187#[derive(Debug, Copy, Clone, PartialEq, Eq)]
1188pub struct spa_pod_array_body {
1189 pub child: spa_pod,
1190}
1191#[allow(clippy::unnecessary_operation, clippy::identity_op)]
1192const _: () = {
1193 ["Size of spa_pod_array_body"][::std::mem::size_of::<spa_pod_array_body>() - 8usize];
1194 ["Alignment of spa_pod_array_body"][::std::mem::align_of::<spa_pod_array_body>() - 4usize];
1195 ["Offset of field: spa_pod_array_body::child"]
1196 [::std::mem::offset_of!(spa_pod_array_body, child) - 0usize];
1197};
1198#[repr(C)]
1199#[derive(Debug, Copy, Clone, PartialEq, Eq)]
1200pub struct spa_pod_array {
1201 pub pod: spa_pod,
1202 pub body: spa_pod_array_body,
1203}
1204#[allow(clippy::unnecessary_operation, clippy::identity_op)]
1205const _: () = {
1206 ["Size of spa_pod_array"][::std::mem::size_of::<spa_pod_array>() - 16usize];
1207 ["Alignment of spa_pod_array"][::std::mem::align_of::<spa_pod_array>() - 4usize];
1208 ["Offset of field: spa_pod_array::pod"][::std::mem::offset_of!(spa_pod_array, pod) - 0usize];
1209 ["Offset of field: spa_pod_array::body"][::std::mem::offset_of!(spa_pod_array, body) - 8usize];
1210};
1211#[doc = "< no choice, first value is current"]
1212pub const SPA_CHOICE_None: spa_choice_type = 0;
1213#[doc = "< range: default, min, max"]
1214pub const SPA_CHOICE_Range: spa_choice_type = 1;
1215#[doc = "< range with step: default, min, max, step"]
1216pub const SPA_CHOICE_Step: spa_choice_type = 2;
1217#[doc = "< list: default, alternative,..."]
1218pub const SPA_CHOICE_Enum: spa_choice_type = 3;
1219#[doc = "< flags: default, possible flags,..."]
1220pub const SPA_CHOICE_Flags: spa_choice_type = 4;
1221pub type spa_choice_type = ::std::os::raw::c_uint;
1222#[repr(C)]
1223#[derive(Debug, Copy, Clone, PartialEq, Eq)]
1224pub struct spa_pod_choice_body {
1225 #[doc = "< type of choice, one of enum spa_choice_type"]
1226 pub type_: u32,
1227 #[doc = "< extra flags"]
1228 pub flags: u32,
1229 pub child: spa_pod,
1230}
1231#[allow(clippy::unnecessary_operation, clippy::identity_op)]
1232const _: () = {
1233 ["Size of spa_pod_choice_body"][::std::mem::size_of::<spa_pod_choice_body>() - 16usize];
1234 ["Alignment of spa_pod_choice_body"][::std::mem::align_of::<spa_pod_choice_body>() - 4usize];
1235 ["Offset of field: spa_pod_choice_body::type_"]
1236 [::std::mem::offset_of!(spa_pod_choice_body, type_) - 0usize];
1237 ["Offset of field: spa_pod_choice_body::flags"]
1238 [::std::mem::offset_of!(spa_pod_choice_body, flags) - 4usize];
1239 ["Offset of field: spa_pod_choice_body::child"]
1240 [::std::mem::offset_of!(spa_pod_choice_body, child) - 8usize];
1241};
1242#[repr(C)]
1243#[derive(Debug, Copy, Clone, PartialEq, Eq)]
1244pub struct spa_pod_choice {
1245 pub pod: spa_pod,
1246 pub body: spa_pod_choice_body,
1247}
1248#[allow(clippy::unnecessary_operation, clippy::identity_op)]
1249const _: () = {
1250 ["Size of spa_pod_choice"][::std::mem::size_of::<spa_pod_choice>() - 24usize];
1251 ["Alignment of spa_pod_choice"][::std::mem::align_of::<spa_pod_choice>() - 4usize];
1252 ["Offset of field: spa_pod_choice::pod"][::std::mem::offset_of!(spa_pod_choice, pod) - 0usize];
1253 ["Offset of field: spa_pod_choice::body"]
1254 [::std::mem::offset_of!(spa_pod_choice, body) - 8usize];
1255};
1256#[repr(C)]
1257#[derive(Debug, Copy, Clone, PartialEq, Eq)]
1258pub struct spa_pod_struct {
1259 pub pod: spa_pod,
1260}
1261#[allow(clippy::unnecessary_operation, clippy::identity_op)]
1262const _: () = {
1263 ["Size of spa_pod_struct"][::std::mem::size_of::<spa_pod_struct>() - 8usize];
1264 ["Alignment of spa_pod_struct"][::std::mem::align_of::<spa_pod_struct>() - 4usize];
1265 ["Offset of field: spa_pod_struct::pod"][::std::mem::offset_of!(spa_pod_struct, pod) - 0usize];
1266};
1267#[repr(C)]
1268#[derive(Debug, Copy, Clone, PartialEq, Eq)]
1269pub struct spa_pod_object_body {
1270 #[doc = "< one of enum spa_type"]
1271 pub type_: u32,
1272 #[doc = "< id of the object, depends on the object type"]
1273 pub id: u32,
1274}
1275#[allow(clippy::unnecessary_operation, clippy::identity_op)]
1276const _: () = {
1277 ["Size of spa_pod_object_body"][::std::mem::size_of::<spa_pod_object_body>() - 8usize];
1278 ["Alignment of spa_pod_object_body"][::std::mem::align_of::<spa_pod_object_body>() - 4usize];
1279 ["Offset of field: spa_pod_object_body::type_"]
1280 [::std::mem::offset_of!(spa_pod_object_body, type_) - 0usize];
1281 ["Offset of field: spa_pod_object_body::id"]
1282 [::std::mem::offset_of!(spa_pod_object_body, id) - 4usize];
1283};
1284#[repr(C)]
1285#[derive(Debug, Copy, Clone, PartialEq, Eq)]
1286pub struct spa_pod_object {
1287 pub pod: spa_pod,
1288 pub body: spa_pod_object_body,
1289}
1290#[allow(clippy::unnecessary_operation, clippy::identity_op)]
1291const _: () = {
1292 ["Size of spa_pod_object"][::std::mem::size_of::<spa_pod_object>() - 16usize];
1293 ["Alignment of spa_pod_object"][::std::mem::align_of::<spa_pod_object>() - 4usize];
1294 ["Offset of field: spa_pod_object::pod"][::std::mem::offset_of!(spa_pod_object, pod) - 0usize];
1295 ["Offset of field: spa_pod_object::body"]
1296 [::std::mem::offset_of!(spa_pod_object, body) - 8usize];
1297};
1298#[repr(C)]
1299#[derive(Debug, Copy, Clone, PartialEq, Eq)]
1300pub struct spa_pod_pointer_body {
1301 #[doc = "< pointer id, one of enum spa_type"]
1302 pub type_: u32,
1303 pub _padding: u32,
1304 pub value: *const ::std::os::raw::c_void,
1305}
1306#[allow(clippy::unnecessary_operation, clippy::identity_op)]
1307const _: () = {
1308 ["Size of spa_pod_pointer_body"][::std::mem::size_of::<spa_pod_pointer_body>() - 16usize];
1309 ["Alignment of spa_pod_pointer_body"][::std::mem::align_of::<spa_pod_pointer_body>() - 8usize];
1310 ["Offset of field: spa_pod_pointer_body::type_"]
1311 [::std::mem::offset_of!(spa_pod_pointer_body, type_) - 0usize];
1312 ["Offset of field: spa_pod_pointer_body::_padding"]
1313 [::std::mem::offset_of!(spa_pod_pointer_body, _padding) - 4usize];
1314 ["Offset of field: spa_pod_pointer_body::value"]
1315 [::std::mem::offset_of!(spa_pod_pointer_body, value) - 8usize];
1316};
1317#[repr(C)]
1318#[derive(Debug, Copy, Clone, PartialEq, Eq)]
1319pub struct spa_pod_pointer {
1320 pub pod: spa_pod,
1321 pub body: spa_pod_pointer_body,
1322}
1323#[allow(clippy::unnecessary_operation, clippy::identity_op)]
1324const _: () = {
1325 ["Size of spa_pod_pointer"][::std::mem::size_of::<spa_pod_pointer>() - 24usize];
1326 ["Alignment of spa_pod_pointer"][::std::mem::align_of::<spa_pod_pointer>() - 8usize];
1327 ["Offset of field: spa_pod_pointer::pod"]
1328 [::std::mem::offset_of!(spa_pod_pointer, pod) - 0usize];
1329 ["Offset of field: spa_pod_pointer::body"]
1330 [::std::mem::offset_of!(spa_pod_pointer, body) - 8usize];
1331};
1332#[repr(C)]
1333#[derive(Debug, Copy, Clone, PartialEq, Eq)]
1334pub struct spa_pod_fd {
1335 pub pod: spa_pod,
1336 pub value: i64,
1337}
1338#[allow(clippy::unnecessary_operation, clippy::identity_op)]
1339const _: () = {
1340 ["Size of spa_pod_fd"][::std::mem::size_of::<spa_pod_fd>() - 16usize];
1341 ["Alignment of spa_pod_fd"][::std::mem::align_of::<spa_pod_fd>() - 8usize];
1342 ["Offset of field: spa_pod_fd::pod"][::std::mem::offset_of!(spa_pod_fd, pod) - 0usize];
1343 ["Offset of field: spa_pod_fd::value"][::std::mem::offset_of!(spa_pod_fd, value) - 8usize];
1344};
1345#[repr(C)]
1346#[derive(Debug, Copy, Clone, PartialEq, Eq)]
1347pub struct spa_pod_prop {
1348 #[doc = "< key of property, list of valid keys depends on the\n object type"]
1349 pub key: u32,
1350 #[doc = "< flags for property"]
1351 pub flags: u32,
1352 pub value: spa_pod,
1353}
1354#[allow(clippy::unnecessary_operation, clippy::identity_op)]
1355const _: () = {
1356 ["Size of spa_pod_prop"][::std::mem::size_of::<spa_pod_prop>() - 16usize];
1357 ["Alignment of spa_pod_prop"][::std::mem::align_of::<spa_pod_prop>() - 4usize];
1358 ["Offset of field: spa_pod_prop::key"][::std::mem::offset_of!(spa_pod_prop, key) - 0usize];
1359 ["Offset of field: spa_pod_prop::flags"][::std::mem::offset_of!(spa_pod_prop, flags) - 4usize];
1360 ["Offset of field: spa_pod_prop::value"][::std::mem::offset_of!(spa_pod_prop, value) - 8usize];
1361};
1362#[repr(C)]
1363#[derive(Debug, Copy, Clone, PartialEq, Eq)]
1364pub struct spa_pod_control {
1365 #[doc = "< media offset"]
1366 pub offset: u32,
1367 #[doc = "< type of control, enum spa_control_type"]
1368 pub type_: u32,
1369 #[doc = "< control value, depends on type"]
1370 pub value: spa_pod,
1371}
1372#[allow(clippy::unnecessary_operation, clippy::identity_op)]
1373const _: () = {
1374 ["Size of spa_pod_control"][::std::mem::size_of::<spa_pod_control>() - 16usize];
1375 ["Alignment of spa_pod_control"][::std::mem::align_of::<spa_pod_control>() - 4usize];
1376 ["Offset of field: spa_pod_control::offset"]
1377 [::std::mem::offset_of!(spa_pod_control, offset) - 0usize];
1378 ["Offset of field: spa_pod_control::type_"]
1379 [::std::mem::offset_of!(spa_pod_control, type_) - 4usize];
1380 ["Offset of field: spa_pod_control::value"]
1381 [::std::mem::offset_of!(spa_pod_control, value) - 8usize];
1382};
1383#[repr(C)]
1384#[derive(Debug, Copy, Clone, PartialEq, Eq)]
1385pub struct spa_pod_sequence_body {
1386 pub unit: u32,
1387 pub pad: u32,
1388}
1389#[allow(clippy::unnecessary_operation, clippy::identity_op)]
1390const _: () = {
1391 ["Size of spa_pod_sequence_body"][::std::mem::size_of::<spa_pod_sequence_body>() - 8usize];
1392 ["Alignment of spa_pod_sequence_body"]
1393 [::std::mem::align_of::<spa_pod_sequence_body>() - 4usize];
1394 ["Offset of field: spa_pod_sequence_body::unit"]
1395 [::std::mem::offset_of!(spa_pod_sequence_body, unit) - 0usize];
1396 ["Offset of field: spa_pod_sequence_body::pad"]
1397 [::std::mem::offset_of!(spa_pod_sequence_body, pad) - 4usize];
1398};
1399#[doc = " a sequence of timed controls"]
1400#[repr(C)]
1401#[derive(Debug, Copy, Clone, PartialEq, Eq)]
1402pub struct spa_pod_sequence {
1403 pub pod: spa_pod,
1404 pub body: spa_pod_sequence_body,
1405}
1406#[allow(clippy::unnecessary_operation, clippy::identity_op)]
1407const _: () = {
1408 ["Size of spa_pod_sequence"][::std::mem::size_of::<spa_pod_sequence>() - 16usize];
1409 ["Alignment of spa_pod_sequence"][::std::mem::align_of::<spa_pod_sequence>() - 4usize];
1410 ["Offset of field: spa_pod_sequence::pod"]
1411 [::std::mem::offset_of!(spa_pod_sequence, pod) - 0usize];
1412 ["Offset of field: spa_pod_sequence::body"]
1413 [::std::mem::offset_of!(spa_pod_sequence, body) - 8usize];
1414};
1415pub const SPA_META_Invalid: spa_meta_type = 0;
1416#[doc = "< struct spa_meta_header"]
1417pub const SPA_META_Header: spa_meta_type = 1;
1418#[doc = "< struct spa_meta_region with cropping data"]
1419pub const SPA_META_VideoCrop: spa_meta_type = 2;
1420#[doc = "< array of struct spa_meta_region with damage, where an invalid entry or end-of-array marks the end."]
1421pub const SPA_META_VideoDamage: spa_meta_type = 3;
1422#[doc = "< struct spa_meta_bitmap"]
1423pub const SPA_META_Bitmap: spa_meta_type = 4;
1424#[doc = "< struct spa_meta_cursor"]
1425pub const SPA_META_Cursor: spa_meta_type = 5;
1426#[doc = "< metadata contains a spa_meta_control\n associated with the data"]
1427pub const SPA_META_Control: spa_meta_type = 6;
1428#[doc = "< don't write to buffer when count > 0"]
1429pub const SPA_META_Busy: spa_meta_type = 7;
1430#[doc = "< struct spa_meta_transform"]
1431pub const SPA_META_VideoTransform: spa_meta_type = 8;
1432#[doc = "< struct spa_meta_sync_timeline"]
1433pub const SPA_META_SyncTimeline: spa_meta_type = 9;
1434#[doc = "< not part of ABI/API"]
1435pub const _SPA_META_LAST: spa_meta_type = 10;
1436#[doc = " \\addtogroup spa_buffer\n \\{"]
1437pub type spa_meta_type = ::std::os::raw::c_uint;
1438#[doc = " A metadata element.\n\n This structure is available on the buffer structure and contains\n the type of the metadata and a pointer/size to the actual metadata\n itself."]
1439#[repr(C)]
1440#[derive(Debug, Copy, Clone, PartialEq, Eq)]
1441pub struct spa_meta {
1442 #[doc = "< metadata type, one of enum spa_meta_type"]
1443 pub type_: u32,
1444 #[doc = "< size of metadata"]
1445 pub size: u32,
1446 #[doc = "< pointer to metadata"]
1447 pub data: *mut ::std::os::raw::c_void,
1448}
1449#[allow(clippy::unnecessary_operation, clippy::identity_op)]
1450const _: () = {
1451 ["Size of spa_meta"][::std::mem::size_of::<spa_meta>() - 16usize];
1452 ["Alignment of spa_meta"][::std::mem::align_of::<spa_meta>() - 8usize];
1453 ["Offset of field: spa_meta::type_"][::std::mem::offset_of!(spa_meta, type_) - 0usize];
1454 ["Offset of field: spa_meta::size"][::std::mem::offset_of!(spa_meta, size) - 4usize];
1455 ["Offset of field: spa_meta::data"][::std::mem::offset_of!(spa_meta, data) - 8usize];
1456};
1457unsafe extern "C" {
1458 #[link_name = "spa_meta_first_libspa_rs"]
1459 pub fn spa_meta_first(m: *const spa_meta) -> *mut ::std::os::raw::c_void;
1460}
1461unsafe extern "C" {
1462 #[link_name = "spa_meta_end_libspa_rs"]
1463 pub fn spa_meta_end(m: *const spa_meta) -> *mut ::std::os::raw::c_void;
1464}
1465#[doc = " Describes essential buffer header metadata such as flags and\n timestamps."]
1466#[repr(C)]
1467#[derive(Debug, Copy, Clone, PartialEq, Eq)]
1468pub struct spa_meta_header {
1469 #[doc = "< flags"]
1470 pub flags: u32,
1471 #[doc = "< offset in current cycle"]
1472 pub offset: u32,
1473 #[doc = "< presentation timestamp in nanoseconds"]
1474 pub pts: i64,
1475 #[doc = "< decoding timestamp as a difference with pts"]
1476 pub dts_offset: i64,
1477 #[doc = "< sequence number, increments with a\n media specific frequency"]
1478 pub seq: u64,
1479}
1480#[allow(clippy::unnecessary_operation, clippy::identity_op)]
1481const _: () = {
1482 ["Size of spa_meta_header"][::std::mem::size_of::<spa_meta_header>() - 32usize];
1483 ["Alignment of spa_meta_header"][::std::mem::align_of::<spa_meta_header>() - 8usize];
1484 ["Offset of field: spa_meta_header::flags"]
1485 [::std::mem::offset_of!(spa_meta_header, flags) - 0usize];
1486 ["Offset of field: spa_meta_header::offset"]
1487 [::std::mem::offset_of!(spa_meta_header, offset) - 4usize];
1488 ["Offset of field: spa_meta_header::pts"]
1489 [::std::mem::offset_of!(spa_meta_header, pts) - 8usize];
1490 ["Offset of field: spa_meta_header::dts_offset"]
1491 [::std::mem::offset_of!(spa_meta_header, dts_offset) - 16usize];
1492 ["Offset of field: spa_meta_header::seq"]
1493 [::std::mem::offset_of!(spa_meta_header, seq) - 24usize];
1494};
1495#[doc = " metadata structure for Region or an array of these for RegionArray"]
1496#[repr(C)]
1497#[derive(Debug, Copy, Clone, PartialEq, Eq)]
1498pub struct spa_meta_region {
1499 pub region: spa_region,
1500}
1501#[allow(clippy::unnecessary_operation, clippy::identity_op)]
1502const _: () = {
1503 ["Size of spa_meta_region"][::std::mem::size_of::<spa_meta_region>() - 16usize];
1504 ["Alignment of spa_meta_region"][::std::mem::align_of::<spa_meta_region>() - 4usize];
1505 ["Offset of field: spa_meta_region::region"]
1506 [::std::mem::offset_of!(spa_meta_region, region) - 0usize];
1507};
1508unsafe extern "C" {
1509 #[link_name = "spa_meta_region_is_valid_libspa_rs"]
1510 pub fn spa_meta_region_is_valid(m: *const spa_meta_region) -> bool;
1511}
1512#[doc = " Bitmap information\n\n This metadata contains a bitmap image in the given format and size.\n It is typically used for cursor images or other small images that are\n better transferred inline."]
1513#[repr(C)]
1514#[derive(Debug, Copy, Clone, PartialEq, Eq)]
1515pub struct spa_meta_bitmap {
1516 #[doc = "< bitmap video format, one of enum spa_video_format. 0 is\n and invalid format and should be handled as if there is\n no new bitmap information."]
1517 pub format: u32,
1518 #[doc = "< width and height of bitmap"]
1519 pub size: spa_rectangle,
1520 #[doc = "< stride of bitmap data"]
1521 pub stride: i32,
1522 #[doc = "< offset of bitmap data in this structure. An offset of\n 0 means no image data (invisible), an offset >=\n sizeof(struct spa_meta_bitmap) contains valid bitmap\n info."]
1523 pub offset: u32,
1524}
1525#[allow(clippy::unnecessary_operation, clippy::identity_op)]
1526const _: () = {
1527 ["Size of spa_meta_bitmap"][::std::mem::size_of::<spa_meta_bitmap>() - 20usize];
1528 ["Alignment of spa_meta_bitmap"][::std::mem::align_of::<spa_meta_bitmap>() - 4usize];
1529 ["Offset of field: spa_meta_bitmap::format"]
1530 [::std::mem::offset_of!(spa_meta_bitmap, format) - 0usize];
1531 ["Offset of field: spa_meta_bitmap::size"]
1532 [::std::mem::offset_of!(spa_meta_bitmap, size) - 4usize];
1533 ["Offset of field: spa_meta_bitmap::stride"]
1534 [::std::mem::offset_of!(spa_meta_bitmap, stride) - 12usize];
1535 ["Offset of field: spa_meta_bitmap::offset"]
1536 [::std::mem::offset_of!(spa_meta_bitmap, offset) - 16usize];
1537};
1538#[doc = " Cursor information\n\n Metadata to describe the position and appearance of a pointing device."]
1539#[repr(C)]
1540#[derive(Debug, Copy, Clone, PartialEq, Eq)]
1541pub struct spa_meta_cursor {
1542 #[doc = "< cursor id. an id of 0 is an invalid id and means that\n there is no new cursor data"]
1543 pub id: u32,
1544 #[doc = "< extra flags"]
1545 pub flags: u32,
1546 #[doc = "< position on screen"]
1547 pub position: spa_point,
1548 #[doc = "< offsets for hotspot in bitmap, this field has no meaning\n when there is no valid bitmap (see below)"]
1549 pub hotspot: spa_point,
1550 #[doc = "< offset of bitmap meta in this structure. When the offset\n is 0, there is no new bitmap information. When the offset is\n >= sizeof(struct spa_meta_cursor) there is a\n struct spa_meta_bitmap at the offset."]
1551 pub bitmap_offset: u32,
1552}
1553#[allow(clippy::unnecessary_operation, clippy::identity_op)]
1554const _: () = {
1555 ["Size of spa_meta_cursor"][::std::mem::size_of::<spa_meta_cursor>() - 28usize];
1556 ["Alignment of spa_meta_cursor"][::std::mem::align_of::<spa_meta_cursor>() - 4usize];
1557 ["Offset of field: spa_meta_cursor::id"][::std::mem::offset_of!(spa_meta_cursor, id) - 0usize];
1558 ["Offset of field: spa_meta_cursor::flags"]
1559 [::std::mem::offset_of!(spa_meta_cursor, flags) - 4usize];
1560 ["Offset of field: spa_meta_cursor::position"]
1561 [::std::mem::offset_of!(spa_meta_cursor, position) - 8usize];
1562 ["Offset of field: spa_meta_cursor::hotspot"]
1563 [::std::mem::offset_of!(spa_meta_cursor, hotspot) - 16usize];
1564 ["Offset of field: spa_meta_cursor::bitmap_offset"]
1565 [::std::mem::offset_of!(spa_meta_cursor, bitmap_offset) - 24usize];
1566};
1567#[doc = " a timed set of events associated with the buffer"]
1568#[repr(C)]
1569#[derive(Debug, Copy, Clone, PartialEq, Eq)]
1570pub struct spa_meta_control {
1571 pub sequence: spa_pod_sequence,
1572}
1573#[allow(clippy::unnecessary_operation, clippy::identity_op)]
1574const _: () = {
1575 ["Size of spa_meta_control"][::std::mem::size_of::<spa_meta_control>() - 16usize];
1576 ["Alignment of spa_meta_control"][::std::mem::align_of::<spa_meta_control>() - 4usize];
1577 ["Offset of field: spa_meta_control::sequence"]
1578 [::std::mem::offset_of!(spa_meta_control, sequence) - 0usize];
1579};
1580#[doc = " a busy counter for the buffer"]
1581#[repr(C)]
1582#[derive(Debug, Copy, Clone, PartialEq, Eq)]
1583pub struct spa_meta_busy {
1584 pub flags: u32,
1585 #[doc = "< number of users busy with the buffer"]
1586 pub count: u32,
1587}
1588#[allow(clippy::unnecessary_operation, clippy::identity_op)]
1589const _: () = {
1590 ["Size of spa_meta_busy"][::std::mem::size_of::<spa_meta_busy>() - 8usize];
1591 ["Alignment of spa_meta_busy"][::std::mem::align_of::<spa_meta_busy>() - 4usize];
1592 ["Offset of field: spa_meta_busy::flags"]
1593 [::std::mem::offset_of!(spa_meta_busy, flags) - 0usize];
1594 ["Offset of field: spa_meta_busy::count"]
1595 [::std::mem::offset_of!(spa_meta_busy, count) - 4usize];
1596};
1597#[doc = "< no transform"]
1598pub const SPA_META_TRANSFORMATION_None: spa_meta_videotransform_value = 0;
1599#[doc = "< 90 degree counter-clockwise"]
1600pub const SPA_META_TRANSFORMATION_90: spa_meta_videotransform_value = 1;
1601#[doc = "< 180 degree counter-clockwise"]
1602pub const SPA_META_TRANSFORMATION_180: spa_meta_videotransform_value = 2;
1603#[doc = "< 270 degree counter-clockwise"]
1604pub const SPA_META_TRANSFORMATION_270: spa_meta_videotransform_value = 3;
1605#[doc = "< 180 degree flipped around the vertical axis. Equivalent\n to a reflexion through the vertical line splitting the\n buffer in two equal sized parts"]
1606pub const SPA_META_TRANSFORMATION_Flipped: spa_meta_videotransform_value = 4;
1607#[doc = "< flip then rotate around 90 degree counter-clockwise"]
1608pub const SPA_META_TRANSFORMATION_Flipped90: spa_meta_videotransform_value = 5;
1609#[doc = "< flip then rotate around 180 degree counter-clockwise"]
1610pub const SPA_META_TRANSFORMATION_Flipped180: spa_meta_videotransform_value = 6;
1611#[doc = "< flip then rotate around 270 degree counter-clockwise"]
1612pub const SPA_META_TRANSFORMATION_Flipped270: spa_meta_videotransform_value = 7;
1613pub type spa_meta_videotransform_value = ::std::os::raw::c_uint;
1614#[doc = " a transformation of the buffer"]
1615#[repr(C)]
1616#[derive(Debug, Copy, Clone, PartialEq, Eq)]
1617pub struct spa_meta_videotransform {
1618 #[doc = "< orientation transformation that was applied to the buffer,\n one of enum spa_meta_videotransform_value"]
1619 pub transform: u32,
1620}
1621#[allow(clippy::unnecessary_operation, clippy::identity_op)]
1622const _: () = {
1623 ["Size of spa_meta_videotransform"][::std::mem::size_of::<spa_meta_videotransform>() - 4usize];
1624 ["Alignment of spa_meta_videotransform"]
1625 [::std::mem::align_of::<spa_meta_videotransform>() - 4usize];
1626 ["Offset of field: spa_meta_videotransform::transform"]
1627 [::std::mem::offset_of!(spa_meta_videotransform, transform) - 0usize];
1628};
1629#[doc = " A timeline point for explicit sync\n\n Metadata to describe the time on the timeline when the buffer\n can be acquired and when it can be reused.\n\n This metadata will require negotiation of 2 extra fds for the acquire\n and release timelines respectively. One way to achieve this is to place\n this metadata as SPA_PARAM_BUFFERS_metaType when negotiating a buffer\n layout with 2 extra fds."]
1630#[repr(C)]
1631#[derive(Debug, Copy, Clone, PartialEq, Eq)]
1632pub struct spa_meta_sync_timeline {
1633 pub flags: u32,
1634 pub padding: u32,
1635 #[doc = "< the timeline acquire point, this is when the data\n can be accessed."]
1636 pub acquire_point: u64,
1637 #[doc = "< the timeline release point, this timeline point should\n be signaled when the data is no longer accessed."]
1638 pub release_point: u64,
1639}
1640#[allow(clippy::unnecessary_operation, clippy::identity_op)]
1641const _: () = {
1642 ["Size of spa_meta_sync_timeline"][::std::mem::size_of::<spa_meta_sync_timeline>() - 24usize];
1643 ["Alignment of spa_meta_sync_timeline"]
1644 [::std::mem::align_of::<spa_meta_sync_timeline>() - 8usize];
1645 ["Offset of field: spa_meta_sync_timeline::flags"]
1646 [::std::mem::offset_of!(spa_meta_sync_timeline, flags) - 0usize];
1647 ["Offset of field: spa_meta_sync_timeline::padding"]
1648 [::std::mem::offset_of!(spa_meta_sync_timeline, padding) - 4usize];
1649 ["Offset of field: spa_meta_sync_timeline::acquire_point"]
1650 [::std::mem::offset_of!(spa_meta_sync_timeline, acquire_point) - 8usize];
1651 ["Offset of field: spa_meta_sync_timeline::release_point"]
1652 [::std::mem::offset_of!(spa_meta_sync_timeline, release_point) - 16usize];
1653};
1654pub const SPA_DATA_Invalid: spa_data_type = 0;
1655#[doc = "< pointer to memory, the data field in\n struct spa_data is set."]
1656pub const SPA_DATA_MemPtr: spa_data_type = 1;
1657#[doc = "< memfd, mmap to get to memory."]
1658pub const SPA_DATA_MemFd: spa_data_type = 2;
1659#[doc = "< fd to dmabuf memory. This might not be readily\n mappable (unless the MAPPABLE flag is set) and should\n normally be handled with DMABUF apis."]
1660pub const SPA_DATA_DmaBuf: spa_data_type = 3;
1661#[doc = "< memory is identified with an id. The actual memory\n can be obtained in some other way and can be identified\n with this id."]
1662pub const SPA_DATA_MemId: spa_data_type = 4;
1663#[doc = "< a syncobj, usually requires a spa_meta_sync_timeline metadata\n with timeline points."]
1664pub const SPA_DATA_SyncObj: spa_data_type = 5;
1665#[doc = "< not part of ABI"]
1666pub const _SPA_DATA_LAST: spa_data_type = 6;
1667#[doc = " \\addtogroup spa_buffer\n \\{"]
1668pub type spa_data_type = ::std::os::raw::c_uint;
1669#[doc = " Chunk of memory, can change for each buffer"]
1670#[repr(C)]
1671#[derive(Debug, Copy, Clone, PartialEq, Eq)]
1672pub struct spa_chunk {
1673 #[doc = "< offset of valid data. Should be taken\n modulo the data maxsize to get the offset\n in the data memory."]
1674 pub offset: u32,
1675 #[doc = "< size of valid data. Should be clamped to\n maxsize."]
1676 pub size: u32,
1677 #[doc = "< stride of valid data"]
1678 pub stride: i32,
1679 #[doc = "< chunk flags"]
1680 pub flags: i32,
1681}
1682#[allow(clippy::unnecessary_operation, clippy::identity_op)]
1683const _: () = {
1684 ["Size of spa_chunk"][::std::mem::size_of::<spa_chunk>() - 16usize];
1685 ["Alignment of spa_chunk"][::std::mem::align_of::<spa_chunk>() - 4usize];
1686 ["Offset of field: spa_chunk::offset"][::std::mem::offset_of!(spa_chunk, offset) - 0usize];
1687 ["Offset of field: spa_chunk::size"][::std::mem::offset_of!(spa_chunk, size) - 4usize];
1688 ["Offset of field: spa_chunk::stride"][::std::mem::offset_of!(spa_chunk, stride) - 8usize];
1689 ["Offset of field: spa_chunk::flags"][::std::mem::offset_of!(spa_chunk, flags) - 12usize];
1690};
1691#[doc = " Data for a buffer this stays constant for a buffer"]
1692#[repr(C)]
1693#[derive(Debug, Copy, Clone, PartialEq, Eq)]
1694pub struct spa_data {
1695 #[doc = "< memory type, one of enum spa_data_type, when\n allocating memory, the type contains a bitmask\n of allowed types. SPA_ID_INVALID is a special\n value for the allocator to indicate that the\n other side did not explicitly specify any\n supported data types. It should probably use\n a memory type that does not require special\n handling in addition to simple mmap/munmap."]
1696 pub type_: u32,
1697 #[doc = "< data flags"]
1698 pub flags: u32,
1699 #[doc = "< optional fd for data"]
1700 pub fd: i64,
1701 #[doc = "< offset to map fd at, this is page aligned"]
1702 pub mapoffset: u32,
1703 #[doc = "< max size of data"]
1704 pub maxsize: u32,
1705 #[doc = "< optional data pointer"]
1706 pub data: *mut ::std::os::raw::c_void,
1707 #[doc = "< valid chunk of memory"]
1708 pub chunk: *mut spa_chunk,
1709}
1710#[allow(clippy::unnecessary_operation, clippy::identity_op)]
1711const _: () = {
1712 ["Size of spa_data"][::std::mem::size_of::<spa_data>() - 40usize];
1713 ["Alignment of spa_data"][::std::mem::align_of::<spa_data>() - 8usize];
1714 ["Offset of field: spa_data::type_"][::std::mem::offset_of!(spa_data, type_) - 0usize];
1715 ["Offset of field: spa_data::flags"][::std::mem::offset_of!(spa_data, flags) - 4usize];
1716 ["Offset of field: spa_data::fd"][::std::mem::offset_of!(spa_data, fd) - 8usize];
1717 ["Offset of field: spa_data::mapoffset"][::std::mem::offset_of!(spa_data, mapoffset) - 16usize];
1718 ["Offset of field: spa_data::maxsize"][::std::mem::offset_of!(spa_data, maxsize) - 20usize];
1719 ["Offset of field: spa_data::data"][::std::mem::offset_of!(spa_data, data) - 24usize];
1720 ["Offset of field: spa_data::chunk"][::std::mem::offset_of!(spa_data, chunk) - 32usize];
1721};
1722#[doc = " A Buffer"]
1723#[repr(C)]
1724#[derive(Debug, Copy, Clone, PartialEq, Eq)]
1725pub struct spa_buffer {
1726 #[doc = "< number of metadata"]
1727 pub n_metas: u32,
1728 #[doc = "< number of data members"]
1729 pub n_datas: u32,
1730 #[doc = "< array of metadata"]
1731 pub metas: *mut spa_meta,
1732 #[doc = "< array of data members"]
1733 pub datas: *mut spa_data,
1734}
1735#[allow(clippy::unnecessary_operation, clippy::identity_op)]
1736const _: () = {
1737 ["Size of spa_buffer"][::std::mem::size_of::<spa_buffer>() - 24usize];
1738 ["Alignment of spa_buffer"][::std::mem::align_of::<spa_buffer>() - 8usize];
1739 ["Offset of field: spa_buffer::n_metas"][::std::mem::offset_of!(spa_buffer, n_metas) - 0usize];
1740 ["Offset of field: spa_buffer::n_datas"][::std::mem::offset_of!(spa_buffer, n_datas) - 4usize];
1741 ["Offset of field: spa_buffer::metas"][::std::mem::offset_of!(spa_buffer, metas) - 8usize];
1742 ["Offset of field: spa_buffer::datas"][::std::mem::offset_of!(spa_buffer, datas) - 16usize];
1743};
1744unsafe extern "C" {
1745 #[doc = " Find metadata in a buffer"]
1746 #[link_name = "spa_buffer_find_meta_libspa_rs"]
1747 pub fn spa_buffer_find_meta(b: *const spa_buffer, type_: u32) -> *mut spa_meta;
1748}
1749unsafe extern "C" {
1750 #[link_name = "spa_buffer_find_meta_data_libspa_rs"]
1751 pub fn spa_buffer_find_meta_data(
1752 b: *const spa_buffer,
1753 type_: u32,
1754 size: usize,
1755 ) -> *mut ::std::os::raw::c_void;
1756}
1757#[doc = " information about the buffer layout"]
1758#[repr(C)]
1759#[derive(Debug, Copy, Clone, PartialEq, Eq)]
1760pub struct spa_buffer_alloc_info {
1761 pub flags: u32,
1762 #[doc = "< max of all alignments"]
1763 pub max_align: u32,
1764 pub n_metas: u32,
1765 pub n_datas: u32,
1766 pub metas: *mut spa_meta,
1767 pub datas: *mut spa_data,
1768 pub data_aligns: *mut u32,
1769 #[doc = "< size of the struct spa_buffer and inlined meta/chunk/data"]
1770 pub skel_size: usize,
1771 #[doc = "< size of the meta if not inlined"]
1772 pub meta_size: usize,
1773 #[doc = "< size of the chunk if not inlined"]
1774 pub chunk_size: usize,
1775 #[doc = "< size of the data if not inlined"]
1776 pub data_size: usize,
1777 #[doc = "< size of the total memory if not inlined"]
1778 pub mem_size: usize,
1779}
1780#[allow(clippy::unnecessary_operation, clippy::identity_op)]
1781const _: () = {
1782 ["Size of spa_buffer_alloc_info"][::std::mem::size_of::<spa_buffer_alloc_info>() - 80usize];
1783 ["Alignment of spa_buffer_alloc_info"]
1784 [::std::mem::align_of::<spa_buffer_alloc_info>() - 8usize];
1785 ["Offset of field: spa_buffer_alloc_info::flags"]
1786 [::std::mem::offset_of!(spa_buffer_alloc_info, flags) - 0usize];
1787 ["Offset of field: spa_buffer_alloc_info::max_align"]
1788 [::std::mem::offset_of!(spa_buffer_alloc_info, max_align) - 4usize];
1789 ["Offset of field: spa_buffer_alloc_info::n_metas"]
1790 [::std::mem::offset_of!(spa_buffer_alloc_info, n_metas) - 8usize];
1791 ["Offset of field: spa_buffer_alloc_info::n_datas"]
1792 [::std::mem::offset_of!(spa_buffer_alloc_info, n_datas) - 12usize];
1793 ["Offset of field: spa_buffer_alloc_info::metas"]
1794 [::std::mem::offset_of!(spa_buffer_alloc_info, metas) - 16usize];
1795 ["Offset of field: spa_buffer_alloc_info::datas"]
1796 [::std::mem::offset_of!(spa_buffer_alloc_info, datas) - 24usize];
1797 ["Offset of field: spa_buffer_alloc_info::data_aligns"]
1798 [::std::mem::offset_of!(spa_buffer_alloc_info, data_aligns) - 32usize];
1799 ["Offset of field: spa_buffer_alloc_info::skel_size"]
1800 [::std::mem::offset_of!(spa_buffer_alloc_info, skel_size) - 40usize];
1801 ["Offset of field: spa_buffer_alloc_info::meta_size"]
1802 [::std::mem::offset_of!(spa_buffer_alloc_info, meta_size) - 48usize];
1803 ["Offset of field: spa_buffer_alloc_info::chunk_size"]
1804 [::std::mem::offset_of!(spa_buffer_alloc_info, chunk_size) - 56usize];
1805 ["Offset of field: spa_buffer_alloc_info::data_size"]
1806 [::std::mem::offset_of!(spa_buffer_alloc_info, data_size) - 64usize];
1807 ["Offset of field: spa_buffer_alloc_info::mem_size"]
1808 [::std::mem::offset_of!(spa_buffer_alloc_info, mem_size) - 72usize];
1809};
1810unsafe extern "C" {
1811 #[doc = " Fill buffer allocation information\n\n Fill \\a info with allocation information needed to allocate buffers\n with the given number of metadata and data members.\n\n The required size of the skeleton (the struct spa_buffer) information\n and the memory (for the metadata, chunk and buffer memory) will be\n calculated.\n\n The flags member in \\a info should be configured before calling this\n functions.\n\n \\param info the information to fill\n \\param n_metas the number of metadatas for the buffer\n \\param metas an array of metadata items\n \\param n_datas the number of datas for the buffer\n \\param datas an array of \\a n_datas items\n \\param data_aligns \\a n_datas alignments\n \\return 0 on success."]
1812 #[link_name = "spa_buffer_alloc_fill_info_libspa_rs"]
1813 pub fn spa_buffer_alloc_fill_info(
1814 info: *mut spa_buffer_alloc_info,
1815 n_metas: u32,
1816 metas: *mut spa_meta,
1817 n_datas: u32,
1818 datas: *mut spa_data,
1819 data_aligns: *mut u32,
1820 ) -> ::std::os::raw::c_int;
1821}
1822unsafe extern "C" {
1823 #[doc = " Fill skeleton and data according to the allocation info\n\n Use the allocation info to create a struct \\ref spa_buffer into\n \\a skel_mem and \\a data_mem.\n\n Depending on the flags given when calling \\ref\n spa_buffer_alloc_fill_info(), the buffer meta, chunk and memory\n will be referenced in either skel_mem or data_mem.\n\n \\param info an allocation info\n \\param skel_mem memory to hold the struct \\ref spa_buffer and the\n pointers to meta, chunk and memory.\n \\param data_mem memory to hold the meta, chunk and memory\n \\return a struct \\ref spa_buffer in \\a skel_mem"]
1824 #[link_name = "spa_buffer_alloc_layout_libspa_rs"]
1825 pub fn spa_buffer_alloc_layout(
1826 info: *mut spa_buffer_alloc_info,
1827 skel_mem: *mut ::std::os::raw::c_void,
1828 data_mem: *mut ::std::os::raw::c_void,
1829 ) -> *mut spa_buffer;
1830}
1831unsafe extern "C" {
1832 #[doc = " Layout an array of buffers\n\n Use the allocation info to layout the memory of an array of buffers.\n\n \\a skel_mem should point to at least info->skel_size * \\a n_buffers bytes\n of memory.\n \\a data_mem should point to at least info->mem_size * \\a n_buffers bytes\n of memory.\n\n \\param info the allocation info for one buffer\n \\param n_buffers the number of buffers to create\n \\param buffers a array with space to hold \\a n_buffers pointers to buffers\n \\param skel_mem memory for the struct \\ref spa_buffer\n \\param data_mem memory for the meta, chunk, memory of the buffer if not\n\t\tinlined in the skeleton.\n \\return 0 on success.\n"]
1833 #[link_name = "spa_buffer_alloc_layout_array_libspa_rs"]
1834 pub fn spa_buffer_alloc_layout_array(
1835 info: *mut spa_buffer_alloc_info,
1836 n_buffers: u32,
1837 buffers: *mut *mut spa_buffer,
1838 skel_mem: *mut ::std::os::raw::c_void,
1839 data_mem: *mut ::std::os::raw::c_void,
1840 ) -> ::std::os::raw::c_int;
1841}
1842unsafe extern "C" {
1843 #[doc = " Allocate an array of buffers\n\n Allocate \\a n_buffers with the given metadata, memory and alignment\n information.\n\n The buffer array, structures, data and metadata will all be allocated\n in one block of memory with the proper requested alignment.\n\n \\param n_buffers the number of buffers to create\n \\param flags extra flags\n \\param n_metas number of metadatas\n \\param metas \\a n_metas metadata specification\n \\param n_datas number of datas\n \\param datas \\a n_datas memory specification\n \\param data_aligns \\a n_datas alignment specifications\n \\returns an array of \\a n_buffers pointers to struct \\ref spa_buffer\n with the given metadata, data and alignment or NULL when\n allocation failed.\n"]
1844 #[link_name = "spa_buffer_alloc_array_libspa_rs"]
1845 pub fn spa_buffer_alloc_array(
1846 n_buffers: u32,
1847 flags: u32,
1848 n_metas: u32,
1849 metas: *mut spa_meta,
1850 n_datas: u32,
1851 datas: *mut spa_data,
1852 data_aligns: *mut u32,
1853 ) -> *mut *mut spa_buffer;
1854}
1855pub const SPA_CONTROL_Invalid: spa_control_type = 0;
1856#[doc = "< SPA_TYPE_OBJECT_Props"]
1857pub const SPA_CONTROL_Properties: spa_control_type = 1;
1858#[doc = "< spa_pod_bytes with raw midi data (deprecated, use SPA_CONTROL_UMP)"]
1859pub const SPA_CONTROL_Midi: spa_control_type = 2;
1860#[doc = "< spa_pod_bytes with an OSC packet"]
1861pub const SPA_CONTROL_OSC: spa_control_type = 3;
1862#[doc = "< spa_pod_bytes with raw UMP (universal MIDI packet)\n data. The UMP 32 bit words are stored in native endian\n format."]
1863pub const SPA_CONTROL_UMP: spa_control_type = 4;
1864#[doc = "< not part of ABI"]
1865pub const _SPA_CONTROL_LAST: spa_control_type = 5;
1866#[doc = " Different Control types"]
1867pub type spa_control_type = ::std::os::raw::c_uint;
1868#[repr(C)]
1869#[derive(Debug, Copy, Clone, PartialEq, Eq)]
1870pub struct spa_debug_context {
1871 pub log: ::std::option::Option<
1872 unsafe extern "C" fn(ctx: *mut spa_debug_context, fmt: *const ::std::os::raw::c_char, ...),
1873 >,
1874}
1875#[allow(clippy::unnecessary_operation, clippy::identity_op)]
1876const _: () = {
1877 ["Size of spa_debug_context"][::std::mem::size_of::<spa_debug_context>() - 8usize];
1878 ["Alignment of spa_debug_context"][::std::mem::align_of::<spa_debug_context>() - 8usize];
1879 ["Offset of field: spa_debug_context::log"]
1880 [::std::mem::offset_of!(spa_debug_context, log) - 0usize];
1881};
1882unsafe extern "C" {
1883 #[link_name = "spa_debugc_error_location_libspa_rs"]
1884 pub fn spa_debugc_error_location(c: *mut spa_debug_context, loc: *mut spa_error_location);
1885}
1886unsafe extern "C" {
1887 #[link_name = "spa_debugc_mem_libspa_rs"]
1888 pub fn spa_debugc_mem(
1889 ctx: *mut spa_debug_context,
1890 indent: ::std::os::raw::c_int,
1891 data: *const ::std::os::raw::c_void,
1892 size: usize,
1893 ) -> ::std::os::raw::c_int;
1894}
1895unsafe extern "C" {
1896 #[link_name = "spa_debug_mem_libspa_rs"]
1897 pub fn spa_debug_mem(
1898 indent: ::std::os::raw::c_int,
1899 data: *const ::std::os::raw::c_void,
1900 size: usize,
1901 ) -> ::std::os::raw::c_int;
1902}
1903#[doc = " \\addtogroup spa_pod\n \\{"]
1904#[repr(C)]
1905#[derive(Debug, Copy, Clone, PartialEq, Eq)]
1906pub struct spa_event_body {
1907 pub body: spa_pod_object_body,
1908}
1909#[allow(clippy::unnecessary_operation, clippy::identity_op)]
1910const _: () = {
1911 ["Size of spa_event_body"][::std::mem::size_of::<spa_event_body>() - 8usize];
1912 ["Alignment of spa_event_body"][::std::mem::align_of::<spa_event_body>() - 4usize];
1913 ["Offset of field: spa_event_body::body"]
1914 [::std::mem::offset_of!(spa_event_body, body) - 0usize];
1915};
1916#[repr(C)]
1917#[derive(Debug, Copy, Clone, PartialEq, Eq)]
1918pub struct spa_event {
1919 pub pod: spa_pod,
1920 pub body: spa_event_body,
1921}
1922#[allow(clippy::unnecessary_operation, clippy::identity_op)]
1923const _: () = {
1924 ["Size of spa_event"][::std::mem::size_of::<spa_event>() - 16usize];
1925 ["Alignment of spa_event"][::std::mem::align_of::<spa_event>() - 4usize];
1926 ["Offset of field: spa_event::pod"][::std::mem::offset_of!(spa_event, pod) - 0usize];
1927 ["Offset of field: spa_event::body"][::std::mem::offset_of!(spa_event, body) - 8usize];
1928};
1929pub const SPA_DEVICE_EVENT_ObjectConfig: spa_device_event = 0;
1930#[doc = " \\addtogroup spa_device\n \\{"]
1931pub type spa_device_event = ::std::os::raw::c_uint;
1932pub const SPA_EVENT_DEVICE_START: spa_event_device = 0;
1933pub const SPA_EVENT_DEVICE_Object: spa_event_device = 1;
1934pub const SPA_EVENT_DEVICE_Props: spa_event_device = 2;
1935pub type spa_event_device = ::std::os::raw::c_uint;
1936#[doc = " \\addtogroup spa_pod\n \\{"]
1937#[repr(C)]
1938#[derive(Debug, Copy, Clone, PartialEq, Eq)]
1939pub struct spa_command_body {
1940 pub body: spa_pod_object_body,
1941}
1942#[allow(clippy::unnecessary_operation, clippy::identity_op)]
1943const _: () = {
1944 ["Size of spa_command_body"][::std::mem::size_of::<spa_command_body>() - 8usize];
1945 ["Alignment of spa_command_body"][::std::mem::align_of::<spa_command_body>() - 4usize];
1946 ["Offset of field: spa_command_body::body"]
1947 [::std::mem::offset_of!(spa_command_body, body) - 0usize];
1948};
1949#[repr(C)]
1950#[derive(Debug, Copy, Clone, PartialEq, Eq)]
1951pub struct spa_command {
1952 pub pod: spa_pod,
1953 pub body: spa_command_body,
1954}
1955#[allow(clippy::unnecessary_operation, clippy::identity_op)]
1956const _: () = {
1957 ["Size of spa_command"][::std::mem::size_of::<spa_command>() - 16usize];
1958 ["Alignment of spa_command"][::std::mem::align_of::<spa_command>() - 4usize];
1959 ["Offset of field: spa_command::pod"][::std::mem::offset_of!(spa_command, pod) - 0usize];
1960 ["Offset of field: spa_command::body"][::std::mem::offset_of!(spa_command, body) - 8usize];
1961};
1962#[doc = "< suspend a node, this removes all configured\n formats and closes any devices"]
1963pub const SPA_NODE_COMMAND_Suspend: spa_node_command = 0;
1964#[doc = "< pause a node. this makes it stop emitting\n scheduling events"]
1965pub const SPA_NODE_COMMAND_Pause: spa_node_command = 1;
1966#[doc = "< start a node, this makes it start emitting\n scheduling events"]
1967pub const SPA_NODE_COMMAND_Start: spa_node_command = 2;
1968pub const SPA_NODE_COMMAND_Enable: spa_node_command = 3;
1969pub const SPA_NODE_COMMAND_Disable: spa_node_command = 4;
1970pub const SPA_NODE_COMMAND_Flush: spa_node_command = 5;
1971pub const SPA_NODE_COMMAND_Drain: spa_node_command = 6;
1972pub const SPA_NODE_COMMAND_Marker: spa_node_command = 7;
1973#[doc = "< begin a set of parameter enumerations or\n configuration that require the device to\n remain opened, like query formats and then\n set a format"]
1974pub const SPA_NODE_COMMAND_ParamBegin: spa_node_command = 8;
1975#[doc = "< end a transaction"]
1976pub const SPA_NODE_COMMAND_ParamEnd: spa_node_command = 9;
1977#[doc = "< Sent to a driver when some other node emitted\n the RequestProcess event."]
1978pub const SPA_NODE_COMMAND_RequestProcess: spa_node_command = 10;
1979pub type spa_node_command = ::std::os::raw::c_uint;
1980pub const SPA_NODE_EVENT_Error: spa_node_event = 0;
1981pub const SPA_NODE_EVENT_Buffering: spa_node_event = 1;
1982pub const SPA_NODE_EVENT_RequestRefresh: spa_node_event = 2;
1983pub const SPA_NODE_EVENT_RequestProcess: spa_node_event = 3;
1984pub type spa_node_event = ::std::os::raw::c_uint;
1985pub const SPA_EVENT_NODE_START: spa_event_node = 0;
1986pub type spa_event_node = ::std::os::raw::c_uint;
1987pub const SPA_IO_Invalid: spa_io_type = 0;
1988#[doc = "< area to exchange buffers, struct spa_io_buffers"]
1989pub const SPA_IO_Buffers: spa_io_type = 1;
1990#[doc = "< expected byte range, struct spa_io_range (currently not used in PipeWire)"]
1991pub const SPA_IO_Range: spa_io_type = 2;
1992#[doc = "< area to update clock information, struct spa_io_clock"]
1993pub const SPA_IO_Clock: spa_io_type = 3;
1994#[doc = "< latency reporting, struct spa_io_latency (currently not used in\n PipeWire). \\see spa_param_latency"]
1995pub const SPA_IO_Latency: spa_io_type = 4;
1996#[doc = "< area for control messages, struct spa_io_sequence"]
1997pub const SPA_IO_Control: spa_io_type = 5;
1998#[doc = "< area for notify messages, struct spa_io_sequence"]
1999pub const SPA_IO_Notify: spa_io_type = 6;
2000#[doc = "< position information in the graph, struct spa_io_position"]
2001pub const SPA_IO_Position: spa_io_type = 7;
2002#[doc = "< rate matching between nodes, struct spa_io_rate_match"]
2003pub const SPA_IO_RateMatch: spa_io_type = 8;
2004#[doc = "< memory pointer, struct spa_io_memory (currently not used in PipeWire)"]
2005pub const SPA_IO_Memory: spa_io_type = 9;
2006#[doc = "< async area to exchange buffers, struct spa_io_async_buffers"]
2007pub const SPA_IO_AsyncBuffers: spa_io_type = 10;
2008#[doc = " Different IO area types"]
2009pub type spa_io_type = ::std::os::raw::c_uint;
2010#[doc = " IO area to exchange buffers.\n\n A set of buffers should first be configured on the node/port.\n Further references to those buffers will be made by using the\n id of the buffer.\n\n If status is SPA_STATUS_OK, the host should ignore\n the io area.\n\n If status is SPA_STATUS_NEED_DATA, the host should:\n 1) recycle the buffer in buffer_id, if possible\n 2) prepare a new buffer and place the id in buffer_id.\n\n If status is SPA_STATUS_HAVE_DATA, the host should consume\n the buffer in buffer_id and set the state to\n SPA_STATUS_NEED_DATA when new data is requested.\n\n If status is SPA_STATUS_STOPPED, some error occurred on the\n port.\n\n If status is SPA_STATUS_DRAINED, data from the io area was\n used to drain.\n\n Status can also be a negative errno value to indicate errors.\n such as:\n -EINVAL: buffer_id is invalid\n -EPIPE: no more buffers available"]
2011#[repr(C)]
2012#[derive(Debug, Copy, Clone, PartialEq, Eq)]
2013pub struct spa_io_buffers {
2014 #[doc = "< the status code"]
2015 pub status: i32,
2016 #[doc = "< a buffer id"]
2017 pub buffer_id: u32,
2018}
2019#[allow(clippy::unnecessary_operation, clippy::identity_op)]
2020const _: () = {
2021 ["Size of spa_io_buffers"][::std::mem::size_of::<spa_io_buffers>() - 8usize];
2022 ["Alignment of spa_io_buffers"][::std::mem::align_of::<spa_io_buffers>() - 4usize];
2023 ["Offset of field: spa_io_buffers::status"]
2024 [::std::mem::offset_of!(spa_io_buffers, status) - 0usize];
2025 ["Offset of field: spa_io_buffers::buffer_id"]
2026 [::std::mem::offset_of!(spa_io_buffers, buffer_id) - 4usize];
2027};
2028#[doc = " IO area to exchange a memory region"]
2029#[repr(C)]
2030#[derive(Debug, Copy, Clone, PartialEq, Eq)]
2031pub struct spa_io_memory {
2032 #[doc = "< the status code"]
2033 pub status: i32,
2034 #[doc = "< the size of \\a data"]
2035 pub size: u32,
2036 #[doc = "< a memory pointer"]
2037 pub data: *mut ::std::os::raw::c_void,
2038}
2039#[allow(clippy::unnecessary_operation, clippy::identity_op)]
2040const _: () = {
2041 ["Size of spa_io_memory"][::std::mem::size_of::<spa_io_memory>() - 16usize];
2042 ["Alignment of spa_io_memory"][::std::mem::align_of::<spa_io_memory>() - 8usize];
2043 ["Offset of field: spa_io_memory::status"]
2044 [::std::mem::offset_of!(spa_io_memory, status) - 0usize];
2045 ["Offset of field: spa_io_memory::size"][::std::mem::offset_of!(spa_io_memory, size) - 4usize];
2046 ["Offset of field: spa_io_memory::data"][::std::mem::offset_of!(spa_io_memory, data) - 8usize];
2047};
2048#[doc = " A range, suitable for input ports that can suggest a range to output ports"]
2049#[repr(C)]
2050#[derive(Debug, Copy, Clone, PartialEq, Eq)]
2051pub struct spa_io_range {
2052 #[doc = "< offset in range"]
2053 pub offset: u64,
2054 #[doc = "< minimum size of data"]
2055 pub min_size: u32,
2056 #[doc = "< maximum size of data"]
2057 pub max_size: u32,
2058}
2059#[allow(clippy::unnecessary_operation, clippy::identity_op)]
2060const _: () = {
2061 ["Size of spa_io_range"][::std::mem::size_of::<spa_io_range>() - 16usize];
2062 ["Alignment of spa_io_range"][::std::mem::align_of::<spa_io_range>() - 8usize];
2063 ["Offset of field: spa_io_range::offset"]
2064 [::std::mem::offset_of!(spa_io_range, offset) - 0usize];
2065 ["Offset of field: spa_io_range::min_size"]
2066 [::std::mem::offset_of!(spa_io_range, min_size) - 8usize];
2067 ["Offset of field: spa_io_range::max_size"]
2068 [::std::mem::offset_of!(spa_io_range, max_size) - 12usize];
2069};
2070#[doc = " Absolute time reporting.\n\n Nodes that can report clocking information will receive this io block.\n The application sets the id. This is usually set as part of the\n position information but can also be set separately.\n\n The clock counts the elapsed time according to the clock provider\n since the provider was last started.\n\n Driver nodes are supposed to update the contents of \\ref SPA_IO_Clock before\n signaling the start of a graph cycle. These updated clock values become\n visible to other nodes in \\ref SPA_IO_Position. Non-driver nodes do\n not need to update the contents of their \\ref SPA_IO_Clock.\n\n The host generally gives each node a separate \\ref spa_io_clock in \\ref\n SPA_IO_Clock, so that updates made by the driver are not visible in the\n contents of \\ref SPA_IO_Clock of other nodes. Instead, \\ref SPA_IO_Position\n is used to look up the current graph time.\n\n A node is a driver when \\ref spa_io_clock.id in \\ref SPA_IO_Clock and\n \\ref spa_io_position.clock.id in \\ref SPA_IO_Position are the same."]
2071#[repr(C)]
2072#[derive(Debug, Copy, Clone, PartialEq)]
2073pub struct spa_io_clock {
2074 #[doc = "< Clock flags"]
2075 pub flags: u32,
2076 #[doc = "< Unique clock id, set by host application"]
2077 pub id: u32,
2078 #[doc = "< Clock name prefixed with API, set by node when it receives\n \\ref SPA_IO_Clock. The clock name is unique per clock and\n can be used to check if nodes share the same clock."]
2079 pub name: [::std::os::raw::c_char; 64usize],
2080 #[doc = "< Time in nanoseconds against monotonic clock\n (CLOCK_MONOTONIC). This fields reflects a real time instant\n in the past. The value may have jitter."]
2081 pub nsec: u64,
2082 #[doc = "< Rate for position/duration/delay/xrun"]
2083 pub rate: spa_fraction,
2084 #[doc = "< Current position, in samples @ \\ref rate"]
2085 pub position: u64,
2086 #[doc = "< Duration of current cycle, in samples @ \\ref rate"]
2087 pub duration: u64,
2088 #[doc = "< Delay between position and hardware, in samples @ \\ref rate"]
2089 pub delay: i64,
2090 #[doc = "< Rate difference between clock and monotonic time, as a ratio of\n clock speeds."]
2091 pub rate_diff: f64,
2092 #[doc = "< Estimated next wakeup time in nanoseconds.\n This time is a logical start time of the next cycle, and\n is not necessarily in the future."]
2093 pub next_nsec: u64,
2094 #[doc = "< Target rate of next cycle"]
2095 pub target_rate: spa_fraction,
2096 #[doc = "< Target duration of next cycle"]
2097 pub target_duration: u64,
2098 #[doc = "< Seq counter. must be equal at start and\n end of read and lower bit must be 0"]
2099 pub target_seq: u32,
2100 #[doc = "< incremented each time the graph is started"]
2101 pub cycle: u32,
2102 #[doc = "< Estimated accumulated xrun duration"]
2103 pub xrun: u64,
2104}
2105#[allow(clippy::unnecessary_operation, clippy::identity_op)]
2106const _: () = {
2107 ["Size of spa_io_clock"][::std::mem::size_of::<spa_io_clock>() - 160usize];
2108 ["Alignment of spa_io_clock"][::std::mem::align_of::<spa_io_clock>() - 8usize];
2109 ["Offset of field: spa_io_clock::flags"][::std::mem::offset_of!(spa_io_clock, flags) - 0usize];
2110 ["Offset of field: spa_io_clock::id"][::std::mem::offset_of!(spa_io_clock, id) - 4usize];
2111 ["Offset of field: spa_io_clock::name"][::std::mem::offset_of!(spa_io_clock, name) - 8usize];
2112 ["Offset of field: spa_io_clock::nsec"][::std::mem::offset_of!(spa_io_clock, nsec) - 72usize];
2113 ["Offset of field: spa_io_clock::rate"][::std::mem::offset_of!(spa_io_clock, rate) - 80usize];
2114 ["Offset of field: spa_io_clock::position"]
2115 [::std::mem::offset_of!(spa_io_clock, position) - 88usize];
2116 ["Offset of field: spa_io_clock::duration"]
2117 [::std::mem::offset_of!(spa_io_clock, duration) - 96usize];
2118 ["Offset of field: spa_io_clock::delay"]
2119 [::std::mem::offset_of!(spa_io_clock, delay) - 104usize];
2120 ["Offset of field: spa_io_clock::rate_diff"]
2121 [::std::mem::offset_of!(spa_io_clock, rate_diff) - 112usize];
2122 ["Offset of field: spa_io_clock::next_nsec"]
2123 [::std::mem::offset_of!(spa_io_clock, next_nsec) - 120usize];
2124 ["Offset of field: spa_io_clock::target_rate"]
2125 [::std::mem::offset_of!(spa_io_clock, target_rate) - 128usize];
2126 ["Offset of field: spa_io_clock::target_duration"]
2127 [::std::mem::offset_of!(spa_io_clock, target_duration) - 136usize];
2128 ["Offset of field: spa_io_clock::target_seq"]
2129 [::std::mem::offset_of!(spa_io_clock, target_seq) - 144usize];
2130 ["Offset of field: spa_io_clock::cycle"]
2131 [::std::mem::offset_of!(spa_io_clock, cycle) - 148usize];
2132 ["Offset of field: spa_io_clock::xrun"][::std::mem::offset_of!(spa_io_clock, xrun) - 152usize];
2133};
2134#[repr(C)]
2135#[derive(Debug, Copy, Clone, PartialEq, Eq)]
2136pub struct spa_io_video_size {
2137 #[doc = "< optional flags"]
2138 pub flags: u32,
2139 #[doc = "< video stride in bytes"]
2140 pub stride: u32,
2141 #[doc = "< the video size"]
2142 pub size: spa_rectangle,
2143 #[doc = "< the minimum framerate, the cycle duration is\n always smaller to ensure there is only one\n video frame per cycle."]
2144 pub framerate: spa_fraction,
2145 pub padding: [u32; 4usize],
2146}
2147#[allow(clippy::unnecessary_operation, clippy::identity_op)]
2148const _: () = {
2149 ["Size of spa_io_video_size"][::std::mem::size_of::<spa_io_video_size>() - 40usize];
2150 ["Alignment of spa_io_video_size"][::std::mem::align_of::<spa_io_video_size>() - 4usize];
2151 ["Offset of field: spa_io_video_size::flags"]
2152 [::std::mem::offset_of!(spa_io_video_size, flags) - 0usize];
2153 ["Offset of field: spa_io_video_size::stride"]
2154 [::std::mem::offset_of!(spa_io_video_size, stride) - 4usize];
2155 ["Offset of field: spa_io_video_size::size"]
2156 [::std::mem::offset_of!(spa_io_video_size, size) - 8usize];
2157 ["Offset of field: spa_io_video_size::framerate"]
2158 [::std::mem::offset_of!(spa_io_video_size, framerate) - 16usize];
2159 ["Offset of field: spa_io_video_size::padding"]
2160 [::std::mem::offset_of!(spa_io_video_size, padding) - 24usize];
2161};
2162#[doc = " Latency reporting\n\n Currently not used in PipeWire. Instead, \\see spa_param_latency"]
2163#[repr(C)]
2164#[derive(Debug, Copy, Clone, PartialEq, Eq)]
2165pub struct spa_io_latency {
2166 #[doc = "< rate for min/max"]
2167 pub rate: spa_fraction,
2168 #[doc = "< min latency"]
2169 pub min: u64,
2170 #[doc = "< max latency"]
2171 pub max: u64,
2172}
2173#[allow(clippy::unnecessary_operation, clippy::identity_op)]
2174const _: () = {
2175 ["Size of spa_io_latency"][::std::mem::size_of::<spa_io_latency>() - 24usize];
2176 ["Alignment of spa_io_latency"][::std::mem::align_of::<spa_io_latency>() - 8usize];
2177 ["Offset of field: spa_io_latency::rate"]
2178 [::std::mem::offset_of!(spa_io_latency, rate) - 0usize];
2179 ["Offset of field: spa_io_latency::min"][::std::mem::offset_of!(spa_io_latency, min) - 8usize];
2180 ["Offset of field: spa_io_latency::max"][::std::mem::offset_of!(spa_io_latency, max) - 16usize];
2181};
2182#[doc = " control stream, io area for SPA_IO_Control and SPA_IO_Notify"]
2183#[repr(C)]
2184#[derive(Debug, Copy, Clone, PartialEq, Eq)]
2185pub struct spa_io_sequence {
2186 #[doc = "< sequence of timed events"]
2187 pub sequence: spa_pod_sequence,
2188}
2189#[allow(clippy::unnecessary_operation, clippy::identity_op)]
2190const _: () = {
2191 ["Size of spa_io_sequence"][::std::mem::size_of::<spa_io_sequence>() - 16usize];
2192 ["Alignment of spa_io_sequence"][::std::mem::align_of::<spa_io_sequence>() - 4usize];
2193 ["Offset of field: spa_io_sequence::sequence"]
2194 [::std::mem::offset_of!(spa_io_sequence, sequence) - 0usize];
2195};
2196#[doc = " bar and beat segment"]
2197#[repr(C)]
2198#[derive(Debug, Copy, Clone, PartialEq)]
2199pub struct spa_io_segment_bar {
2200 #[doc = "< extra flags"]
2201 pub flags: u32,
2202 #[doc = "< offset in segment of this beat"]
2203 pub offset: u32,
2204 #[doc = "< time signature numerator"]
2205 pub signature_num: f32,
2206 #[doc = "< time signature denominator"]
2207 pub signature_denom: f32,
2208 #[doc = "< beats per minute"]
2209 pub bpm: f64,
2210 #[doc = "< current beat in segment"]
2211 pub beat: f64,
2212 pub bar_start_tick: f64,
2213 pub ticks_per_beat: f64,
2214 pub padding: [u32; 4usize],
2215}
2216#[allow(clippy::unnecessary_operation, clippy::identity_op)]
2217const _: () = {
2218 ["Size of spa_io_segment_bar"][::std::mem::size_of::<spa_io_segment_bar>() - 64usize];
2219 ["Alignment of spa_io_segment_bar"][::std::mem::align_of::<spa_io_segment_bar>() - 8usize];
2220 ["Offset of field: spa_io_segment_bar::flags"]
2221 [::std::mem::offset_of!(spa_io_segment_bar, flags) - 0usize];
2222 ["Offset of field: spa_io_segment_bar::offset"]
2223 [::std::mem::offset_of!(spa_io_segment_bar, offset) - 4usize];
2224 ["Offset of field: spa_io_segment_bar::signature_num"]
2225 [::std::mem::offset_of!(spa_io_segment_bar, signature_num) - 8usize];
2226 ["Offset of field: spa_io_segment_bar::signature_denom"]
2227 [::std::mem::offset_of!(spa_io_segment_bar, signature_denom) - 12usize];
2228 ["Offset of field: spa_io_segment_bar::bpm"]
2229 [::std::mem::offset_of!(spa_io_segment_bar, bpm) - 16usize];
2230 ["Offset of field: spa_io_segment_bar::beat"]
2231 [::std::mem::offset_of!(spa_io_segment_bar, beat) - 24usize];
2232 ["Offset of field: spa_io_segment_bar::bar_start_tick"]
2233 [::std::mem::offset_of!(spa_io_segment_bar, bar_start_tick) - 32usize];
2234 ["Offset of field: spa_io_segment_bar::ticks_per_beat"]
2235 [::std::mem::offset_of!(spa_io_segment_bar, ticks_per_beat) - 40usize];
2236 ["Offset of field: spa_io_segment_bar::padding"]
2237 [::std::mem::offset_of!(spa_io_segment_bar, padding) - 48usize];
2238};
2239#[doc = " video frame segment"]
2240#[repr(C)]
2241#[derive(Debug, Copy, Clone, PartialEq, Eq)]
2242pub struct spa_io_segment_video {
2243 #[doc = "< flags"]
2244 pub flags: u32,
2245 #[doc = "< offset in segment"]
2246 pub offset: u32,
2247 pub framerate: spa_fraction,
2248 pub hours: u32,
2249 pub minutes: u32,
2250 pub seconds: u32,
2251 pub frames: u32,
2252 #[doc = "< 0 for progressive, 1 and 2 for interlaced"]
2253 pub field_count: u32,
2254 pub padding: [u32; 11usize],
2255}
2256#[allow(clippy::unnecessary_operation, clippy::identity_op)]
2257const _: () = {
2258 ["Size of spa_io_segment_video"][::std::mem::size_of::<spa_io_segment_video>() - 80usize];
2259 ["Alignment of spa_io_segment_video"][::std::mem::align_of::<spa_io_segment_video>() - 4usize];
2260 ["Offset of field: spa_io_segment_video::flags"]
2261 [::std::mem::offset_of!(spa_io_segment_video, flags) - 0usize];
2262 ["Offset of field: spa_io_segment_video::offset"]
2263 [::std::mem::offset_of!(spa_io_segment_video, offset) - 4usize];
2264 ["Offset of field: spa_io_segment_video::framerate"]
2265 [::std::mem::offset_of!(spa_io_segment_video, framerate) - 8usize];
2266 ["Offset of field: spa_io_segment_video::hours"]
2267 [::std::mem::offset_of!(spa_io_segment_video, hours) - 16usize];
2268 ["Offset of field: spa_io_segment_video::minutes"]
2269 [::std::mem::offset_of!(spa_io_segment_video, minutes) - 20usize];
2270 ["Offset of field: spa_io_segment_video::seconds"]
2271 [::std::mem::offset_of!(spa_io_segment_video, seconds) - 24usize];
2272 ["Offset of field: spa_io_segment_video::frames"]
2273 [::std::mem::offset_of!(spa_io_segment_video, frames) - 28usize];
2274 ["Offset of field: spa_io_segment_video::field_count"]
2275 [::std::mem::offset_of!(spa_io_segment_video, field_count) - 32usize];
2276 ["Offset of field: spa_io_segment_video::padding"]
2277 [::std::mem::offset_of!(spa_io_segment_video, padding) - 36usize];
2278};
2279#[doc = " A segment converts a running time to a segment (stream) position.\n\n The segment position is valid when the current running time is between\n start and start + duration. The position is then\n calculated as:\n\n (running time - start) * rate + position;\n\n Support for looping is done by specifying the LOOPING flags with a\n non-zero duration. When the running time reaches start + duration,\n duration is added to start and the loop repeats.\n\n Care has to be taken when the running time + clock.duration extends\n past the start + duration from the segment; the user should correctly\n wrap around and partially repeat the loop in the current cycle.\n\n Extra information can be placed in the segment by setting the valid flags\n and filling up the corresponding structures."]
2280#[repr(C)]
2281#[derive(Debug, Copy, Clone, PartialEq)]
2282pub struct spa_io_segment {
2283 pub version: u32,
2284 #[doc = "< extra flags"]
2285 pub flags: u32,
2286 #[doc = "< value of running time when this\n info is active. Can be in the future for\n pending changes. It does not have to be in\n exact multiples of the clock duration."]
2287 pub start: u64,
2288 #[doc = "< duration when this info becomes invalid expressed\n in running time. If the duration is 0, this\n segment extends to the next segment. If the\n segment becomes invalid and the looping flag is\n set, the segment repeats."]
2289 pub duration: u64,
2290 #[doc = "< overall rate of the segment, can be negative for\n backwards time reporting."]
2291 pub rate: f64,
2292 #[doc = "< The position when the running time == start.\n can be invalid when the owner of the extra segment\n information has not yet made the mapping."]
2293 pub position: u64,
2294 pub bar: spa_io_segment_bar,
2295 pub video: spa_io_segment_video,
2296}
2297#[allow(clippy::unnecessary_operation, clippy::identity_op)]
2298const _: () = {
2299 ["Size of spa_io_segment"][::std::mem::size_of::<spa_io_segment>() - 184usize];
2300 ["Alignment of spa_io_segment"][::std::mem::align_of::<spa_io_segment>() - 8usize];
2301 ["Offset of field: spa_io_segment::version"]
2302 [::std::mem::offset_of!(spa_io_segment, version) - 0usize];
2303 ["Offset of field: spa_io_segment::flags"]
2304 [::std::mem::offset_of!(spa_io_segment, flags) - 4usize];
2305 ["Offset of field: spa_io_segment::start"]
2306 [::std::mem::offset_of!(spa_io_segment, start) - 8usize];
2307 ["Offset of field: spa_io_segment::duration"]
2308 [::std::mem::offset_of!(spa_io_segment, duration) - 16usize];
2309 ["Offset of field: spa_io_segment::rate"]
2310 [::std::mem::offset_of!(spa_io_segment, rate) - 24usize];
2311 ["Offset of field: spa_io_segment::position"]
2312 [::std::mem::offset_of!(spa_io_segment, position) - 32usize];
2313 ["Offset of field: spa_io_segment::bar"][::std::mem::offset_of!(spa_io_segment, bar) - 40usize];
2314 ["Offset of field: spa_io_segment::video"]
2315 [::std::mem::offset_of!(spa_io_segment, video) - 104usize];
2316};
2317pub const SPA_IO_POSITION_STATE_STOPPED: spa_io_position_state = 0;
2318pub const SPA_IO_POSITION_STATE_STARTING: spa_io_position_state = 1;
2319pub const SPA_IO_POSITION_STATE_RUNNING: spa_io_position_state = 2;
2320pub type spa_io_position_state = ::std::os::raw::c_uint;
2321#[doc = " The position information adds extra meaning to the raw clock times.\n\n It is set on all nodes in \\ref SPA_IO_Position, and the contents of \\ref\n spa_io_position.clock contain the clock updates made by the driving node in\n the graph in its \\ref SPA_IO_Clock. Also, \\ref spa_io_position.clock.id\n will contain the clock id of the driving node in the graph.\n\n The position clock indicates the logical start time of the current graph\n cycle.\n\n The position information contains 1 or more segments that convert the\n raw clock times to a stream time. They are sorted based on their\n start times, and thus the order in which they will activate in\n the future. This makes it possible to look ahead in the scheduled\n segments and anticipate the changes in the timeline."]
2322#[repr(C)]
2323#[derive(Debug, Copy, Clone, PartialEq)]
2324pub struct spa_io_position {
2325 #[doc = "< clock position of driver, always valid and\n read only"]
2326 pub clock: spa_io_clock,
2327 #[doc = "< size of the video in the current cycle"]
2328 pub video: spa_io_video_size,
2329 #[doc = "< an offset to subtract from the clock position\n to get a running time. This is the time that\n the state has been in the RUNNING state and the\n time that should be used to compare the segment\n start values against."]
2330 pub offset: i64,
2331 #[doc = "< one of enum spa_io_position_state"]
2332 pub state: u32,
2333 #[doc = "< number of segments"]
2334 pub n_segments: u32,
2335 #[doc = "< segments"]
2336 pub segments: [spa_io_segment; 8usize],
2337}
2338#[allow(clippy::unnecessary_operation, clippy::identity_op)]
2339const _: () = {
2340 ["Size of spa_io_position"][::std::mem::size_of::<spa_io_position>() - 1688usize];
2341 ["Alignment of spa_io_position"][::std::mem::align_of::<spa_io_position>() - 8usize];
2342 ["Offset of field: spa_io_position::clock"]
2343 [::std::mem::offset_of!(spa_io_position, clock) - 0usize];
2344 ["Offset of field: spa_io_position::video"]
2345 [::std::mem::offset_of!(spa_io_position, video) - 160usize];
2346 ["Offset of field: spa_io_position::offset"]
2347 [::std::mem::offset_of!(spa_io_position, offset) - 200usize];
2348 ["Offset of field: spa_io_position::state"]
2349 [::std::mem::offset_of!(spa_io_position, state) - 208usize];
2350 ["Offset of field: spa_io_position::n_segments"]
2351 [::std::mem::offset_of!(spa_io_position, n_segments) - 212usize];
2352 ["Offset of field: spa_io_position::segments"]
2353 [::std::mem::offset_of!(spa_io_position, segments) - 216usize];
2354};
2355#[doc = " Rate matching.\n\n It is usually set on the nodes that process resampled data, by\n the component (audioadapter) that handles resampling between graph\n and node rates. The \\a flags and \\a rate fields may be modified by the node.\n\n The node can request a correction to the resampling rate in its process(), by setting\n \\ref SPA_IO_RATE_MATCH_ACTIVE on \\a flags, and setting \\a rate to the desired rate\n correction. Usually the rate is obtained from DLL or other adaptive mechanism that\n e.g. drives the node buffer fill level toward a specific value.\n\n When resampling to (graph->node) direction, the number of samples produced\n by the resampler varies on each cycle, as the rates are not commensurate.\n\n When resampling to (node->graph) direction, the number of samples consumed by the\n resampler varies. Node output ports in process() should produce \\a size number of\n samples to match what the resampler needs to produce one graph quantum of output\n samples.\n\n Resampling filters introduce processing delay, given by \\a delay and \\a delay_frac, in\n samples at node rate. The delay varies on each cycle e.g. when resampling between\n noncommensurate rates.\n\n The first sample output (graph->node) or consumed (node->graph) by the resampler is\n offset by \\a delay + \\a delay_frac / 1e9 node samples relative to the nominal graph\n cycle start position:\n\n \\code{.unparsed}\n first_resampled_sample_nsec =\n\tfirst_original_sample_nsec\n\t- (rate_match->delay * SPA_NSEC_PER_SEC + rate_match->delay_frac) / node_rate\n \\endcode"]
2356#[repr(C)]
2357#[derive(Debug, Copy, Clone, PartialEq)]
2358pub struct spa_io_rate_match {
2359 #[doc = "< resampling delay, in samples at\n node rate"]
2360 pub delay: u32,
2361 #[doc = "< requested input size for resampler"]
2362 pub size: u32,
2363 #[doc = "< rate for resampler (set by node)"]
2364 pub rate: f64,
2365 #[doc = "< extra flags (set by node)"]
2366 pub flags: u32,
2367 #[doc = "< resampling delay fractional part,\n in units of nanosamples (1/10^9 sample) at node rate"]
2368 pub delay_frac: i32,
2369 pub padding: [u32; 6usize],
2370}
2371#[allow(clippy::unnecessary_operation, clippy::identity_op)]
2372const _: () = {
2373 ["Size of spa_io_rate_match"][::std::mem::size_of::<spa_io_rate_match>() - 48usize];
2374 ["Alignment of spa_io_rate_match"][::std::mem::align_of::<spa_io_rate_match>() - 8usize];
2375 ["Offset of field: spa_io_rate_match::delay"]
2376 [::std::mem::offset_of!(spa_io_rate_match, delay) - 0usize];
2377 ["Offset of field: spa_io_rate_match::size"]
2378 [::std::mem::offset_of!(spa_io_rate_match, size) - 4usize];
2379 ["Offset of field: spa_io_rate_match::rate"]
2380 [::std::mem::offset_of!(spa_io_rate_match, rate) - 8usize];
2381 ["Offset of field: spa_io_rate_match::flags"]
2382 [::std::mem::offset_of!(spa_io_rate_match, flags) - 16usize];
2383 ["Offset of field: spa_io_rate_match::delay_frac"]
2384 [::std::mem::offset_of!(spa_io_rate_match, delay_frac) - 20usize];
2385 ["Offset of field: spa_io_rate_match::padding"]
2386 [::std::mem::offset_of!(spa_io_rate_match, padding) - 24usize];
2387};
2388#[doc = " async buffers"]
2389#[repr(C)]
2390#[derive(Debug, Copy, Clone, PartialEq, Eq)]
2391pub struct spa_io_async_buffers {
2392 #[doc = "< async buffers, writers write to current (cycle+1)&1,\n readers read from (cycle)&1"]
2393 pub buffers: [spa_io_buffers; 2usize],
2394}
2395#[allow(clippy::unnecessary_operation, clippy::identity_op)]
2396const _: () = {
2397 ["Size of spa_io_async_buffers"][::std::mem::size_of::<spa_io_async_buffers>() - 16usize];
2398 ["Alignment of spa_io_async_buffers"][::std::mem::align_of::<spa_io_async_buffers>() - 4usize];
2399 ["Offset of field: spa_io_async_buffers::buffers"]
2400 [::std::mem::offset_of!(spa_io_async_buffers, buffers) - 0usize];
2401};
2402#[doc = "< invalid"]
2403pub const SPA_PARAM_Invalid: spa_param_type = 0;
2404#[doc = "< property information as SPA_TYPE_OBJECT_PropInfo"]
2405pub const SPA_PARAM_PropInfo: spa_param_type = 1;
2406#[doc = "< properties as SPA_TYPE_OBJECT_Props"]
2407pub const SPA_PARAM_Props: spa_param_type = 2;
2408#[doc = "< available formats as SPA_TYPE_OBJECT_Format"]
2409pub const SPA_PARAM_EnumFormat: spa_param_type = 3;
2410#[doc = "< configured format as SPA_TYPE_OBJECT_Format"]
2411pub const SPA_PARAM_Format: spa_param_type = 4;
2412#[doc = "< buffer configurations as SPA_TYPE_OBJECT_ParamBuffers"]
2413pub const SPA_PARAM_Buffers: spa_param_type = 5;
2414#[doc = "< allowed metadata for buffers as SPA_TYPE_OBJECT_ParamMeta"]
2415pub const SPA_PARAM_Meta: spa_param_type = 6;
2416#[doc = "< configurable IO areas as SPA_TYPE_OBJECT_ParamIO"]
2417pub const SPA_PARAM_IO: spa_param_type = 7;
2418#[doc = "< profile enumeration as SPA_TYPE_OBJECT_ParamProfile"]
2419pub const SPA_PARAM_EnumProfile: spa_param_type = 8;
2420#[doc = "< profile configuration as SPA_TYPE_OBJECT_ParamProfile"]
2421pub const SPA_PARAM_Profile: spa_param_type = 9;
2422#[doc = "< port configuration enumeration as SPA_TYPE_OBJECT_ParamPortConfig"]
2423pub const SPA_PARAM_EnumPortConfig: spa_param_type = 10;
2424#[doc = "< port configuration as SPA_TYPE_OBJECT_ParamPortConfig"]
2425pub const SPA_PARAM_PortConfig: spa_param_type = 11;
2426#[doc = "< routing enumeration as SPA_TYPE_OBJECT_ParamRoute"]
2427pub const SPA_PARAM_EnumRoute: spa_param_type = 12;
2428#[doc = "< routing configuration as SPA_TYPE_OBJECT_ParamRoute"]
2429pub const SPA_PARAM_Route: spa_param_type = 13;
2430#[doc = "< Control parameter, a SPA_TYPE_Sequence"]
2431pub const SPA_PARAM_Control: spa_param_type = 14;
2432#[doc = "< latency reporting, a SPA_TYPE_OBJECT_ParamLatency"]
2433pub const SPA_PARAM_Latency: spa_param_type = 15;
2434#[doc = "< processing latency, a SPA_TYPE_OBJECT_ParamProcessLatency"]
2435pub const SPA_PARAM_ProcessLatency: spa_param_type = 16;
2436#[doc = "< tag reporting, a SPA_TYPE_OBJECT_ParamTag. Since 0.3.79"]
2437pub const SPA_PARAM_Tag: spa_param_type = 17;
2438#[doc = " different parameter types that can be queried"]
2439pub type spa_param_type = ::std::os::raw::c_uint;
2440#[doc = " information about a parameter"]
2441#[repr(C)]
2442#[derive(Debug, Copy, Clone, PartialEq, Eq)]
2443pub struct spa_param_info {
2444 #[doc = "< enum spa_param_type"]
2445 pub id: u32,
2446 pub flags: u32,
2447 #[doc = "< private user field. You can use this to keep\n state."]
2448 pub user: u32,
2449 #[doc = "< private seq field. You can use this to keep\n state of a pending update."]
2450 pub seq: i32,
2451 pub padding: [u32; 4usize],
2452}
2453#[allow(clippy::unnecessary_operation, clippy::identity_op)]
2454const _: () = {
2455 ["Size of spa_param_info"][::std::mem::size_of::<spa_param_info>() - 32usize];
2456 ["Alignment of spa_param_info"][::std::mem::align_of::<spa_param_info>() - 4usize];
2457 ["Offset of field: spa_param_info::id"][::std::mem::offset_of!(spa_param_info, id) - 0usize];
2458 ["Offset of field: spa_param_info::flags"]
2459 [::std::mem::offset_of!(spa_param_info, flags) - 4usize];
2460 ["Offset of field: spa_param_info::user"]
2461 [::std::mem::offset_of!(spa_param_info, user) - 8usize];
2462 ["Offset of field: spa_param_info::seq"][::std::mem::offset_of!(spa_param_info, seq) - 12usize];
2463 ["Offset of field: spa_param_info::padding"]
2464 [::std::mem::offset_of!(spa_param_info, padding) - 16usize];
2465};
2466#[doc = "< unknown bitorder"]
2467pub const SPA_PARAM_BITORDER_unknown: spa_param_bitorder = 0;
2468#[doc = "< most significant bit"]
2469pub const SPA_PARAM_BITORDER_msb: spa_param_bitorder = 1;
2470#[doc = "< least significant bit"]
2471pub const SPA_PARAM_BITORDER_lsb: spa_param_bitorder = 2;
2472pub type spa_param_bitorder = ::std::os::raw::c_uint;
2473#[doc = "< unknown availability"]
2474pub const SPA_PARAM_AVAILABILITY_unknown: spa_param_availability = 0;
2475#[doc = "< not available"]
2476pub const SPA_PARAM_AVAILABILITY_no: spa_param_availability = 1;
2477#[doc = "< available"]
2478pub const SPA_PARAM_AVAILABILITY_yes: spa_param_availability = 2;
2479pub type spa_param_availability = ::std::os::raw::c_uint;
2480pub const SPA_PARAM_BUFFERS_START: spa_param_buffers = 0;
2481#[doc = "< number of buffers (Int)"]
2482pub const SPA_PARAM_BUFFERS_buffers: spa_param_buffers = 1;
2483#[doc = "< number of data blocks per buffer (Int)"]
2484pub const SPA_PARAM_BUFFERS_blocks: spa_param_buffers = 2;
2485#[doc = "< size of a data block memory (Int)"]
2486pub const SPA_PARAM_BUFFERS_size: spa_param_buffers = 3;
2487#[doc = "< stride of data block memory (Int)"]
2488pub const SPA_PARAM_BUFFERS_stride: spa_param_buffers = 4;
2489#[doc = "< alignment of data block memory (Int)"]
2490pub const SPA_PARAM_BUFFERS_align: spa_param_buffers = 5;
2491#[doc = "< possible memory types (flags choice Int, mask of enum spa_data_type)"]
2492pub const SPA_PARAM_BUFFERS_dataType: spa_param_buffers = 6;
2493#[doc = "< required meta data types (Int, mask of enum spa_meta_type)"]
2494pub const SPA_PARAM_BUFFERS_metaType: spa_param_buffers = 7;
2495#[doc = " properties for SPA_TYPE_OBJECT_ParamBuffers"]
2496pub type spa_param_buffers = ::std::os::raw::c_uint;
2497pub const SPA_PARAM_META_START: spa_param_meta = 0;
2498#[doc = "< the metadata, one of enum spa_meta_type (Id enum spa_meta_type)"]
2499pub const SPA_PARAM_META_type: spa_param_meta = 1;
2500#[doc = "< the expected maximum size the meta (Int)"]
2501pub const SPA_PARAM_META_size: spa_param_meta = 2;
2502#[doc = " properties for SPA_TYPE_OBJECT_ParamMeta"]
2503pub type spa_param_meta = ::std::os::raw::c_uint;
2504pub const SPA_PARAM_IO_START: spa_param_io = 0;
2505#[doc = "< type ID, uniquely identifies the io area (Id enum spa_io_type)"]
2506pub const SPA_PARAM_IO_id: spa_param_io = 1;
2507#[doc = "< size of the io area (Int)"]
2508pub const SPA_PARAM_IO_size: spa_param_io = 2;
2509#[doc = " properties for SPA_TYPE_OBJECT_ParamIO"]
2510pub type spa_param_io = ::std::os::raw::c_uint;
2511pub const SPA_PARAM_PROFILE_START: spa_param_profile = 0;
2512#[doc = "< profile index (Int)"]
2513pub const SPA_PARAM_PROFILE_index: spa_param_profile = 1;
2514#[doc = "< profile name (String)"]
2515pub const SPA_PARAM_PROFILE_name: spa_param_profile = 2;
2516#[doc = "< profile description (String)"]
2517pub const SPA_PARAM_PROFILE_description: spa_param_profile = 3;
2518#[doc = "< profile priority (Int)"]
2519pub const SPA_PARAM_PROFILE_priority: spa_param_profile = 4;
2520#[doc = "< availability of the profile\n (Id enum spa_param_availability)"]
2521pub const SPA_PARAM_PROFILE_available: spa_param_profile = 5;
2522#[doc = "< info (Struct(\n\t\t Int : n_items,\n\t\t (String : key,\n\t\t String : value)*))"]
2523pub const SPA_PARAM_PROFILE_info: spa_param_profile = 6;
2524#[doc = "< node classes provided by this profile\n (Struct(\n\t Int : number of items following\n Struct(\n String : class name (eg. \"Audio/Source\"),\n Int : number of nodes\n String : property (eg. \"card.profile.devices\"),\n Array of Int: device indexes\n )*))"]
2525pub const SPA_PARAM_PROFILE_classes: spa_param_profile = 7;
2526#[doc = "< If profile should be saved (Bool)"]
2527pub const SPA_PARAM_PROFILE_save: spa_param_profile = 8;
2528#[doc = " properties for SPA_TYPE_OBJECT_ParamProfile"]
2529pub type spa_param_profile = ::std::os::raw::c_uint;
2530#[doc = "< no configuration"]
2531pub const SPA_PARAM_PORT_CONFIG_MODE_none: spa_param_port_config_mode = 0;
2532#[doc = "< passthrough configuration"]
2533pub const SPA_PARAM_PORT_CONFIG_MODE_passthrough: spa_param_port_config_mode = 1;
2534#[doc = "< convert configuration"]
2535pub const SPA_PARAM_PORT_CONFIG_MODE_convert: spa_param_port_config_mode = 2;
2536#[doc = "< dsp configuration, depending on the external\n format. For audio, ports will be configured for\n the given number of channels with F32 format."]
2537pub const SPA_PARAM_PORT_CONFIG_MODE_dsp: spa_param_port_config_mode = 3;
2538pub type spa_param_port_config_mode = ::std::os::raw::c_uint;
2539pub const SPA_PARAM_PORT_CONFIG_START: spa_param_port_config = 0;
2540#[doc = "< (Id enum spa_direction) direction"]
2541pub const SPA_PARAM_PORT_CONFIG_direction: spa_param_port_config = 1;
2542#[doc = "< (Id enum spa_param_port_config_mode) mode"]
2543pub const SPA_PARAM_PORT_CONFIG_mode: spa_param_port_config = 2;
2544#[doc = "< (Bool) enable monitor output ports on input ports"]
2545pub const SPA_PARAM_PORT_CONFIG_monitor: spa_param_port_config = 3;
2546#[doc = "< (Bool) enable control ports"]
2547pub const SPA_PARAM_PORT_CONFIG_control: spa_param_port_config = 4;
2548#[doc = "< (Object) format filter"]
2549pub const SPA_PARAM_PORT_CONFIG_format: spa_param_port_config = 5;
2550#[doc = " properties for SPA_TYPE_OBJECT_ParamPortConfig"]
2551pub type spa_param_port_config = ::std::os::raw::c_uint;
2552pub const SPA_PARAM_ROUTE_START: spa_param_route = 0;
2553#[doc = "< index of the routing destination (Int)"]
2554pub const SPA_PARAM_ROUTE_index: spa_param_route = 1;
2555#[doc = "< direction, input/output (Id enum spa_direction)"]
2556pub const SPA_PARAM_ROUTE_direction: spa_param_route = 2;
2557#[doc = "< device id (Int)"]
2558pub const SPA_PARAM_ROUTE_device: spa_param_route = 3;
2559#[doc = "< name of the routing destination (String)"]
2560pub const SPA_PARAM_ROUTE_name: spa_param_route = 4;
2561#[doc = "< description of the destination (String)"]
2562pub const SPA_PARAM_ROUTE_description: spa_param_route = 5;
2563#[doc = "< priority of the destination (Int)"]
2564pub const SPA_PARAM_ROUTE_priority: spa_param_route = 6;
2565#[doc = "< availability of the destination\n (Id enum spa_param_availability)"]
2566pub const SPA_PARAM_ROUTE_available: spa_param_route = 7;
2567#[doc = "< info (Struct(\n\t\t Int : n_items,\n\t\t (String : key,\n\t\t String : value)*))"]
2568pub const SPA_PARAM_ROUTE_info: spa_param_route = 8;
2569#[doc = "< associated profile indexes (Array of Int)"]
2570pub const SPA_PARAM_ROUTE_profiles: spa_param_route = 9;
2571#[doc = "< properties SPA_TYPE_OBJECT_Props"]
2572pub const SPA_PARAM_ROUTE_props: spa_param_route = 10;
2573#[doc = "< associated device indexes (Array of Int)"]
2574pub const SPA_PARAM_ROUTE_devices: spa_param_route = 11;
2575#[doc = "< profile id (Int)"]
2576pub const SPA_PARAM_ROUTE_profile: spa_param_route = 12;
2577#[doc = "< If route should be saved (Bool)"]
2578pub const SPA_PARAM_ROUTE_save: spa_param_route = 13;
2579#[doc = " properties for SPA_TYPE_OBJECT_ParamRoute"]
2580pub type spa_param_route = ::std::os::raw::c_uint;
2581pub const SPA_PROP_INFO_START: spa_prop_info = 0;
2582#[doc = "< associated id of the property"]
2583pub const SPA_PROP_INFO_id: spa_prop_info = 1;
2584#[doc = "< name of the property"]
2585pub const SPA_PROP_INFO_name: spa_prop_info = 2;
2586#[doc = "< type and range/enums of property"]
2587pub const SPA_PROP_INFO_type: spa_prop_info = 3;
2588#[doc = "< labels of property if any, this is a\n struct with pairs of values, the first one\n is of the type of the property, the second\n one is a string with a user readable label\n for the value."]
2589pub const SPA_PROP_INFO_labels: spa_prop_info = 4;
2590#[doc = "< type of container if any (Id)"]
2591pub const SPA_PROP_INFO_container: spa_prop_info = 5;
2592#[doc = "< is part of params property (Bool)"]
2593pub const SPA_PROP_INFO_params: spa_prop_info = 6;
2594#[doc = "< User readable description"]
2595pub const SPA_PROP_INFO_description: spa_prop_info = 7;
2596#[doc = " properties of SPA_TYPE_OBJECT_PropInfo"]
2597pub type spa_prop_info = ::std::os::raw::c_uint;
2598pub const SPA_PROP_START: spa_prop = 0;
2599#[doc = "< an unknown property"]
2600pub const SPA_PROP_unknown: spa_prop = 1;
2601#[doc = "< device related properties"]
2602pub const SPA_PROP_START_Device: spa_prop = 256;
2603pub const SPA_PROP_device: spa_prop = 257;
2604pub const SPA_PROP_deviceName: spa_prop = 258;
2605pub const SPA_PROP_deviceFd: spa_prop = 259;
2606pub const SPA_PROP_card: spa_prop = 260;
2607pub const SPA_PROP_cardName: spa_prop = 261;
2608pub const SPA_PROP_minLatency: spa_prop = 262;
2609pub const SPA_PROP_maxLatency: spa_prop = 263;
2610pub const SPA_PROP_periods: spa_prop = 264;
2611pub const SPA_PROP_periodSize: spa_prop = 265;
2612pub const SPA_PROP_periodEvent: spa_prop = 266;
2613pub const SPA_PROP_live: spa_prop = 267;
2614pub const SPA_PROP_rate: spa_prop = 268;
2615pub const SPA_PROP_quality: spa_prop = 269;
2616pub const SPA_PROP_bluetoothAudioCodec: spa_prop = 270;
2617pub const SPA_PROP_bluetoothOffloadActive: spa_prop = 271;
2618#[doc = "< audio related properties"]
2619pub const SPA_PROP_START_Audio: spa_prop = 65536;
2620pub const SPA_PROP_waveType: spa_prop = 65537;
2621pub const SPA_PROP_frequency: spa_prop = 65538;
2622#[doc = "< a volume (Float), 0.0 silence, 1.0 no attenutation"]
2623pub const SPA_PROP_volume: spa_prop = 65539;
2624#[doc = "< mute (Bool)"]
2625pub const SPA_PROP_mute: spa_prop = 65540;
2626pub const SPA_PROP_patternType: spa_prop = 65541;
2627pub const SPA_PROP_ditherType: spa_prop = 65542;
2628pub const SPA_PROP_truncate: spa_prop = 65543;
2629#[doc = "< a volume array, one (linear) volume per channel\n (Array of Float). 0.0 is silence, 1.0 is\n without attenuation. This is the effective\n volume that is applied. It can result\n in a hardware volume and software volume\n (see softVolumes)"]
2630pub const SPA_PROP_channelVolumes: spa_prop = 65544;
2631#[doc = "< a volume base (Float)"]
2632pub const SPA_PROP_volumeBase: spa_prop = 65545;
2633#[doc = "< a volume step (Float)"]
2634pub const SPA_PROP_volumeStep: spa_prop = 65546;
2635#[doc = "< a channelmap array\n (Array (Id enum spa_audio_channel))"]
2636pub const SPA_PROP_channelMap: spa_prop = 65547;
2637#[doc = "< mute (Bool)"]
2638pub const SPA_PROP_monitorMute: spa_prop = 65548;
2639#[doc = "< a volume array, one (linear) volume per\n channel (Array of Float)"]
2640pub const SPA_PROP_monitorVolumes: spa_prop = 65549;
2641#[doc = "< delay adjustment"]
2642pub const SPA_PROP_latencyOffsetNsec: spa_prop = 65550;
2643#[doc = "< mute (Bool) applied in software"]
2644pub const SPA_PROP_softMute: spa_prop = 65551;
2645#[doc = "< a volume array, one (linear) volume per channel\n (Array of Float). 0.0 is silence, 1.0 is without\n attenuation. This is the volume applied in\n software, there might be a part applied in\n hardware."]
2646pub const SPA_PROP_softVolumes: spa_prop = 65552;
2647#[doc = "< enabled IEC958 (S/PDIF) codecs,\n (Array (Id enum spa_audio_iec958_codec)"]
2648pub const SPA_PROP_iec958Codecs: spa_prop = 65553;
2649#[doc = "< Samples to ramp the volume over"]
2650pub const SPA_PROP_volumeRampSamples: spa_prop = 65554;
2651#[doc = "< Step or incremental Samples to ramp\n the volume over"]
2652pub const SPA_PROP_volumeRampStepSamples: spa_prop = 65555;
2653#[doc = "< Time in millisec to ramp the volume over"]
2654pub const SPA_PROP_volumeRampTime: spa_prop = 65556;
2655#[doc = "< Step or incremental Time in nano seconds\n to ramp the"]
2656pub const SPA_PROP_volumeRampStepTime: spa_prop = 65557;
2657#[doc = "< the scale or graph to used to ramp the\n volume"]
2658pub const SPA_PROP_volumeRampScale: spa_prop = 65558;
2659#[doc = "< video related properties"]
2660pub const SPA_PROP_START_Video: spa_prop = 131072;
2661pub const SPA_PROP_brightness: spa_prop = 131073;
2662pub const SPA_PROP_contrast: spa_prop = 131074;
2663pub const SPA_PROP_saturation: spa_prop = 131075;
2664pub const SPA_PROP_hue: spa_prop = 131076;
2665pub const SPA_PROP_gamma: spa_prop = 131077;
2666pub const SPA_PROP_exposure: spa_prop = 131078;
2667pub const SPA_PROP_gain: spa_prop = 131079;
2668pub const SPA_PROP_sharpness: spa_prop = 131080;
2669#[doc = "< other properties"]
2670pub const SPA_PROP_START_Other: spa_prop = 524288;
2671#[doc = "< simple control params\n (Struct(\n\t (String : key,\n\t Pod : value)*))"]
2672pub const SPA_PROP_params: spa_prop = 524289;
2673pub const SPA_PROP_START_CUSTOM: spa_prop = 16777216;
2674#[doc = " predefined properties for SPA_TYPE_OBJECT_Props"]
2675pub type spa_prop = ::std::os::raw::c_uint;
2676pub const SPA_MEDIA_TYPE_unknown: spa_media_type = 0;
2677pub const SPA_MEDIA_TYPE_audio: spa_media_type = 1;
2678pub const SPA_MEDIA_TYPE_video: spa_media_type = 2;
2679pub const SPA_MEDIA_TYPE_image: spa_media_type = 3;
2680pub const SPA_MEDIA_TYPE_binary: spa_media_type = 4;
2681pub const SPA_MEDIA_TYPE_stream: spa_media_type = 5;
2682pub const SPA_MEDIA_TYPE_application: spa_media_type = 6;
2683#[doc = " media type for SPA_TYPE_OBJECT_Format"]
2684pub type spa_media_type = ::std::os::raw::c_uint;
2685pub const SPA_MEDIA_SUBTYPE_unknown: spa_media_subtype = 0;
2686pub const SPA_MEDIA_SUBTYPE_raw: spa_media_subtype = 1;
2687pub const SPA_MEDIA_SUBTYPE_dsp: spa_media_subtype = 2;
2688pub const SPA_MEDIA_SUBTYPE_iec958: spa_media_subtype = 3;
2689#[doc = " S/PDIF"]
2690pub const SPA_MEDIA_SUBTYPE_dsd: spa_media_subtype = 4;
2691#[doc = " S/PDIF"]
2692pub const SPA_MEDIA_SUBTYPE_START_Audio: spa_media_subtype = 65536;
2693#[doc = " S/PDIF"]
2694pub const SPA_MEDIA_SUBTYPE_mp3: spa_media_subtype = 65537;
2695#[doc = " S/PDIF"]
2696pub const SPA_MEDIA_SUBTYPE_aac: spa_media_subtype = 65538;
2697#[doc = " S/PDIF"]
2698pub const SPA_MEDIA_SUBTYPE_vorbis: spa_media_subtype = 65539;
2699#[doc = " S/PDIF"]
2700pub const SPA_MEDIA_SUBTYPE_wma: spa_media_subtype = 65540;
2701#[doc = " S/PDIF"]
2702pub const SPA_MEDIA_SUBTYPE_ra: spa_media_subtype = 65541;
2703#[doc = " S/PDIF"]
2704pub const SPA_MEDIA_SUBTYPE_sbc: spa_media_subtype = 65542;
2705#[doc = " S/PDIF"]
2706pub const SPA_MEDIA_SUBTYPE_adpcm: spa_media_subtype = 65543;
2707#[doc = " S/PDIF"]
2708pub const SPA_MEDIA_SUBTYPE_g723: spa_media_subtype = 65544;
2709#[doc = " S/PDIF"]
2710pub const SPA_MEDIA_SUBTYPE_g726: spa_media_subtype = 65545;
2711#[doc = " S/PDIF"]
2712pub const SPA_MEDIA_SUBTYPE_g729: spa_media_subtype = 65546;
2713#[doc = " S/PDIF"]
2714pub const SPA_MEDIA_SUBTYPE_amr: spa_media_subtype = 65547;
2715#[doc = " S/PDIF"]
2716pub const SPA_MEDIA_SUBTYPE_gsm: spa_media_subtype = 65548;
2717#[doc = " S/PDIF"]
2718pub const SPA_MEDIA_SUBTYPE_alac: spa_media_subtype = 65549;
2719#[doc = " since 0.3.65"]
2720pub const SPA_MEDIA_SUBTYPE_flac: spa_media_subtype = 65550;
2721#[doc = " since 0.3.65"]
2722pub const SPA_MEDIA_SUBTYPE_ape: spa_media_subtype = 65551;
2723#[doc = " since 0.3.65"]
2724pub const SPA_MEDIA_SUBTYPE_opus: spa_media_subtype = 65552;
2725#[doc = " since 0.3.68"]
2726pub const SPA_MEDIA_SUBTYPE_START_Video: spa_media_subtype = 131072;
2727#[doc = " since 0.3.68"]
2728pub const SPA_MEDIA_SUBTYPE_h264: spa_media_subtype = 131073;
2729#[doc = " since 0.3.68"]
2730pub const SPA_MEDIA_SUBTYPE_mjpg: spa_media_subtype = 131074;
2731#[doc = " since 0.3.68"]
2732pub const SPA_MEDIA_SUBTYPE_dv: spa_media_subtype = 131075;
2733#[doc = " since 0.3.68"]
2734pub const SPA_MEDIA_SUBTYPE_mpegts: spa_media_subtype = 131076;
2735#[doc = " since 0.3.68"]
2736pub const SPA_MEDIA_SUBTYPE_h263: spa_media_subtype = 131077;
2737#[doc = " since 0.3.68"]
2738pub const SPA_MEDIA_SUBTYPE_mpeg1: spa_media_subtype = 131078;
2739#[doc = " since 0.3.68"]
2740pub const SPA_MEDIA_SUBTYPE_mpeg2: spa_media_subtype = 131079;
2741#[doc = " since 0.3.68"]
2742pub const SPA_MEDIA_SUBTYPE_mpeg4: spa_media_subtype = 131080;
2743#[doc = " since 0.3.68"]
2744pub const SPA_MEDIA_SUBTYPE_xvid: spa_media_subtype = 131081;
2745#[doc = " since 0.3.68"]
2746pub const SPA_MEDIA_SUBTYPE_vc1: spa_media_subtype = 131082;
2747#[doc = " since 0.3.68"]
2748pub const SPA_MEDIA_SUBTYPE_vp8: spa_media_subtype = 131083;
2749#[doc = " since 0.3.68"]
2750pub const SPA_MEDIA_SUBTYPE_vp9: spa_media_subtype = 131084;
2751#[doc = " since 0.3.68"]
2752pub const SPA_MEDIA_SUBTYPE_bayer: spa_media_subtype = 131085;
2753#[doc = " since 0.3.68"]
2754pub const SPA_MEDIA_SUBTYPE_START_Image: spa_media_subtype = 196608;
2755#[doc = " since 0.3.68"]
2756pub const SPA_MEDIA_SUBTYPE_jpeg: spa_media_subtype = 196609;
2757#[doc = " since 0.3.68"]
2758pub const SPA_MEDIA_SUBTYPE_START_Binary: spa_media_subtype = 262144;
2759#[doc = " since 0.3.68"]
2760pub const SPA_MEDIA_SUBTYPE_START_Stream: spa_media_subtype = 327680;
2761#[doc = " since 0.3.68"]
2762pub const SPA_MEDIA_SUBTYPE_midi: spa_media_subtype = 327681;
2763#[doc = " since 0.3.68"]
2764pub const SPA_MEDIA_SUBTYPE_START_Application: spa_media_subtype = 393216;
2765#[doc = "< control stream, data contains\n spa_pod_sequence with control info."]
2766pub const SPA_MEDIA_SUBTYPE_control: spa_media_subtype = 393217;
2767#[doc = " media subtype for SPA_TYPE_OBJECT_Format"]
2768pub type spa_media_subtype = ::std::os::raw::c_uint;
2769pub const SPA_FORMAT_START: spa_format = 0;
2770#[doc = "< media type (Id enum spa_media_type)"]
2771pub const SPA_FORMAT_mediaType: spa_format = 1;
2772#[doc = "< media subtype (Id enum spa_media_subtype)"]
2773pub const SPA_FORMAT_mediaSubtype: spa_format = 2;
2774pub const SPA_FORMAT_START_Audio: spa_format = 65536;
2775#[doc = "< audio format, (Id enum spa_audio_format)"]
2776pub const SPA_FORMAT_AUDIO_format: spa_format = 65537;
2777#[doc = "< optional flags (Int)"]
2778pub const SPA_FORMAT_AUDIO_flags: spa_format = 65538;
2779#[doc = "< sample rate (Int)"]
2780pub const SPA_FORMAT_AUDIO_rate: spa_format = 65539;
2781#[doc = "< number of audio channels (Int)"]
2782pub const SPA_FORMAT_AUDIO_channels: spa_format = 65540;
2783#[doc = "< channel positions (Id enum spa_audio_position)"]
2784pub const SPA_FORMAT_AUDIO_position: spa_format = 65541;
2785#[doc = "< codec used (IEC958) (Id enum spa_audio_iec958_codec)"]
2786pub const SPA_FORMAT_AUDIO_iec958Codec: spa_format = 65542;
2787#[doc = "< bit order (Id enum spa_param_bitorder)"]
2788pub const SPA_FORMAT_AUDIO_bitorder: spa_format = 65543;
2789#[doc = "< Interleave bytes (Int)"]
2790pub const SPA_FORMAT_AUDIO_interleave: spa_format = 65544;
2791#[doc = "< bit rate (Int)"]
2792pub const SPA_FORMAT_AUDIO_bitrate: spa_format = 65545;
2793#[doc = "< audio data block alignment (Int)"]
2794pub const SPA_FORMAT_AUDIO_blockAlign: spa_format = 65546;
2795#[doc = "< AAC stream format, (Id enum spa_audio_aac_stream_format)"]
2796pub const SPA_FORMAT_AUDIO_AAC_streamFormat: spa_format = 65547;
2797#[doc = "< WMA profile (Id enum spa_audio_wma_profile)"]
2798pub const SPA_FORMAT_AUDIO_WMA_profile: spa_format = 65548;
2799#[doc = "< AMR band mode (Id enum spa_audio_amr_band_mode)"]
2800pub const SPA_FORMAT_AUDIO_AMR_bandMode: spa_format = 65549;
2801pub const SPA_FORMAT_START_Video: spa_format = 131072;
2802#[doc = "< video format (Id enum spa_video_format)"]
2803pub const SPA_FORMAT_VIDEO_format: spa_format = 131073;
2804#[doc = "< format modifier (Long)\n use only with DMA-BUF and omit for other buffer types"]
2805pub const SPA_FORMAT_VIDEO_modifier: spa_format = 131074;
2806#[doc = "< size (Rectangle)"]
2807pub const SPA_FORMAT_VIDEO_size: spa_format = 131075;
2808#[doc = "< frame rate (Fraction)"]
2809pub const SPA_FORMAT_VIDEO_framerate: spa_format = 131076;
2810#[doc = "< maximum frame rate (Fraction)"]
2811pub const SPA_FORMAT_VIDEO_maxFramerate: spa_format = 131077;
2812#[doc = "< number of views (Int)"]
2813pub const SPA_FORMAT_VIDEO_views: spa_format = 131078;
2814#[doc = "< (Id enum spa_video_interlace_mode)"]
2815pub const SPA_FORMAT_VIDEO_interlaceMode: spa_format = 131079;
2816#[doc = "< (Rectangle)"]
2817pub const SPA_FORMAT_VIDEO_pixelAspectRatio: spa_format = 131080;
2818#[doc = "< (Id enum spa_video_multiview_mode)"]
2819pub const SPA_FORMAT_VIDEO_multiviewMode: spa_format = 131081;
2820#[doc = "< (Id enum spa_video_multiview_flags)"]
2821pub const SPA_FORMAT_VIDEO_multiviewFlags: spa_format = 131082;
2822#[doc = "< /Id enum spa_video_chroma_site)"]
2823pub const SPA_FORMAT_VIDEO_chromaSite: spa_format = 131083;
2824#[doc = "< /Id enum spa_video_color_range)"]
2825pub const SPA_FORMAT_VIDEO_colorRange: spa_format = 131084;
2826#[doc = "< /Id enum spa_video_color_matrix)"]
2827pub const SPA_FORMAT_VIDEO_colorMatrix: spa_format = 131085;
2828#[doc = "< /Id enum spa_video_transfer_function)"]
2829pub const SPA_FORMAT_VIDEO_transferFunction: spa_format = 131086;
2830#[doc = "< /Id enum spa_video_color_primaries)"]
2831pub const SPA_FORMAT_VIDEO_colorPrimaries: spa_format = 131087;
2832#[doc = "< (Int)"]
2833pub const SPA_FORMAT_VIDEO_profile: spa_format = 131088;
2834#[doc = "< (Int)"]
2835pub const SPA_FORMAT_VIDEO_level: spa_format = 131089;
2836#[doc = "< (Id enum spa_h264_stream_format)"]
2837pub const SPA_FORMAT_VIDEO_H264_streamFormat: spa_format = 131090;
2838#[doc = "< (Id enum spa_h264_alignment)"]
2839pub const SPA_FORMAT_VIDEO_H264_alignment: spa_format = 131091;
2840pub const SPA_FORMAT_START_Image: spa_format = 196608;
2841pub const SPA_FORMAT_START_Binary: spa_format = 262144;
2842pub const SPA_FORMAT_START_Stream: spa_format = 327680;
2843pub const SPA_FORMAT_START_Application: spa_format = 393216;
2844#[doc = "< possible control types (flags choice Int,\n mask of enum spa_control_type)"]
2845pub const SPA_FORMAT_CONTROL_types: spa_format = 393217;
2846#[doc = " properties for audio SPA_TYPE_OBJECT_Format"]
2847pub type spa_format = ::std::os::raw::c_uint;
2848pub const SPA_AUDIO_FORMAT_UNKNOWN: spa_audio_format = 0;
2849pub const SPA_AUDIO_FORMAT_ENCODED: spa_audio_format = 1;
2850pub const SPA_AUDIO_FORMAT_START_Interleaved: spa_audio_format = 256;
2851pub const SPA_AUDIO_FORMAT_S8: spa_audio_format = 257;
2852pub const SPA_AUDIO_FORMAT_U8: spa_audio_format = 258;
2853pub const SPA_AUDIO_FORMAT_S16_LE: spa_audio_format = 259;
2854pub const SPA_AUDIO_FORMAT_S16_BE: spa_audio_format = 260;
2855pub const SPA_AUDIO_FORMAT_U16_LE: spa_audio_format = 261;
2856pub const SPA_AUDIO_FORMAT_U16_BE: spa_audio_format = 262;
2857pub const SPA_AUDIO_FORMAT_S24_32_LE: spa_audio_format = 263;
2858pub const SPA_AUDIO_FORMAT_S24_32_BE: spa_audio_format = 264;
2859pub const SPA_AUDIO_FORMAT_U24_32_LE: spa_audio_format = 265;
2860pub const SPA_AUDIO_FORMAT_U24_32_BE: spa_audio_format = 266;
2861pub const SPA_AUDIO_FORMAT_S32_LE: spa_audio_format = 267;
2862pub const SPA_AUDIO_FORMAT_S32_BE: spa_audio_format = 268;
2863pub const SPA_AUDIO_FORMAT_U32_LE: spa_audio_format = 269;
2864pub const SPA_AUDIO_FORMAT_U32_BE: spa_audio_format = 270;
2865pub const SPA_AUDIO_FORMAT_S24_LE: spa_audio_format = 271;
2866pub const SPA_AUDIO_FORMAT_S24_BE: spa_audio_format = 272;
2867pub const SPA_AUDIO_FORMAT_U24_LE: spa_audio_format = 273;
2868pub const SPA_AUDIO_FORMAT_U24_BE: spa_audio_format = 274;
2869pub const SPA_AUDIO_FORMAT_S20_LE: spa_audio_format = 275;
2870pub const SPA_AUDIO_FORMAT_S20_BE: spa_audio_format = 276;
2871pub const SPA_AUDIO_FORMAT_U20_LE: spa_audio_format = 277;
2872pub const SPA_AUDIO_FORMAT_U20_BE: spa_audio_format = 278;
2873pub const SPA_AUDIO_FORMAT_S18_LE: spa_audio_format = 279;
2874pub const SPA_AUDIO_FORMAT_S18_BE: spa_audio_format = 280;
2875pub const SPA_AUDIO_FORMAT_U18_LE: spa_audio_format = 281;
2876pub const SPA_AUDIO_FORMAT_U18_BE: spa_audio_format = 282;
2877pub const SPA_AUDIO_FORMAT_F32_LE: spa_audio_format = 283;
2878pub const SPA_AUDIO_FORMAT_F32_BE: spa_audio_format = 284;
2879pub const SPA_AUDIO_FORMAT_F64_LE: spa_audio_format = 285;
2880pub const SPA_AUDIO_FORMAT_F64_BE: spa_audio_format = 286;
2881pub const SPA_AUDIO_FORMAT_ULAW: spa_audio_format = 287;
2882pub const SPA_AUDIO_FORMAT_ALAW: spa_audio_format = 288;
2883pub const SPA_AUDIO_FORMAT_START_Planar: spa_audio_format = 512;
2884pub const SPA_AUDIO_FORMAT_U8P: spa_audio_format = 513;
2885pub const SPA_AUDIO_FORMAT_S16P: spa_audio_format = 514;
2886pub const SPA_AUDIO_FORMAT_S24_32P: spa_audio_format = 515;
2887pub const SPA_AUDIO_FORMAT_S32P: spa_audio_format = 516;
2888pub const SPA_AUDIO_FORMAT_S24P: spa_audio_format = 517;
2889pub const SPA_AUDIO_FORMAT_F32P: spa_audio_format = 518;
2890pub const SPA_AUDIO_FORMAT_F64P: spa_audio_format = 519;
2891pub const SPA_AUDIO_FORMAT_S8P: spa_audio_format = 520;
2892pub const SPA_AUDIO_FORMAT_START_Other: spa_audio_format = 1024;
2893pub const SPA_AUDIO_FORMAT_DSP_S32: spa_audio_format = 515;
2894pub const SPA_AUDIO_FORMAT_DSP_F32: spa_audio_format = 518;
2895pub const SPA_AUDIO_FORMAT_DSP_F64: spa_audio_format = 519;
2896pub const SPA_AUDIO_FORMAT_S16: spa_audio_format = 259;
2897pub const SPA_AUDIO_FORMAT_U16: spa_audio_format = 261;
2898pub const SPA_AUDIO_FORMAT_S24_32: spa_audio_format = 263;
2899pub const SPA_AUDIO_FORMAT_U24_32: spa_audio_format = 265;
2900pub const SPA_AUDIO_FORMAT_S32: spa_audio_format = 267;
2901pub const SPA_AUDIO_FORMAT_U32: spa_audio_format = 269;
2902pub const SPA_AUDIO_FORMAT_S24: spa_audio_format = 271;
2903pub const SPA_AUDIO_FORMAT_U24: spa_audio_format = 273;
2904pub const SPA_AUDIO_FORMAT_S20: spa_audio_format = 275;
2905pub const SPA_AUDIO_FORMAT_U20: spa_audio_format = 277;
2906pub const SPA_AUDIO_FORMAT_S18: spa_audio_format = 279;
2907pub const SPA_AUDIO_FORMAT_U18: spa_audio_format = 281;
2908pub const SPA_AUDIO_FORMAT_F32: spa_audio_format = 283;
2909pub const SPA_AUDIO_FORMAT_F64: spa_audio_format = 285;
2910pub const SPA_AUDIO_FORMAT_S16_OE: spa_audio_format = 260;
2911pub const SPA_AUDIO_FORMAT_U16_OE: spa_audio_format = 262;
2912pub const SPA_AUDIO_FORMAT_S24_32_OE: spa_audio_format = 264;
2913pub const SPA_AUDIO_FORMAT_U24_32_OE: spa_audio_format = 266;
2914pub const SPA_AUDIO_FORMAT_S32_OE: spa_audio_format = 268;
2915pub const SPA_AUDIO_FORMAT_U32_OE: spa_audio_format = 270;
2916pub const SPA_AUDIO_FORMAT_S24_OE: spa_audio_format = 272;
2917pub const SPA_AUDIO_FORMAT_U24_OE: spa_audio_format = 274;
2918pub const SPA_AUDIO_FORMAT_S20_OE: spa_audio_format = 276;
2919pub const SPA_AUDIO_FORMAT_U20_OE: spa_audio_format = 278;
2920pub const SPA_AUDIO_FORMAT_S18_OE: spa_audio_format = 280;
2921pub const SPA_AUDIO_FORMAT_U18_OE: spa_audio_format = 282;
2922pub const SPA_AUDIO_FORMAT_F32_OE: spa_audio_format = 284;
2923pub const SPA_AUDIO_FORMAT_F64_OE: spa_audio_format = 286;
2924pub type spa_audio_format = ::std::os::raw::c_uint;
2925#[doc = "< unspecified"]
2926pub const SPA_AUDIO_CHANNEL_UNKNOWN: spa_audio_channel = 0;
2927#[doc = "< N/A, silent"]
2928pub const SPA_AUDIO_CHANNEL_NA: spa_audio_channel = 1;
2929#[doc = "< mono stream"]
2930pub const SPA_AUDIO_CHANNEL_MONO: spa_audio_channel = 2;
2931#[doc = "< front left"]
2932pub const SPA_AUDIO_CHANNEL_FL: spa_audio_channel = 3;
2933#[doc = "< front right"]
2934pub const SPA_AUDIO_CHANNEL_FR: spa_audio_channel = 4;
2935#[doc = "< front center"]
2936pub const SPA_AUDIO_CHANNEL_FC: spa_audio_channel = 5;
2937#[doc = "< LFE"]
2938pub const SPA_AUDIO_CHANNEL_LFE: spa_audio_channel = 6;
2939#[doc = "< side left"]
2940pub const SPA_AUDIO_CHANNEL_SL: spa_audio_channel = 7;
2941#[doc = "< side right"]
2942pub const SPA_AUDIO_CHANNEL_SR: spa_audio_channel = 8;
2943#[doc = "< front left center"]
2944pub const SPA_AUDIO_CHANNEL_FLC: spa_audio_channel = 9;
2945#[doc = "< front right center"]
2946pub const SPA_AUDIO_CHANNEL_FRC: spa_audio_channel = 10;
2947#[doc = "< rear center"]
2948pub const SPA_AUDIO_CHANNEL_RC: spa_audio_channel = 11;
2949#[doc = "< rear left"]
2950pub const SPA_AUDIO_CHANNEL_RL: spa_audio_channel = 12;
2951#[doc = "< rear right"]
2952pub const SPA_AUDIO_CHANNEL_RR: spa_audio_channel = 13;
2953#[doc = "< top center"]
2954pub const SPA_AUDIO_CHANNEL_TC: spa_audio_channel = 14;
2955#[doc = "< top front left"]
2956pub const SPA_AUDIO_CHANNEL_TFL: spa_audio_channel = 15;
2957#[doc = "< top front center"]
2958pub const SPA_AUDIO_CHANNEL_TFC: spa_audio_channel = 16;
2959#[doc = "< top front right"]
2960pub const SPA_AUDIO_CHANNEL_TFR: spa_audio_channel = 17;
2961#[doc = "< top rear left"]
2962pub const SPA_AUDIO_CHANNEL_TRL: spa_audio_channel = 18;
2963#[doc = "< top rear center"]
2964pub const SPA_AUDIO_CHANNEL_TRC: spa_audio_channel = 19;
2965#[doc = "< top rear right"]
2966pub const SPA_AUDIO_CHANNEL_TRR: spa_audio_channel = 20;
2967#[doc = "< rear left center"]
2968pub const SPA_AUDIO_CHANNEL_RLC: spa_audio_channel = 21;
2969#[doc = "< rear right center"]
2970pub const SPA_AUDIO_CHANNEL_RRC: spa_audio_channel = 22;
2971#[doc = "< front left wide"]
2972pub const SPA_AUDIO_CHANNEL_FLW: spa_audio_channel = 23;
2973#[doc = "< front right wide"]
2974pub const SPA_AUDIO_CHANNEL_FRW: spa_audio_channel = 24;
2975#[doc = "< LFE 2"]
2976pub const SPA_AUDIO_CHANNEL_LFE2: spa_audio_channel = 25;
2977#[doc = "< front left high"]
2978pub const SPA_AUDIO_CHANNEL_FLH: spa_audio_channel = 26;
2979#[doc = "< front center high"]
2980pub const SPA_AUDIO_CHANNEL_FCH: spa_audio_channel = 27;
2981#[doc = "< front right high"]
2982pub const SPA_AUDIO_CHANNEL_FRH: spa_audio_channel = 28;
2983#[doc = "< top front left center"]
2984pub const SPA_AUDIO_CHANNEL_TFLC: spa_audio_channel = 29;
2985#[doc = "< top front right center"]
2986pub const SPA_AUDIO_CHANNEL_TFRC: spa_audio_channel = 30;
2987#[doc = "< top side left"]
2988pub const SPA_AUDIO_CHANNEL_TSL: spa_audio_channel = 31;
2989#[doc = "< top side right"]
2990pub const SPA_AUDIO_CHANNEL_TSR: spa_audio_channel = 32;
2991#[doc = "< left LFE"]
2992pub const SPA_AUDIO_CHANNEL_LLFE: spa_audio_channel = 33;
2993#[doc = "< right LFE"]
2994pub const SPA_AUDIO_CHANNEL_RLFE: spa_audio_channel = 34;
2995#[doc = "< bottom center"]
2996pub const SPA_AUDIO_CHANNEL_BC: spa_audio_channel = 35;
2997#[doc = "< bottom left center"]
2998pub const SPA_AUDIO_CHANNEL_BLC: spa_audio_channel = 36;
2999#[doc = "< bottom right center"]
3000pub const SPA_AUDIO_CHANNEL_BRC: spa_audio_channel = 37;
3001#[doc = "< aux channels"]
3002pub const SPA_AUDIO_CHANNEL_START_Aux: spa_audio_channel = 4096;
3003pub const SPA_AUDIO_CHANNEL_AUX0: spa_audio_channel = 4096;
3004pub const SPA_AUDIO_CHANNEL_AUX1: spa_audio_channel = 4097;
3005pub const SPA_AUDIO_CHANNEL_AUX2: spa_audio_channel = 4098;
3006pub const SPA_AUDIO_CHANNEL_AUX3: spa_audio_channel = 4099;
3007pub const SPA_AUDIO_CHANNEL_AUX4: spa_audio_channel = 4100;
3008pub const SPA_AUDIO_CHANNEL_AUX5: spa_audio_channel = 4101;
3009pub const SPA_AUDIO_CHANNEL_AUX6: spa_audio_channel = 4102;
3010pub const SPA_AUDIO_CHANNEL_AUX7: spa_audio_channel = 4103;
3011pub const SPA_AUDIO_CHANNEL_AUX8: spa_audio_channel = 4104;
3012pub const SPA_AUDIO_CHANNEL_AUX9: spa_audio_channel = 4105;
3013pub const SPA_AUDIO_CHANNEL_AUX10: spa_audio_channel = 4106;
3014pub const SPA_AUDIO_CHANNEL_AUX11: spa_audio_channel = 4107;
3015pub const SPA_AUDIO_CHANNEL_AUX12: spa_audio_channel = 4108;
3016pub const SPA_AUDIO_CHANNEL_AUX13: spa_audio_channel = 4109;
3017pub const SPA_AUDIO_CHANNEL_AUX14: spa_audio_channel = 4110;
3018pub const SPA_AUDIO_CHANNEL_AUX15: spa_audio_channel = 4111;
3019pub const SPA_AUDIO_CHANNEL_AUX16: spa_audio_channel = 4112;
3020pub const SPA_AUDIO_CHANNEL_AUX17: spa_audio_channel = 4113;
3021pub const SPA_AUDIO_CHANNEL_AUX18: spa_audio_channel = 4114;
3022pub const SPA_AUDIO_CHANNEL_AUX19: spa_audio_channel = 4115;
3023pub const SPA_AUDIO_CHANNEL_AUX20: spa_audio_channel = 4116;
3024pub const SPA_AUDIO_CHANNEL_AUX21: spa_audio_channel = 4117;
3025pub const SPA_AUDIO_CHANNEL_AUX22: spa_audio_channel = 4118;
3026pub const SPA_AUDIO_CHANNEL_AUX23: spa_audio_channel = 4119;
3027pub const SPA_AUDIO_CHANNEL_AUX24: spa_audio_channel = 4120;
3028pub const SPA_AUDIO_CHANNEL_AUX25: spa_audio_channel = 4121;
3029pub const SPA_AUDIO_CHANNEL_AUX26: spa_audio_channel = 4122;
3030pub const SPA_AUDIO_CHANNEL_AUX27: spa_audio_channel = 4123;
3031pub const SPA_AUDIO_CHANNEL_AUX28: spa_audio_channel = 4124;
3032pub const SPA_AUDIO_CHANNEL_AUX29: spa_audio_channel = 4125;
3033pub const SPA_AUDIO_CHANNEL_AUX30: spa_audio_channel = 4126;
3034pub const SPA_AUDIO_CHANNEL_AUX31: spa_audio_channel = 4127;
3035pub const SPA_AUDIO_CHANNEL_AUX32: spa_audio_channel = 4128;
3036pub const SPA_AUDIO_CHANNEL_AUX33: spa_audio_channel = 4129;
3037pub const SPA_AUDIO_CHANNEL_AUX34: spa_audio_channel = 4130;
3038pub const SPA_AUDIO_CHANNEL_AUX35: spa_audio_channel = 4131;
3039pub const SPA_AUDIO_CHANNEL_AUX36: spa_audio_channel = 4132;
3040pub const SPA_AUDIO_CHANNEL_AUX37: spa_audio_channel = 4133;
3041pub const SPA_AUDIO_CHANNEL_AUX38: spa_audio_channel = 4134;
3042pub const SPA_AUDIO_CHANNEL_AUX39: spa_audio_channel = 4135;
3043pub const SPA_AUDIO_CHANNEL_AUX40: spa_audio_channel = 4136;
3044pub const SPA_AUDIO_CHANNEL_AUX41: spa_audio_channel = 4137;
3045pub const SPA_AUDIO_CHANNEL_AUX42: spa_audio_channel = 4138;
3046pub const SPA_AUDIO_CHANNEL_AUX43: spa_audio_channel = 4139;
3047pub const SPA_AUDIO_CHANNEL_AUX44: spa_audio_channel = 4140;
3048pub const SPA_AUDIO_CHANNEL_AUX45: spa_audio_channel = 4141;
3049pub const SPA_AUDIO_CHANNEL_AUX46: spa_audio_channel = 4142;
3050pub const SPA_AUDIO_CHANNEL_AUX47: spa_audio_channel = 4143;
3051pub const SPA_AUDIO_CHANNEL_AUX48: spa_audio_channel = 4144;
3052pub const SPA_AUDIO_CHANNEL_AUX49: spa_audio_channel = 4145;
3053pub const SPA_AUDIO_CHANNEL_AUX50: spa_audio_channel = 4146;
3054pub const SPA_AUDIO_CHANNEL_AUX51: spa_audio_channel = 4147;
3055pub const SPA_AUDIO_CHANNEL_AUX52: spa_audio_channel = 4148;
3056pub const SPA_AUDIO_CHANNEL_AUX53: spa_audio_channel = 4149;
3057pub const SPA_AUDIO_CHANNEL_AUX54: spa_audio_channel = 4150;
3058pub const SPA_AUDIO_CHANNEL_AUX55: spa_audio_channel = 4151;
3059pub const SPA_AUDIO_CHANNEL_AUX56: spa_audio_channel = 4152;
3060pub const SPA_AUDIO_CHANNEL_AUX57: spa_audio_channel = 4153;
3061pub const SPA_AUDIO_CHANNEL_AUX58: spa_audio_channel = 4154;
3062pub const SPA_AUDIO_CHANNEL_AUX59: spa_audio_channel = 4155;
3063pub const SPA_AUDIO_CHANNEL_AUX60: spa_audio_channel = 4156;
3064pub const SPA_AUDIO_CHANNEL_AUX61: spa_audio_channel = 4157;
3065pub const SPA_AUDIO_CHANNEL_AUX62: spa_audio_channel = 4158;
3066pub const SPA_AUDIO_CHANNEL_AUX63: spa_audio_channel = 4159;
3067#[doc = "< aux channels"]
3068pub const SPA_AUDIO_CHANNEL_LAST_Aux: spa_audio_channel = 8191;
3069pub const SPA_AUDIO_CHANNEL_START_Custom: spa_audio_channel = 65536;
3070pub type spa_audio_channel = ::std::os::raw::c_uint;
3071pub const SPA_AUDIO_VOLUME_RAMP_INVALID: spa_audio_volume_ramp_scale = 0;
3072pub const SPA_AUDIO_VOLUME_RAMP_LINEAR: spa_audio_volume_ramp_scale = 1;
3073pub const SPA_AUDIO_VOLUME_RAMP_CUBIC: spa_audio_volume_ramp_scale = 2;
3074pub type spa_audio_volume_ramp_scale = ::std::os::raw::c_uint;
3075#[doc = " Audio information description"]
3076#[repr(C)]
3077#[derive(Debug, Copy, Clone, PartialEq, Eq)]
3078pub struct spa_audio_info_raw {
3079 pub format: spa_audio_format,
3080 pub flags: u32,
3081 pub rate: u32,
3082 pub channels: u32,
3083 pub position: [u32; 64usize],
3084}
3085#[allow(clippy::unnecessary_operation, clippy::identity_op)]
3086const _: () = {
3087 ["Size of spa_audio_info_raw"][::std::mem::size_of::<spa_audio_info_raw>() - 272usize];
3088 ["Alignment of spa_audio_info_raw"][::std::mem::align_of::<spa_audio_info_raw>() - 4usize];
3089 ["Offset of field: spa_audio_info_raw::format"]
3090 [::std::mem::offset_of!(spa_audio_info_raw, format) - 0usize];
3091 ["Offset of field: spa_audio_info_raw::flags"]
3092 [::std::mem::offset_of!(spa_audio_info_raw, flags) - 4usize];
3093 ["Offset of field: spa_audio_info_raw::rate"]
3094 [::std::mem::offset_of!(spa_audio_info_raw, rate) - 8usize];
3095 ["Offset of field: spa_audio_info_raw::channels"]
3096 [::std::mem::offset_of!(spa_audio_info_raw, channels) - 12usize];
3097 ["Offset of field: spa_audio_info_raw::position"]
3098 [::std::mem::offset_of!(spa_audio_info_raw, position) - 16usize];
3099};
3100unsafe extern "C" {
3101 #[link_name = "spa_type_audio_format_from_short_name_libspa_rs"]
3102 pub fn spa_type_audio_format_from_short_name(name: *const ::std::os::raw::c_char) -> u32;
3103}
3104unsafe extern "C" {
3105 #[link_name = "spa_type_audio_format_to_short_name_libspa_rs"]
3106 pub fn spa_type_audio_format_to_short_name(type_: u32) -> *const ::std::os::raw::c_char;
3107}
3108unsafe extern "C" {
3109 #[link_name = "spa_type_audio_channel_from_short_name_libspa_rs"]
3110 pub fn spa_type_audio_channel_from_short_name(name: *const ::std::os::raw::c_char) -> u32;
3111}
3112unsafe extern "C" {
3113 #[link_name = "spa_type_audio_channel_to_short_name_libspa_rs"]
3114 pub fn spa_type_audio_channel_to_short_name(type_: u32) -> *const ::std::os::raw::c_char;
3115}
3116pub const SPA_AUDIO_IEC958_CODEC_UNKNOWN: spa_audio_iec958_codec = 0;
3117pub const SPA_AUDIO_IEC958_CODEC_PCM: spa_audio_iec958_codec = 1;
3118pub const SPA_AUDIO_IEC958_CODEC_DTS: spa_audio_iec958_codec = 2;
3119pub const SPA_AUDIO_IEC958_CODEC_AC3: spa_audio_iec958_codec = 3;
3120#[doc = "< MPEG-1 or MPEG-2 (Part 3, not AAC)"]
3121pub const SPA_AUDIO_IEC958_CODEC_MPEG: spa_audio_iec958_codec = 4;
3122#[doc = "< MPEG-2 AAC"]
3123pub const SPA_AUDIO_IEC958_CODEC_MPEG2_AAC: spa_audio_iec958_codec = 5;
3124pub const SPA_AUDIO_IEC958_CODEC_EAC3: spa_audio_iec958_codec = 6;
3125#[doc = "< Dolby TrueHD"]
3126pub const SPA_AUDIO_IEC958_CODEC_TRUEHD: spa_audio_iec958_codec = 7;
3127#[doc = "< DTS-HD Master Audio"]
3128pub const SPA_AUDIO_IEC958_CODEC_DTSHD: spa_audio_iec958_codec = 8;
3129#[doc = " \\addtogroup spa_param\n \\{"]
3130pub type spa_audio_iec958_codec = ::std::os::raw::c_uint;
3131#[repr(C)]
3132#[derive(Debug, Copy, Clone, PartialEq, Eq)]
3133pub struct spa_audio_info_iec958 {
3134 pub codec: spa_audio_iec958_codec,
3135 pub flags: u32,
3136 pub rate: u32,
3137}
3138#[allow(clippy::unnecessary_operation, clippy::identity_op)]
3139const _: () = {
3140 ["Size of spa_audio_info_iec958"][::std::mem::size_of::<spa_audio_info_iec958>() - 12usize];
3141 ["Alignment of spa_audio_info_iec958"]
3142 [::std::mem::align_of::<spa_audio_info_iec958>() - 4usize];
3143 ["Offset of field: spa_audio_info_iec958::codec"]
3144 [::std::mem::offset_of!(spa_audio_info_iec958, codec) - 0usize];
3145 ["Offset of field: spa_audio_info_iec958::flags"]
3146 [::std::mem::offset_of!(spa_audio_info_iec958, flags) - 4usize];
3147 ["Offset of field: spa_audio_info_iec958::rate"]
3148 [::std::mem::offset_of!(spa_audio_info_iec958, rate) - 8usize];
3149};
3150unsafe extern "C" {
3151 #[link_name = "spa_type_audio_iec958_codec_from_short_name_libspa_rs"]
3152 pub fn spa_type_audio_iec958_codec_from_short_name(name: *const ::std::os::raw::c_char) -> u32;
3153}
3154unsafe extern "C" {
3155 #[link_name = "spa_type_audio_iec958_codec_to_short_name_libspa_rs"]
3156 pub fn spa_type_audio_iec958_codec_to_short_name(type_: u32) -> *const ::std::os::raw::c_char;
3157}
3158pub const SPA_AUDIO_MP3_CHANNEL_MODE_UNKNOWN: spa_audio_mp3_channel_mode = 0;
3159pub const SPA_AUDIO_MP3_CHANNEL_MODE_MONO: spa_audio_mp3_channel_mode = 1;
3160pub const SPA_AUDIO_MP3_CHANNEL_MODE_STEREO: spa_audio_mp3_channel_mode = 2;
3161pub const SPA_AUDIO_MP3_CHANNEL_MODE_JOINTSTEREO: spa_audio_mp3_channel_mode = 3;
3162pub const SPA_AUDIO_MP3_CHANNEL_MODE_DUAL: spa_audio_mp3_channel_mode = 4;
3163#[doc = " \\addtogroup spa_param\n \\{"]
3164pub type spa_audio_mp3_channel_mode = ::std::os::raw::c_uint;
3165#[repr(C)]
3166#[derive(Debug, Copy, Clone, PartialEq, Eq)]
3167pub struct spa_audio_info_mp3 {
3168 pub rate: u32,
3169 pub channels: u32,
3170}
3171#[allow(clippy::unnecessary_operation, clippy::identity_op)]
3172const _: () = {
3173 ["Size of spa_audio_info_mp3"][::std::mem::size_of::<spa_audio_info_mp3>() - 8usize];
3174 ["Alignment of spa_audio_info_mp3"][::std::mem::align_of::<spa_audio_info_mp3>() - 4usize];
3175 ["Offset of field: spa_audio_info_mp3::rate"]
3176 [::std::mem::offset_of!(spa_audio_info_mp3, rate) - 0usize];
3177 ["Offset of field: spa_audio_info_mp3::channels"]
3178 [::std::mem::offset_of!(spa_audio_info_mp3, channels) - 4usize];
3179};
3180pub const SPA_AUDIO_AAC_STREAM_FORMAT_UNKNOWN: spa_audio_aac_stream_format = 0;
3181pub const SPA_AUDIO_AAC_STREAM_FORMAT_RAW: spa_audio_aac_stream_format = 1;
3182pub const SPA_AUDIO_AAC_STREAM_FORMAT_MP2ADTS: spa_audio_aac_stream_format = 2;
3183pub const SPA_AUDIO_AAC_STREAM_FORMAT_MP4ADTS: spa_audio_aac_stream_format = 3;
3184pub const SPA_AUDIO_AAC_STREAM_FORMAT_MP4LOAS: spa_audio_aac_stream_format = 4;
3185pub const SPA_AUDIO_AAC_STREAM_FORMAT_MP4LATM: spa_audio_aac_stream_format = 5;
3186pub const SPA_AUDIO_AAC_STREAM_FORMAT_ADIF: spa_audio_aac_stream_format = 6;
3187pub const SPA_AUDIO_AAC_STREAM_FORMAT_MP4FF: spa_audio_aac_stream_format = 7;
3188pub const SPA_AUDIO_AAC_STREAM_FORMAT_CUSTOM: spa_audio_aac_stream_format = 65536;
3189#[doc = " \\addtogroup spa_param\n \\{"]
3190pub type spa_audio_aac_stream_format = ::std::os::raw::c_uint;
3191#[repr(C)]
3192#[derive(Debug, Copy, Clone, PartialEq, Eq)]
3193pub struct spa_audio_info_aac {
3194 pub rate: u32,
3195 pub channels: u32,
3196 pub bitrate: u32,
3197 pub stream_format: spa_audio_aac_stream_format,
3198}
3199#[allow(clippy::unnecessary_operation, clippy::identity_op)]
3200const _: () = {
3201 ["Size of spa_audio_info_aac"][::std::mem::size_of::<spa_audio_info_aac>() - 16usize];
3202 ["Alignment of spa_audio_info_aac"][::std::mem::align_of::<spa_audio_info_aac>() - 4usize];
3203 ["Offset of field: spa_audio_info_aac::rate"]
3204 [::std::mem::offset_of!(spa_audio_info_aac, rate) - 0usize];
3205 ["Offset of field: spa_audio_info_aac::channels"]
3206 [::std::mem::offset_of!(spa_audio_info_aac, channels) - 4usize];
3207 ["Offset of field: spa_audio_info_aac::bitrate"]
3208 [::std::mem::offset_of!(spa_audio_info_aac, bitrate) - 8usize];
3209 ["Offset of field: spa_audio_info_aac::stream_format"]
3210 [::std::mem::offset_of!(spa_audio_info_aac, stream_format) - 12usize];
3211};
3212pub const SPA_AUDIO_WMA_PROFILE_UNKNOWN: spa_audio_wma_profile = 0;
3213pub const SPA_AUDIO_WMA_PROFILE_WMA7: spa_audio_wma_profile = 1;
3214pub const SPA_AUDIO_WMA_PROFILE_WMA8: spa_audio_wma_profile = 2;
3215pub const SPA_AUDIO_WMA_PROFILE_WMA9: spa_audio_wma_profile = 3;
3216pub const SPA_AUDIO_WMA_PROFILE_WMA10: spa_audio_wma_profile = 4;
3217pub const SPA_AUDIO_WMA_PROFILE_WMA9_PRO: spa_audio_wma_profile = 5;
3218pub const SPA_AUDIO_WMA_PROFILE_WMA9_LOSSLESS: spa_audio_wma_profile = 6;
3219pub const SPA_AUDIO_WMA_PROFILE_WMA10_LOSSLESS: spa_audio_wma_profile = 7;
3220pub const SPA_AUDIO_WMA_PROFILE_CUSTOM: spa_audio_wma_profile = 65536;
3221#[doc = " \\addtogroup spa_param\n \\{"]
3222pub type spa_audio_wma_profile = ::std::os::raw::c_uint;
3223#[repr(C)]
3224#[derive(Debug, Copy, Clone, PartialEq, Eq)]
3225pub struct spa_audio_info_wma {
3226 pub rate: u32,
3227 pub channels: u32,
3228 pub bitrate: u32,
3229 pub block_align: u32,
3230 pub profile: spa_audio_wma_profile,
3231}
3232#[allow(clippy::unnecessary_operation, clippy::identity_op)]
3233const _: () = {
3234 ["Size of spa_audio_info_wma"][::std::mem::size_of::<spa_audio_info_wma>() - 20usize];
3235 ["Alignment of spa_audio_info_wma"][::std::mem::align_of::<spa_audio_info_wma>() - 4usize];
3236 ["Offset of field: spa_audio_info_wma::rate"]
3237 [::std::mem::offset_of!(spa_audio_info_wma, rate) - 0usize];
3238 ["Offset of field: spa_audio_info_wma::channels"]
3239 [::std::mem::offset_of!(spa_audio_info_wma, channels) - 4usize];
3240 ["Offset of field: spa_audio_info_wma::bitrate"]
3241 [::std::mem::offset_of!(spa_audio_info_wma, bitrate) - 8usize];
3242 ["Offset of field: spa_audio_info_wma::block_align"]
3243 [::std::mem::offset_of!(spa_audio_info_wma, block_align) - 12usize];
3244 ["Offset of field: spa_audio_info_wma::profile"]
3245 [::std::mem::offset_of!(spa_audio_info_wma, profile) - 16usize];
3246};
3247pub const SPA_AUDIO_AMR_BAND_MODE_UNKNOWN: spa_audio_amr_band_mode = 0;
3248pub const SPA_AUDIO_AMR_BAND_MODE_NB: spa_audio_amr_band_mode = 1;
3249pub const SPA_AUDIO_AMR_BAND_MODE_WB: spa_audio_amr_band_mode = 2;
3250#[doc = " \\addtogroup spa_param\n \\{"]
3251pub type spa_audio_amr_band_mode = ::std::os::raw::c_uint;
3252#[repr(C)]
3253#[derive(Debug, Copy, Clone, PartialEq, Eq)]
3254pub struct spa_audio_info_amr {
3255 pub rate: u32,
3256 pub channels: u32,
3257 pub band_mode: spa_audio_amr_band_mode,
3258}
3259#[allow(clippy::unnecessary_operation, clippy::identity_op)]
3260const _: () = {
3261 ["Size of spa_audio_info_amr"][::std::mem::size_of::<spa_audio_info_amr>() - 12usize];
3262 ["Alignment of spa_audio_info_amr"][::std::mem::align_of::<spa_audio_info_amr>() - 4usize];
3263 ["Offset of field: spa_audio_info_amr::rate"]
3264 [::std::mem::offset_of!(spa_audio_info_amr, rate) - 0usize];
3265 ["Offset of field: spa_audio_info_amr::channels"]
3266 [::std::mem::offset_of!(spa_audio_info_amr, channels) - 4usize];
3267 ["Offset of field: spa_audio_info_amr::band_mode"]
3268 [::std::mem::offset_of!(spa_audio_info_amr, band_mode) - 8usize];
3269};
3270pub const SPA_BLUETOOTH_AUDIO_CODEC_START: spa_bluetooth_audio_codec = 0;
3271pub const SPA_BLUETOOTH_AUDIO_CODEC_SBC: spa_bluetooth_audio_codec = 1;
3272pub const SPA_BLUETOOTH_AUDIO_CODEC_SBC_XQ: spa_bluetooth_audio_codec = 2;
3273pub const SPA_BLUETOOTH_AUDIO_CODEC_MPEG: spa_bluetooth_audio_codec = 3;
3274pub const SPA_BLUETOOTH_AUDIO_CODEC_AAC: spa_bluetooth_audio_codec = 4;
3275pub const SPA_BLUETOOTH_AUDIO_CODEC_AAC_ELD: spa_bluetooth_audio_codec = 5;
3276pub const SPA_BLUETOOTH_AUDIO_CODEC_APTX: spa_bluetooth_audio_codec = 6;
3277pub const SPA_BLUETOOTH_AUDIO_CODEC_APTX_HD: spa_bluetooth_audio_codec = 7;
3278pub const SPA_BLUETOOTH_AUDIO_CODEC_LDAC: spa_bluetooth_audio_codec = 8;
3279pub const SPA_BLUETOOTH_AUDIO_CODEC_APTX_LL: spa_bluetooth_audio_codec = 9;
3280pub const SPA_BLUETOOTH_AUDIO_CODEC_APTX_LL_DUPLEX: spa_bluetooth_audio_codec = 10;
3281pub const SPA_BLUETOOTH_AUDIO_CODEC_FASTSTREAM: spa_bluetooth_audio_codec = 11;
3282pub const SPA_BLUETOOTH_AUDIO_CODEC_FASTSTREAM_DUPLEX: spa_bluetooth_audio_codec = 12;
3283pub const SPA_BLUETOOTH_AUDIO_CODEC_LC3PLUS_HR: spa_bluetooth_audio_codec = 13;
3284pub const SPA_BLUETOOTH_AUDIO_CODEC_OPUS_05: spa_bluetooth_audio_codec = 14;
3285pub const SPA_BLUETOOTH_AUDIO_CODEC_OPUS_05_51: spa_bluetooth_audio_codec = 15;
3286pub const SPA_BLUETOOTH_AUDIO_CODEC_OPUS_05_71: spa_bluetooth_audio_codec = 16;
3287pub const SPA_BLUETOOTH_AUDIO_CODEC_OPUS_05_DUPLEX: spa_bluetooth_audio_codec = 17;
3288pub const SPA_BLUETOOTH_AUDIO_CODEC_OPUS_05_PRO: spa_bluetooth_audio_codec = 18;
3289pub const SPA_BLUETOOTH_AUDIO_CODEC_OPUS_G: spa_bluetooth_audio_codec = 19;
3290pub const SPA_BLUETOOTH_AUDIO_CODEC_CVSD: spa_bluetooth_audio_codec = 256;
3291pub const SPA_BLUETOOTH_AUDIO_CODEC_MSBC: spa_bluetooth_audio_codec = 257;
3292pub const SPA_BLUETOOTH_AUDIO_CODEC_LC3_SWB: spa_bluetooth_audio_codec = 258;
3293pub const SPA_BLUETOOTH_AUDIO_CODEC_LC3: spa_bluetooth_audio_codec = 512;
3294pub const SPA_BLUETOOTH_AUDIO_CODEC_G722: spa_bluetooth_audio_codec = 768;
3295#[doc = " \\addtogroup spa_param\n \\{"]
3296pub type spa_bluetooth_audio_codec = ::std::os::raw::c_uint;
3297#[doc = "< unknown cositing"]
3298pub const SPA_VIDEO_CHROMA_SITE_UNKNOWN: spa_video_chroma_site = 0;
3299#[doc = "< no cositing"]
3300pub const SPA_VIDEO_CHROMA_SITE_NONE: spa_video_chroma_site = 1;
3301#[doc = "< chroma is horizontally cosited"]
3302pub const SPA_VIDEO_CHROMA_SITE_H_COSITED: spa_video_chroma_site = 2;
3303#[doc = "< chroma is vertically cosited"]
3304pub const SPA_VIDEO_CHROMA_SITE_V_COSITED: spa_video_chroma_site = 4;
3305#[doc = "< chroma samples are sited on alternate lines"]
3306pub const SPA_VIDEO_CHROMA_SITE_ALT_LINE: spa_video_chroma_site = 8;
3307#[doc = " chroma samples cosited with luma samples"]
3308pub const SPA_VIDEO_CHROMA_SITE_COSITED: spa_video_chroma_site = 6;
3309#[doc = " jpeg style cositing, also for mpeg1 and mjpeg"]
3310pub const SPA_VIDEO_CHROMA_SITE_JPEG: spa_video_chroma_site = 1;
3311#[doc = " mpeg2 style cositing"]
3312pub const SPA_VIDEO_CHROMA_SITE_MPEG2: spa_video_chroma_site = 2;
3313pub const SPA_VIDEO_CHROMA_SITE_DV: spa_video_chroma_site = 14;
3314#[doc = " Various Chroma settings."]
3315pub type spa_video_chroma_site = ::std::os::raw::c_uint;
3316#[doc = "< unknown range"]
3317pub const SPA_VIDEO_COLOR_RANGE_UNKNOWN: spa_video_color_range = 0;
3318#[doc = "< [0..255] for 8 bit components"]
3319pub const SPA_VIDEO_COLOR_RANGE_0_255: spa_video_color_range = 1;
3320#[doc = "< [16..235] for 8 bit components. Chroma has\n[16..240] range."]
3321pub const SPA_VIDEO_COLOR_RANGE_16_235: spa_video_color_range = 2;
3322#[doc = " Possible color range values. These constants are defined for 8 bit color\n values and can be scaled for other bit depths."]
3323pub type spa_video_color_range = ::std::os::raw::c_uint;
3324#[doc = "< unknown matrix"]
3325pub const SPA_VIDEO_COLOR_MATRIX_UNKNOWN: spa_video_color_matrix = 0;
3326#[doc = "< identity matrix"]
3327pub const SPA_VIDEO_COLOR_MATRIX_RGB: spa_video_color_matrix = 1;
3328#[doc = "< FCC color matrix"]
3329pub const SPA_VIDEO_COLOR_MATRIX_FCC: spa_video_color_matrix = 2;
3330#[doc = "< ITU BT.709 color matrix"]
3331pub const SPA_VIDEO_COLOR_MATRIX_BT709: spa_video_color_matrix = 3;
3332#[doc = "< ITU BT.601 color matrix"]
3333pub const SPA_VIDEO_COLOR_MATRIX_BT601: spa_video_color_matrix = 4;
3334#[doc = "< SMTPE 240M color matrix"]
3335pub const SPA_VIDEO_COLOR_MATRIX_SMPTE240M: spa_video_color_matrix = 5;
3336#[doc = "< ITU-R BT.2020 color matrix. since 1.6."]
3337pub const SPA_VIDEO_COLOR_MATRIX_BT2020: spa_video_color_matrix = 6;
3338#[doc = " The color matrix is used to convert between Y'PbPr and\n non-linear RGB (R'G'B')"]
3339pub type spa_video_color_matrix = ::std::os::raw::c_uint;
3340#[doc = "< unknown transfer function"]
3341pub const SPA_VIDEO_TRANSFER_UNKNOWN: spa_video_transfer_function = 0;
3342#[doc = "< linear RGB, gamma 1.0 curve"]
3343pub const SPA_VIDEO_TRANSFER_GAMMA10: spa_video_transfer_function = 1;
3344#[doc = "< Gamma 1.8 curve"]
3345pub const SPA_VIDEO_TRANSFER_GAMMA18: spa_video_transfer_function = 2;
3346#[doc = "< Gamma 2.0 curve"]
3347pub const SPA_VIDEO_TRANSFER_GAMMA20: spa_video_transfer_function = 3;
3348#[doc = "< Gamma 2.2 curve"]
3349pub const SPA_VIDEO_TRANSFER_GAMMA22: spa_video_transfer_function = 4;
3350#[doc = "< Gamma 2.2 curve with a linear segment in the lower range"]
3351pub const SPA_VIDEO_TRANSFER_BT709: spa_video_transfer_function = 5;
3352#[doc = "< Gamma 2.2 curve with a linear segment in the lower range"]
3353pub const SPA_VIDEO_TRANSFER_SMPTE240M: spa_video_transfer_function = 6;
3354#[doc = "< Gamma 2.4 curve with a linear segment in the lower range"]
3355pub const SPA_VIDEO_TRANSFER_SRGB: spa_video_transfer_function = 7;
3356#[doc = "< Gamma 2.8 curve"]
3357pub const SPA_VIDEO_TRANSFER_GAMMA28: spa_video_transfer_function = 8;
3358#[doc = "< Logarithmic transfer characteristic 100:1 range"]
3359pub const SPA_VIDEO_TRANSFER_LOG100: spa_video_transfer_function = 9;
3360#[doc = "< Logarithmic transfer characteristic 316.22777:1 range"]
3361pub const SPA_VIDEO_TRANSFER_LOG316: spa_video_transfer_function = 10;
3362#[doc = "< Gamma 2.2 curve with a linear segment in the lower\n range. Used for BT.2020 with 12 bits per\n component. \\since 1.6."]
3363pub const SPA_VIDEO_TRANSFER_BT2020_12: spa_video_transfer_function = 11;
3364#[doc = "< Gamma 2.19921875. \\since 1.8"]
3365pub const SPA_VIDEO_TRANSFER_ADOBERGB: spa_video_transfer_function = 12;
3366#[doc = " The video transfer function defines the formula for converting between\n non-linear RGB (R'G'B') and linear RGB"]
3367pub type spa_video_transfer_function = ::std::os::raw::c_uint;
3368#[doc = "< unknown color primaries"]
3369pub const SPA_VIDEO_COLOR_PRIMARIES_UNKNOWN: spa_video_color_primaries = 0;
3370#[doc = "< BT709 primaries"]
3371pub const SPA_VIDEO_COLOR_PRIMARIES_BT709: spa_video_color_primaries = 1;
3372#[doc = "< BT470M primaries"]
3373pub const SPA_VIDEO_COLOR_PRIMARIES_BT470M: spa_video_color_primaries = 2;
3374#[doc = "< BT470BG primaries"]
3375pub const SPA_VIDEO_COLOR_PRIMARIES_BT470BG: spa_video_color_primaries = 3;
3376#[doc = "< SMPTE170M primaries"]
3377pub const SPA_VIDEO_COLOR_PRIMARIES_SMPTE170M: spa_video_color_primaries = 4;
3378#[doc = "< SMPTE240M primaries"]
3379pub const SPA_VIDEO_COLOR_PRIMARIES_SMPTE240M: spa_video_color_primaries = 5;
3380#[doc = "< Generic film"]
3381pub const SPA_VIDEO_COLOR_PRIMARIES_FILM: spa_video_color_primaries = 6;
3382#[doc = "< BT2020 primaries. \\since 1.6."]
3383pub const SPA_VIDEO_COLOR_PRIMARIES_BT2020: spa_video_color_primaries = 7;
3384#[doc = "< Adobe RGB primaries. \\since 1.8"]
3385pub const SPA_VIDEO_COLOR_PRIMARIES_ADOBERGB: spa_video_color_primaries = 8;
3386#[doc = " The color primaries define the how to transform linear RGB values to and from\n the CIE XYZ colorspace."]
3387pub type spa_video_color_primaries = ::std::os::raw::c_uint;
3388#[doc = " spa_video_colorimetry:\n\n Structure describing the color info."]
3389#[repr(C)]
3390#[derive(Debug, Copy, Clone, PartialEq, Eq)]
3391pub struct spa_video_colorimetry {
3392 #[doc = "< The color range. This is the valid range for the\n samples. It is used to convert the samples to Y'PbPr\n values."]
3393 pub range: spa_video_color_range,
3394 #[doc = "< the color matrix. Used to convert between Y'PbPr and\n non-linear RGB (R'G'B')"]
3395 pub matrix: spa_video_color_matrix,
3396 #[doc = "< The transfer function. Used to convert between\n R'G'B' and RGB"]
3397 pub transfer: spa_video_transfer_function,
3398 #[doc = "< Color primaries. Used to convert between R'G'B'\n and CIE XYZ"]
3399 pub primaries: spa_video_color_primaries,
3400}
3401#[allow(clippy::unnecessary_operation, clippy::identity_op)]
3402const _: () = {
3403 ["Size of spa_video_colorimetry"][::std::mem::size_of::<spa_video_colorimetry>() - 16usize];
3404 ["Alignment of spa_video_colorimetry"]
3405 [::std::mem::align_of::<spa_video_colorimetry>() - 4usize];
3406 ["Offset of field: spa_video_colorimetry::range"]
3407 [::std::mem::offset_of!(spa_video_colorimetry, range) - 0usize];
3408 ["Offset of field: spa_video_colorimetry::matrix"]
3409 [::std::mem::offset_of!(spa_video_colorimetry, matrix) - 4usize];
3410 ["Offset of field: spa_video_colorimetry::transfer"]
3411 [::std::mem::offset_of!(spa_video_colorimetry, transfer) - 8usize];
3412 ["Offset of field: spa_video_colorimetry::primaries"]
3413 [::std::mem::offset_of!(spa_video_colorimetry, primaries) - 12usize];
3414};
3415#[doc = " A special value indicating no multiview information. Used in spa_video_info and other\n places to indicate that no specific multiview handling has been requested or provided.\n This value is never carried on caps."]
3416pub const SPA_VIDEO_MULTIVIEW_MODE_NONE: spa_video_multiview_mode = -1;
3417#[doc = "< All frames are monoscopic"]
3418pub const SPA_VIDEO_MULTIVIEW_MODE_MONO: spa_video_multiview_mode = 0;
3419#[doc = "< All frames represent a left-eye view"]
3420pub const SPA_VIDEO_MULTIVIEW_MODE_LEFT: spa_video_multiview_mode = 1;
3421#[doc = "< All frames represent a right-eye view"]
3422pub const SPA_VIDEO_MULTIVIEW_MODE_RIGHT: spa_video_multiview_mode = 2;
3423#[doc = "< Left and right eye views are provided\n in the left and right half of the frame\n respectively."]
3424pub const SPA_VIDEO_MULTIVIEW_MODE_SIDE_BY_SIDE: spa_video_multiview_mode = 3;
3425#[doc = "< Left and right eye views are provided\n in the left and right half of the\n frame, but have been sampled using\n quincunx method, with half-pixel offset\n between the 2 views."]
3426pub const SPA_VIDEO_MULTIVIEW_MODE_SIDE_BY_SIDE_QUINCUNX: spa_video_multiview_mode = 4;
3427#[doc = "< Alternating vertical columns of pixels\n represent the left and right eye view\n respectively."]
3428pub const SPA_VIDEO_MULTIVIEW_MODE_COLUMN_INTERLEAVED: spa_video_multiview_mode = 5;
3429#[doc = "< Alternating horizontal rows of pixels\n represent the left and right eye view\n respectively."]
3430pub const SPA_VIDEO_MULTIVIEW_MODE_ROW_INTERLEAVED: spa_video_multiview_mode = 6;
3431#[doc = "< The top half of the frame contains the\n left eye, and the bottom half the right\n eye."]
3432pub const SPA_VIDEO_MULTIVIEW_MODE_TOP_BOTTOM: spa_video_multiview_mode = 7;
3433#[doc = "< Pixels are arranged with alternating\n pixels representing left and right eye\n views in a checkerboard fashion."]
3434pub const SPA_VIDEO_MULTIVIEW_MODE_CHECKERBOARD: spa_video_multiview_mode = 8;
3435#[doc = "< Left and right eye views are provided\n in separate frames alternately."]
3436pub const SPA_VIDEO_MULTIVIEW_MODE_FRAME_BY_FRAME: spa_video_multiview_mode = 32;
3437#[doc = "< Multipleindependent views are\n provided in separate frames in\n sequence. This method only applies to\n raw video buffers at the moment.\n Specific view identification is via\n metadata on raw video buffers."]
3438pub const SPA_VIDEO_MULTIVIEW_MODE_MULTIVIEW_FRAME_BY_FRAME: spa_video_multiview_mode = 33;
3439#[doc = "< Multiple views are provided as separate\n \\ref spa_data framebuffers attached\n to each \\ref spa_buffer, described\n by the metadata"]
3440pub const SPA_VIDEO_MULTIVIEW_MODE_SEPARATED: spa_video_multiview_mode = 34;
3441#[doc = " All possible stereoscopic 3D and multiview representations.\n In conjunction with \\ref spa_video_multiview_flags, describes how\n multiview content is being transported in the stream."]
3442pub type spa_video_multiview_mode = ::std::os::raw::c_int;
3443#[doc = "< No flags"]
3444pub const SPA_VIDEO_MULTIVIEW_FLAGS_NONE: spa_video_multiview_flags = 0;
3445#[doc = "< For stereo streams, the normal arrangement\n of left and right views is reversed"]
3446pub const SPA_VIDEO_MULTIVIEW_FLAGS_RIGHT_VIEW_FIRST: spa_video_multiview_flags = 1;
3447#[doc = "< The left view is vertically mirrored"]
3448pub const SPA_VIDEO_MULTIVIEW_FLAGS_LEFT_FLIPPED: spa_video_multiview_flags = 2;
3449#[doc = "< The left view is horizontally mirrored"]
3450pub const SPA_VIDEO_MULTIVIEW_FLAGS_LEFT_FLOPPED: spa_video_multiview_flags = 4;
3451#[doc = "< The right view is vertically mirrored"]
3452pub const SPA_VIDEO_MULTIVIEW_FLAGS_RIGHT_FLIPPED: spa_video_multiview_flags = 8;
3453#[doc = "< The right view is horizontally mirrored"]
3454pub const SPA_VIDEO_MULTIVIEW_FLAGS_RIGHT_FLOPPED: spa_video_multiview_flags = 16;
3455#[doc = "< For frame-packed multiview\n modes, indicates that the individual\n views have been encoded with half the true\n width or height and should be scaled back\n up for display. This flag is used for\n overriding input layout interpretation\n by adjusting pixel-aspect-ratio.\n For side-by-side, column interleaved or\n checkerboard packings, the\n pixel width will be doubled.\n For row interleaved and\n top-bottom encodings, pixel height will\n be doubled"]
3456pub const SPA_VIDEO_MULTIVIEW_FLAGS_HALF_ASPECT: spa_video_multiview_flags = 16384;
3457#[doc = "< The video stream contains both\n mono and multiview portions,\n signalled on each buffer by the\n absence or presence of a buffer flag."]
3458pub const SPA_VIDEO_MULTIVIEW_FLAGS_MIXED_MONO: spa_video_multiview_flags = 32768;
3459#[doc = " spa_video_multiview_flags are used to indicate extra properties of a\n stereo/multiview stream beyond the frame layout and buffer mapping\n that is conveyed in the \\ref spa_video_multiview_mode."]
3460pub type spa_video_multiview_flags = ::std::os::raw::c_uint;
3461pub const SPA_VIDEO_FORMAT_UNKNOWN: spa_video_format = 0;
3462pub const SPA_VIDEO_FORMAT_ENCODED: spa_video_format = 1;
3463pub const SPA_VIDEO_FORMAT_I420: spa_video_format = 2;
3464pub const SPA_VIDEO_FORMAT_YV12: spa_video_format = 3;
3465pub const SPA_VIDEO_FORMAT_YUY2: spa_video_format = 4;
3466pub const SPA_VIDEO_FORMAT_UYVY: spa_video_format = 5;
3467pub const SPA_VIDEO_FORMAT_AYUV: spa_video_format = 6;
3468pub const SPA_VIDEO_FORMAT_RGBx: spa_video_format = 7;
3469pub const SPA_VIDEO_FORMAT_BGRx: spa_video_format = 8;
3470pub const SPA_VIDEO_FORMAT_xRGB: spa_video_format = 9;
3471pub const SPA_VIDEO_FORMAT_xBGR: spa_video_format = 10;
3472pub const SPA_VIDEO_FORMAT_RGBA: spa_video_format = 11;
3473pub const SPA_VIDEO_FORMAT_BGRA: spa_video_format = 12;
3474pub const SPA_VIDEO_FORMAT_ARGB: spa_video_format = 13;
3475pub const SPA_VIDEO_FORMAT_ABGR: spa_video_format = 14;
3476pub const SPA_VIDEO_FORMAT_RGB: spa_video_format = 15;
3477pub const SPA_VIDEO_FORMAT_BGR: spa_video_format = 16;
3478pub const SPA_VIDEO_FORMAT_Y41B: spa_video_format = 17;
3479pub const SPA_VIDEO_FORMAT_Y42B: spa_video_format = 18;
3480pub const SPA_VIDEO_FORMAT_YVYU: spa_video_format = 19;
3481pub const SPA_VIDEO_FORMAT_Y444: spa_video_format = 20;
3482pub const SPA_VIDEO_FORMAT_v210: spa_video_format = 21;
3483pub const SPA_VIDEO_FORMAT_v216: spa_video_format = 22;
3484pub const SPA_VIDEO_FORMAT_NV12: spa_video_format = 23;
3485pub const SPA_VIDEO_FORMAT_NV21: spa_video_format = 24;
3486pub const SPA_VIDEO_FORMAT_GRAY8: spa_video_format = 25;
3487pub const SPA_VIDEO_FORMAT_GRAY16_BE: spa_video_format = 26;
3488pub const SPA_VIDEO_FORMAT_GRAY16_LE: spa_video_format = 27;
3489pub const SPA_VIDEO_FORMAT_v308: spa_video_format = 28;
3490pub const SPA_VIDEO_FORMAT_RGB16: spa_video_format = 29;
3491pub const SPA_VIDEO_FORMAT_BGR16: spa_video_format = 30;
3492pub const SPA_VIDEO_FORMAT_RGB15: spa_video_format = 31;
3493pub const SPA_VIDEO_FORMAT_BGR15: spa_video_format = 32;
3494pub const SPA_VIDEO_FORMAT_UYVP: spa_video_format = 33;
3495pub const SPA_VIDEO_FORMAT_A420: spa_video_format = 34;
3496pub const SPA_VIDEO_FORMAT_RGB8P: spa_video_format = 35;
3497pub const SPA_VIDEO_FORMAT_YUV9: spa_video_format = 36;
3498pub const SPA_VIDEO_FORMAT_YVU9: spa_video_format = 37;
3499pub const SPA_VIDEO_FORMAT_IYU1: spa_video_format = 38;
3500pub const SPA_VIDEO_FORMAT_ARGB64: spa_video_format = 39;
3501pub const SPA_VIDEO_FORMAT_AYUV64: spa_video_format = 40;
3502pub const SPA_VIDEO_FORMAT_r210: spa_video_format = 41;
3503pub const SPA_VIDEO_FORMAT_I420_10BE: spa_video_format = 42;
3504pub const SPA_VIDEO_FORMAT_I420_10LE: spa_video_format = 43;
3505pub const SPA_VIDEO_FORMAT_I422_10BE: spa_video_format = 44;
3506pub const SPA_VIDEO_FORMAT_I422_10LE: spa_video_format = 45;
3507pub const SPA_VIDEO_FORMAT_Y444_10BE: spa_video_format = 46;
3508pub const SPA_VIDEO_FORMAT_Y444_10LE: spa_video_format = 47;
3509pub const SPA_VIDEO_FORMAT_GBR: spa_video_format = 48;
3510pub const SPA_VIDEO_FORMAT_GBR_10BE: spa_video_format = 49;
3511pub const SPA_VIDEO_FORMAT_GBR_10LE: spa_video_format = 50;
3512pub const SPA_VIDEO_FORMAT_NV16: spa_video_format = 51;
3513pub const SPA_VIDEO_FORMAT_NV24: spa_video_format = 52;
3514pub const SPA_VIDEO_FORMAT_NV12_64Z32: spa_video_format = 53;
3515pub const SPA_VIDEO_FORMAT_A420_10BE: spa_video_format = 54;
3516pub const SPA_VIDEO_FORMAT_A420_10LE: spa_video_format = 55;
3517pub const SPA_VIDEO_FORMAT_A422_10BE: spa_video_format = 56;
3518pub const SPA_VIDEO_FORMAT_A422_10LE: spa_video_format = 57;
3519pub const SPA_VIDEO_FORMAT_A444_10BE: spa_video_format = 58;
3520pub const SPA_VIDEO_FORMAT_A444_10LE: spa_video_format = 59;
3521pub const SPA_VIDEO_FORMAT_NV61: spa_video_format = 60;
3522pub const SPA_VIDEO_FORMAT_P010_10BE: spa_video_format = 61;
3523pub const SPA_VIDEO_FORMAT_P010_10LE: spa_video_format = 62;
3524pub const SPA_VIDEO_FORMAT_IYU2: spa_video_format = 63;
3525pub const SPA_VIDEO_FORMAT_VYUY: spa_video_format = 64;
3526pub const SPA_VIDEO_FORMAT_GBRA: spa_video_format = 65;
3527pub const SPA_VIDEO_FORMAT_GBRA_10BE: spa_video_format = 66;
3528pub const SPA_VIDEO_FORMAT_GBRA_10LE: spa_video_format = 67;
3529pub const SPA_VIDEO_FORMAT_GBR_12BE: spa_video_format = 68;
3530pub const SPA_VIDEO_FORMAT_GBR_12LE: spa_video_format = 69;
3531pub const SPA_VIDEO_FORMAT_GBRA_12BE: spa_video_format = 70;
3532pub const SPA_VIDEO_FORMAT_GBRA_12LE: spa_video_format = 71;
3533pub const SPA_VIDEO_FORMAT_I420_12BE: spa_video_format = 72;
3534pub const SPA_VIDEO_FORMAT_I420_12LE: spa_video_format = 73;
3535pub const SPA_VIDEO_FORMAT_I422_12BE: spa_video_format = 74;
3536pub const SPA_VIDEO_FORMAT_I422_12LE: spa_video_format = 75;
3537pub const SPA_VIDEO_FORMAT_Y444_12BE: spa_video_format = 76;
3538pub const SPA_VIDEO_FORMAT_Y444_12LE: spa_video_format = 77;
3539pub const SPA_VIDEO_FORMAT_RGBA_F16: spa_video_format = 78;
3540pub const SPA_VIDEO_FORMAT_RGBA_F32: spa_video_format = 79;
3541#[doc = "< 32-bit x:R:G:B 2:10:10:10 little endian"]
3542pub const SPA_VIDEO_FORMAT_xRGB_210LE: spa_video_format = 80;
3543#[doc = "< 32-bit x:B:G:R 2:10:10:10 little endian"]
3544pub const SPA_VIDEO_FORMAT_xBGR_210LE: spa_video_format = 81;
3545#[doc = "< 32-bit R:G:B:x 10:10:10:2 little endian"]
3546pub const SPA_VIDEO_FORMAT_RGBx_102LE: spa_video_format = 82;
3547#[doc = "< 32-bit B:G:R:x 10:10:10:2 little endian"]
3548pub const SPA_VIDEO_FORMAT_BGRx_102LE: spa_video_format = 83;
3549#[doc = "< 32-bit A:R:G:B 2:10:10:10 little endian"]
3550pub const SPA_VIDEO_FORMAT_ARGB_210LE: spa_video_format = 84;
3551#[doc = "< 32-bit A:B:G:R 2:10:10:10 little endian"]
3552pub const SPA_VIDEO_FORMAT_ABGR_210LE: spa_video_format = 85;
3553#[doc = "< 32-bit R:G:B:A 10:10:10:2 little endian"]
3554pub const SPA_VIDEO_FORMAT_RGBA_102LE: spa_video_format = 86;
3555#[doc = "< 32-bit B:G:R:A 10:10:10:2 little endian"]
3556pub const SPA_VIDEO_FORMAT_BGRA_102LE: spa_video_format = 87;
3557pub const SPA_VIDEO_FORMAT_DSP_F32: spa_video_format = 79;
3558#[doc = " Video formats\n\n The components are in general described in big-endian order. There are some\n exceptions (e.g. RGB15 and RGB16) which use the host endianness.\n\n Most of the formats are identical to their GStreamer equivalent. See the\n GStreamer video formats documentation for more details:\n\n https://gstreamer.freedesktop.org/documentation/additional/design/mediatype-video-raw.html#formats"]
3559pub type spa_video_format = ::std::os::raw::c_uint;
3560#[doc = "< no flags"]
3561pub const SPA_VIDEO_FLAG_NONE: spa_video_flags = 0;
3562#[doc = "< a variable fps is selected, fps_n and fps_d\n denote the maximum fps of the video"]
3563pub const SPA_VIDEO_FLAG_VARIABLE_FPS: spa_video_flags = 1;
3564#[doc = "< Each color has been scaled by the alpha value."]
3565pub const SPA_VIDEO_FLAG_PREMULTIPLIED_ALPHA: spa_video_flags = 2;
3566#[doc = "< use the format modifier"]
3567pub const SPA_VIDEO_FLAG_MODIFIER: spa_video_flags = 4;
3568#[doc = "< format modifier was not fixated yet"]
3569pub const SPA_VIDEO_FLAG_MODIFIER_FIXATION_REQUIRED: spa_video_flags = 8;
3570#[doc = " Extra video flags"]
3571pub type spa_video_flags = ::std::os::raw::c_uint;
3572#[doc = "< all frames are progressive"]
3573pub const SPA_VIDEO_INTERLACE_MODE_PROGRESSIVE: spa_video_interlace_mode = 0;
3574#[doc = "< 2 fields are interleaved in one video frame.\n Extra buffer flags describe the field order."]
3575pub const SPA_VIDEO_INTERLACE_MODE_INTERLEAVED: spa_video_interlace_mode = 1;
3576#[doc = "< frames contains both interlaced and progressive\n video, the buffer flags describe the frame and\n fields."]
3577pub const SPA_VIDEO_INTERLACE_MODE_MIXED: spa_video_interlace_mode = 2;
3578#[doc = "< 2 fields are stored in one buffer, use the\n frame ID to get access to the required\n field. For multiview (the 'views'\n property > 1) the fields of view N can\n be found at frame ID (N * 2) and (N *\n 2) + 1. Each field has only half the\n amount of lines as noted in the height\n property. This mode requires multiple\n spa_data to describe the fields."]
3579pub const SPA_VIDEO_INTERLACE_MODE_FIELDS: spa_video_interlace_mode = 3;
3580#[doc = " The possible values of the #spa_video_interlace_mode describing the interlace\n mode of the stream."]
3581pub type spa_video_interlace_mode = ::std::os::raw::c_uint;
3582#[repr(C)]
3583#[derive(Debug, Copy, Clone, PartialEq, Eq)]
3584pub struct spa_video_info_raw {
3585 #[doc = "< the format"]
3586 pub format: spa_video_format,
3587 #[doc = "< extra video flags"]
3588 pub flags: u32,
3589 #[doc = "< format modifier\n only used with DMA-BUF"]
3590 pub modifier: u64,
3591 #[doc = "< the frame size of the video"]
3592 pub size: spa_rectangle,
3593 #[doc = "< the framerate of the video, 0/1 means variable rate"]
3594 pub framerate: spa_fraction,
3595 #[doc = "< the maximum framerate of the video. This is only valid when\n\\ref framerate is 0/1"]
3596 pub max_framerate: spa_fraction,
3597 #[doc = "< the number of views in this video"]
3598 pub views: u32,
3599 #[doc = "< the interlace mode"]
3600 pub interlace_mode: spa_video_interlace_mode,
3601 #[doc = "< the pixel aspect ratio"]
3602 pub pixel_aspect_ratio: spa_fraction,
3603 #[doc = "< multiview mode"]
3604 pub multiview_mode: spa_video_multiview_mode,
3605 #[doc = "< multiview flags"]
3606 pub multiview_flags: spa_video_multiview_flags,
3607 #[doc = "< the chroma siting"]
3608 pub chroma_site: spa_video_chroma_site,
3609 #[doc = "< the color range. This is the valid range for the samples.\n It is used to convert the samples to Y'PbPr values."]
3610 pub color_range: spa_video_color_range,
3611 #[doc = "< the color matrix. Used to convert between Y'PbPr and\n non-linear RGB (R'G'B')"]
3612 pub color_matrix: spa_video_color_matrix,
3613 #[doc = "< the transfer function. used to convert between R'G'B' and RGB"]
3614 pub transfer_function: spa_video_transfer_function,
3615 #[doc = "< color primaries. used to convert between R'G'B' and CIE XYZ"]
3616 pub color_primaries: spa_video_color_primaries,
3617}
3618#[allow(clippy::unnecessary_operation, clippy::identity_op)]
3619const _: () = {
3620 ["Size of spa_video_info_raw"][::std::mem::size_of::<spa_video_info_raw>() - 88usize];
3621 ["Alignment of spa_video_info_raw"][::std::mem::align_of::<spa_video_info_raw>() - 8usize];
3622 ["Offset of field: spa_video_info_raw::format"]
3623 [::std::mem::offset_of!(spa_video_info_raw, format) - 0usize];
3624 ["Offset of field: spa_video_info_raw::flags"]
3625 [::std::mem::offset_of!(spa_video_info_raw, flags) - 4usize];
3626 ["Offset of field: spa_video_info_raw::modifier"]
3627 [::std::mem::offset_of!(spa_video_info_raw, modifier) - 8usize];
3628 ["Offset of field: spa_video_info_raw::size"]
3629 [::std::mem::offset_of!(spa_video_info_raw, size) - 16usize];
3630 ["Offset of field: spa_video_info_raw::framerate"]
3631 [::std::mem::offset_of!(spa_video_info_raw, framerate) - 24usize];
3632 ["Offset of field: spa_video_info_raw::max_framerate"]
3633 [::std::mem::offset_of!(spa_video_info_raw, max_framerate) - 32usize];
3634 ["Offset of field: spa_video_info_raw::views"]
3635 [::std::mem::offset_of!(spa_video_info_raw, views) - 40usize];
3636 ["Offset of field: spa_video_info_raw::interlace_mode"]
3637 [::std::mem::offset_of!(spa_video_info_raw, interlace_mode) - 44usize];
3638 ["Offset of field: spa_video_info_raw::pixel_aspect_ratio"]
3639 [::std::mem::offset_of!(spa_video_info_raw, pixel_aspect_ratio) - 48usize];
3640 ["Offset of field: spa_video_info_raw::multiview_mode"]
3641 [::std::mem::offset_of!(spa_video_info_raw, multiview_mode) - 56usize];
3642 ["Offset of field: spa_video_info_raw::multiview_flags"]
3643 [::std::mem::offset_of!(spa_video_info_raw, multiview_flags) - 60usize];
3644 ["Offset of field: spa_video_info_raw::chroma_site"]
3645 [::std::mem::offset_of!(spa_video_info_raw, chroma_site) - 64usize];
3646 ["Offset of field: spa_video_info_raw::color_range"]
3647 [::std::mem::offset_of!(spa_video_info_raw, color_range) - 68usize];
3648 ["Offset of field: spa_video_info_raw::color_matrix"]
3649 [::std::mem::offset_of!(spa_video_info_raw, color_matrix) - 72usize];
3650 ["Offset of field: spa_video_info_raw::transfer_function"]
3651 [::std::mem::offset_of!(spa_video_info_raw, transfer_function) - 76usize];
3652 ["Offset of field: spa_video_info_raw::color_primaries"]
3653 [::std::mem::offset_of!(spa_video_info_raw, color_primaries) - 80usize];
3654};
3655unsafe extern "C" {
3656 #[link_name = "spa_type_video_format_from_short_name_libspa_rs"]
3657 pub fn spa_type_video_format_from_short_name(name: *const ::std::os::raw::c_char) -> u32;
3658}
3659unsafe extern "C" {
3660 #[link_name = "spa_type_video_format_to_short_name_libspa_rs"]
3661 pub fn spa_type_video_format_to_short_name(type_: u32) -> *const ::std::os::raw::c_char;
3662}
3663pub const SPA_PARAM_LATENCY_START: spa_param_latency = 0;
3664#[doc = "< direction, input/output (Id enum spa_direction)"]
3665pub const SPA_PARAM_LATENCY_direction: spa_param_latency = 1;
3666#[doc = "< min latency relative to quantum (Float)"]
3667pub const SPA_PARAM_LATENCY_minQuantum: spa_param_latency = 2;
3668#[doc = "< max latency relative to quantum (Float)"]
3669pub const SPA_PARAM_LATENCY_maxQuantum: spa_param_latency = 3;
3670#[doc = "< min latency (Int) relative to graph rate"]
3671pub const SPA_PARAM_LATENCY_minRate: spa_param_latency = 4;
3672#[doc = "< max latency (Int) relative to graph rate"]
3673pub const SPA_PARAM_LATENCY_maxRate: spa_param_latency = 5;
3674#[doc = "< min latency (Long) in nanoseconds"]
3675pub const SPA_PARAM_LATENCY_minNs: spa_param_latency = 6;
3676#[doc = "< max latency (Long) in nanoseconds"]
3677pub const SPA_PARAM_LATENCY_maxNs: spa_param_latency = 7;
3678#[doc = " Properties for SPA_TYPE_OBJECT_ParamLatency\n\n The latency indicates:\n\n - for playback: time delay between start of a graph cycle, and the rendering of\n the first sample of that cycle in audio output.\n\n - for capture: time delay between start of a graph cycle, and the first sample\n of that cycle having occurred in audio input.\n\n For physical output/input, the latency is intended to correspond to the\n rendering/capture of physical audio, including hardware internal rendering delay.\n\n The latency values are adjusted by \\ref SPA_PROP_latencyOffsetNsec or\n SPA_PARAM_ProcessLatency, if present. (e.g. for ALSA this is used to adjust for\n the internal hardware latency)."]
3679pub type spa_param_latency = ::std::os::raw::c_uint;
3680#[doc = " helper structure for managing latency objects"]
3681#[repr(C)]
3682#[derive(Debug, Copy, Clone, PartialEq)]
3683pub struct spa_latency_info {
3684 pub direction: spa_direction,
3685 pub min_quantum: f32,
3686 pub max_quantum: f32,
3687 pub min_rate: i32,
3688 pub max_rate: i32,
3689 pub min_ns: i64,
3690 pub max_ns: i64,
3691}
3692#[allow(clippy::unnecessary_operation, clippy::identity_op)]
3693const _: () = {
3694 ["Size of spa_latency_info"][::std::mem::size_of::<spa_latency_info>() - 40usize];
3695 ["Alignment of spa_latency_info"][::std::mem::align_of::<spa_latency_info>() - 8usize];
3696 ["Offset of field: spa_latency_info::direction"]
3697 [::std::mem::offset_of!(spa_latency_info, direction) - 0usize];
3698 ["Offset of field: spa_latency_info::min_quantum"]
3699 [::std::mem::offset_of!(spa_latency_info, min_quantum) - 4usize];
3700 ["Offset of field: spa_latency_info::max_quantum"]
3701 [::std::mem::offset_of!(spa_latency_info, max_quantum) - 8usize];
3702 ["Offset of field: spa_latency_info::min_rate"]
3703 [::std::mem::offset_of!(spa_latency_info, min_rate) - 12usize];
3704 ["Offset of field: spa_latency_info::max_rate"]
3705 [::std::mem::offset_of!(spa_latency_info, max_rate) - 16usize];
3706 ["Offset of field: spa_latency_info::min_ns"]
3707 [::std::mem::offset_of!(spa_latency_info, min_ns) - 24usize];
3708 ["Offset of field: spa_latency_info::max_ns"]
3709 [::std::mem::offset_of!(spa_latency_info, max_ns) - 32usize];
3710};
3711pub const SPA_PARAM_PROCESS_LATENCY_START: spa_param_process_latency = 0;
3712#[doc = "< latency relative to quantum (Float)"]
3713pub const SPA_PARAM_PROCESS_LATENCY_quantum: spa_param_process_latency = 1;
3714#[doc = "< latency (Int) relative to graph rate"]
3715pub const SPA_PARAM_PROCESS_LATENCY_rate: spa_param_process_latency = 2;
3716#[doc = "< latency (Long) in nanoseconds"]
3717pub const SPA_PARAM_PROCESS_LATENCY_ns: spa_param_process_latency = 3;
3718#[doc = " Properties for SPA_TYPE_OBJECT_ParamProcessLatency\n\n The processing latency indicates logical time delay between a sample in an input port,\n and a corresponding sample in an output port, relative to the graph time."]
3719pub type spa_param_process_latency = ::std::os::raw::c_uint;
3720#[doc = " Helper structure for managing process latency objects"]
3721#[repr(C)]
3722#[derive(Debug, Copy, Clone, PartialEq)]
3723pub struct spa_process_latency_info {
3724 pub quantum: f32,
3725 pub rate: i32,
3726 pub ns: i64,
3727}
3728#[allow(clippy::unnecessary_operation, clippy::identity_op)]
3729const _: () = {
3730 ["Size of spa_process_latency_info"]
3731 [::std::mem::size_of::<spa_process_latency_info>() - 16usize];
3732 ["Alignment of spa_process_latency_info"]
3733 [::std::mem::align_of::<spa_process_latency_info>() - 8usize];
3734 ["Offset of field: spa_process_latency_info::quantum"]
3735 [::std::mem::offset_of!(spa_process_latency_info, quantum) - 0usize];
3736 ["Offset of field: spa_process_latency_info::rate"]
3737 [::std::mem::offset_of!(spa_process_latency_info, rate) - 4usize];
3738 ["Offset of field: spa_process_latency_info::ns"]
3739 [::std::mem::offset_of!(spa_process_latency_info, ns) - 8usize];
3740};
3741pub const SPA_PROFILER_START: spa_profiler = 0;
3742#[doc = "< driver related profiler properties"]
3743pub const SPA_PROFILER_START_Driver: spa_profiler = 65536;
3744#[doc = "< Generic info, counter and CPU load,\n (Struct(\n Long : counter,\n Float : cpu_load fast,\n Float : cpu_load medium,\n Float : cpu_load slow),\n Int : xrun-count))"]
3745pub const SPA_PROFILER_info: spa_profiler = 65537;
3746#[doc = "< clock information\n (Struct(\n Int : clock flags,\n Int : clock id,\n String: clock name,\n Long : clock nsec,\n Fraction : clock rate,\n Long : clock position,\n Long : clock duration,\n Long : clock delay,\n Double : clock rate_diff,\n Long : clock next_nsec,\n Int : transport_state,\n Int : clock cycle,\n Long : xrun duration))"]
3747pub const SPA_PROFILER_clock: spa_profiler = 65538;
3748#[doc = "< generic driver info block\n (Struct(\n Int : driver_id,\n String : name,\n Long : driver prev_signal,\n Long : driver signal,\n Long : driver awake,\n Long : driver finish,\n Int : driver status,\n Fraction : latency,\n Int : xrun_count))"]
3749pub const SPA_PROFILER_driverBlock: spa_profiler = 65539;
3750#[doc = "< follower related profiler properties"]
3751pub const SPA_PROFILER_START_Follower: spa_profiler = 131072;
3752#[doc = "< generic follower info block\n (Struct(\n Int : id,\n String : name,\n Long : prev_signal,\n Long : signal,\n Long : awake,\n Long : finish,\n Int : status,\n Fraction : latency,\n Int : xrun_count))"]
3753pub const SPA_PROFILER_followerBlock: spa_profiler = 131073;
3754#[doc = "< follower clock information\n (Struct(\n Int : clock id,\n String: clock name,\n Long : clock nsec,\n Fraction : clock rate,\n Long : clock position,\n Long : clock duration,\n Long : clock delay,\n Double : clock rate_diff,\n Long : clock next_nsec,\n Long : xrun duration))"]
3755pub const SPA_PROFILER_followerClock: spa_profiler = 131074;
3756pub const SPA_PROFILER_START_CUSTOM: spa_profiler = 16777216;
3757#[doc = " properties for SPA_TYPE_OBJECT_Profiler"]
3758pub type spa_profiler = ::std::os::raw::c_uint;
3759pub const SPA_PARAM_TAG_START: spa_param_tag = 0;
3760#[doc = "< direction, input/output (Id enum spa_direction)"]
3761pub const SPA_PARAM_TAG_direction: spa_param_tag = 1;
3762#[doc = "< Struct(\n Int: n_items\n (String: key\n String: value)*\n )"]
3763pub const SPA_PARAM_TAG_info: spa_param_tag = 2;
3764#[doc = " properties for SPA_TYPE_OBJECT_ParamTag"]
3765pub type spa_param_tag = ::std::os::raw::c_uint;
3766#[doc = " helper structure for managing tag objects"]
3767#[repr(C)]
3768#[derive(Debug, Copy, Clone, PartialEq, Eq)]
3769pub struct spa_tag_info {
3770 pub direction: spa_direction,
3771 pub info: *const spa_pod,
3772}
3773#[allow(clippy::unnecessary_operation, clippy::identity_op)]
3774const _: () = {
3775 ["Size of spa_tag_info"][::std::mem::size_of::<spa_tag_info>() - 16usize];
3776 ["Alignment of spa_tag_info"][::std::mem::align_of::<spa_tag_info>() - 8usize];
3777 ["Offset of field: spa_tag_info::direction"]
3778 [::std::mem::offset_of!(spa_tag_info, direction) - 0usize];
3779 ["Offset of field: spa_tag_info::info"][::std::mem::offset_of!(spa_tag_info, info) - 8usize];
3780};
3781unsafe extern "C" {
3782 #[link_name = "spa_debug_type_find_libspa_rs"]
3783 pub fn spa_debug_type_find(info: *const spa_type_info, type_: u32) -> *const spa_type_info;
3784}
3785unsafe extern "C" {
3786 #[link_name = "spa_debug_type_short_name_libspa_rs"]
3787 pub fn spa_debug_type_short_name(
3788 name: *const ::std::os::raw::c_char,
3789 ) -> *const ::std::os::raw::c_char;
3790}
3791unsafe extern "C" {
3792 #[link_name = "spa_debug_type_find_name_libspa_rs"]
3793 pub fn spa_debug_type_find_name(
3794 info: *const spa_type_info,
3795 type_: u32,
3796 ) -> *const ::std::os::raw::c_char;
3797}
3798unsafe extern "C" {
3799 #[link_name = "spa_debug_type_find_short_name_libspa_rs"]
3800 pub fn spa_debug_type_find_short_name(
3801 info: *const spa_type_info,
3802 type_: u32,
3803 ) -> *const ::std::os::raw::c_char;
3804}
3805unsafe extern "C" {
3806 #[link_name = "spa_debug_type_find_type_libspa_rs"]
3807 pub fn spa_debug_type_find_type(
3808 info: *const spa_type_info,
3809 name: *const ::std::os::raw::c_char,
3810 ) -> u32;
3811}
3812unsafe extern "C" {
3813 #[link_name = "spa_debug_type_find_short_libspa_rs"]
3814 pub fn spa_debug_type_find_short(
3815 info: *const spa_type_info,
3816 name: *const ::std::os::raw::c_char,
3817 ) -> *const spa_type_info;
3818}
3819unsafe extern "C" {
3820 #[link_name = "spa_debug_type_find_type_short_libspa_rs"]
3821 pub fn spa_debug_type_find_type_short(
3822 info: *const spa_type_info,
3823 name: *const ::std::os::raw::c_char,
3824 ) -> u32;
3825}
3826unsafe extern "C" {
3827 #[link_name = "spa_debugc_buffer_libspa_rs"]
3828 pub fn spa_debugc_buffer(
3829 ctx: *mut spa_debug_context,
3830 indent: ::std::os::raw::c_int,
3831 buffer: *const spa_buffer,
3832 ) -> ::std::os::raw::c_int;
3833}
3834unsafe extern "C" {
3835 #[link_name = "spa_debug_buffer_libspa_rs"]
3836 pub fn spa_debug_buffer(
3837 indent: ::std::os::raw::c_int,
3838 buffer: *const spa_buffer,
3839 ) -> ::std::os::raw::c_int;
3840}
3841#[doc = " \\addtogroup spa_dict\n \\{"]
3842#[repr(C)]
3843#[derive(Debug, Copy, Clone, PartialEq, Eq)]
3844pub struct spa_dict_item {
3845 pub key: *const ::std::os::raw::c_char,
3846 pub value: *const ::std::os::raw::c_char,
3847}
3848#[allow(clippy::unnecessary_operation, clippy::identity_op)]
3849const _: () = {
3850 ["Size of spa_dict_item"][::std::mem::size_of::<spa_dict_item>() - 16usize];
3851 ["Alignment of spa_dict_item"][::std::mem::align_of::<spa_dict_item>() - 8usize];
3852 ["Offset of field: spa_dict_item::key"][::std::mem::offset_of!(spa_dict_item, key) - 0usize];
3853 ["Offset of field: spa_dict_item::value"]
3854 [::std::mem::offset_of!(spa_dict_item, value) - 8usize];
3855};
3856#[repr(C)]
3857#[derive(Debug, Copy, Clone, PartialEq, Eq)]
3858pub struct spa_dict {
3859 pub flags: u32,
3860 pub n_items: u32,
3861 pub items: *const spa_dict_item,
3862}
3863#[allow(clippy::unnecessary_operation, clippy::identity_op)]
3864const _: () = {
3865 ["Size of spa_dict"][::std::mem::size_of::<spa_dict>() - 16usize];
3866 ["Alignment of spa_dict"][::std::mem::align_of::<spa_dict>() - 8usize];
3867 ["Offset of field: spa_dict::flags"][::std::mem::offset_of!(spa_dict, flags) - 0usize];
3868 ["Offset of field: spa_dict::n_items"][::std::mem::offset_of!(spa_dict, n_items) - 4usize];
3869 ["Offset of field: spa_dict::items"][::std::mem::offset_of!(spa_dict, items) - 8usize];
3870};
3871unsafe extern "C" {
3872 #[link_name = "spa_dict_item_compare_libspa_rs"]
3873 pub fn spa_dict_item_compare(
3874 i1: *const ::std::os::raw::c_void,
3875 i2: *const ::std::os::raw::c_void,
3876 ) -> ::std::os::raw::c_int;
3877}
3878unsafe extern "C" {
3879 #[link_name = "spa_dict_qsort_libspa_rs"]
3880 pub fn spa_dict_qsort(dict: *mut spa_dict);
3881}
3882unsafe extern "C" {
3883 #[link_name = "spa_dict_lookup_item_libspa_rs"]
3884 pub fn spa_dict_lookup_item(
3885 dict: *const spa_dict,
3886 key: *const ::std::os::raw::c_char,
3887 ) -> *const spa_dict_item;
3888}
3889unsafe extern "C" {
3890 #[link_name = "spa_dict_lookup_libspa_rs"]
3891 pub fn spa_dict_lookup(
3892 dict: *const spa_dict,
3893 key: *const ::std::os::raw::c_char,
3894 ) -> *const ::std::os::raw::c_char;
3895}
3896unsafe extern "C" {
3897 #[link_name = "spa_debugc_dict_libspa_rs"]
3898 pub fn spa_debugc_dict(
3899 ctx: *mut spa_debug_context,
3900 indent: ::std::os::raw::c_int,
3901 dict: *const spa_dict,
3902 ) -> ::std::os::raw::c_int;
3903}
3904unsafe extern "C" {
3905 #[link_name = "spa_debug_dict_libspa_rs"]
3906 pub fn spa_debug_dict(
3907 indent: ::std::os::raw::c_int,
3908 dict: *const spa_dict,
3909 ) -> ::std::os::raw::c_int;
3910}
3911#[doc = " \\addtogroup spa_pod\n \\{"]
3912#[repr(C)]
3913#[derive(Debug, Copy, Clone, PartialEq, Eq)]
3914pub struct spa_pod_frame {
3915 pub pod: spa_pod,
3916 pub parent: *mut spa_pod_frame,
3917 pub offset: u32,
3918 pub flags: u32,
3919}
3920#[allow(clippy::unnecessary_operation, clippy::identity_op)]
3921const _: () = {
3922 ["Size of spa_pod_frame"][::std::mem::size_of::<spa_pod_frame>() - 24usize];
3923 ["Alignment of spa_pod_frame"][::std::mem::align_of::<spa_pod_frame>() - 8usize];
3924 ["Offset of field: spa_pod_frame::pod"][::std::mem::offset_of!(spa_pod_frame, pod) - 0usize];
3925 ["Offset of field: spa_pod_frame::parent"]
3926 [::std::mem::offset_of!(spa_pod_frame, parent) - 8usize];
3927 ["Offset of field: spa_pod_frame::offset"]
3928 [::std::mem::offset_of!(spa_pod_frame, offset) - 16usize];
3929 ["Offset of field: spa_pod_frame::flags"]
3930 [::std::mem::offset_of!(spa_pod_frame, flags) - 20usize];
3931};
3932unsafe extern "C" {
3933 #[link_name = "spa_pod_is_inside_libspa_rs"]
3934 pub fn spa_pod_is_inside(
3935 pod: *const ::std::os::raw::c_void,
3936 size: u32,
3937 iter: *const ::std::os::raw::c_void,
3938 ) -> bool;
3939}
3940unsafe extern "C" {
3941 #[link_name = "spa_pod_next_libspa_rs"]
3942 pub fn spa_pod_next(iter: *const ::std::os::raw::c_void) -> *mut ::std::os::raw::c_void;
3943}
3944unsafe extern "C" {
3945 #[link_name = "spa_pod_prop_first_libspa_rs"]
3946 pub fn spa_pod_prop_first(body: *const spa_pod_object_body) -> *mut spa_pod_prop;
3947}
3948unsafe extern "C" {
3949 #[link_name = "spa_pod_prop_is_inside_libspa_rs"]
3950 pub fn spa_pod_prop_is_inside(
3951 body: *const spa_pod_object_body,
3952 size: u32,
3953 iter: *const spa_pod_prop,
3954 ) -> bool;
3955}
3956unsafe extern "C" {
3957 #[link_name = "spa_pod_prop_next_libspa_rs"]
3958 pub fn spa_pod_prop_next(iter: *const spa_pod_prop) -> *mut spa_pod_prop;
3959}
3960unsafe extern "C" {
3961 #[link_name = "spa_pod_control_first_libspa_rs"]
3962 pub fn spa_pod_control_first(body: *const spa_pod_sequence_body) -> *mut spa_pod_control;
3963}
3964unsafe extern "C" {
3965 #[link_name = "spa_pod_control_is_inside_libspa_rs"]
3966 pub fn spa_pod_control_is_inside(
3967 body: *const spa_pod_sequence_body,
3968 size: u32,
3969 iter: *const spa_pod_control,
3970 ) -> bool;
3971}
3972unsafe extern "C" {
3973 #[link_name = "spa_pod_control_next_libspa_rs"]
3974 pub fn spa_pod_control_next(iter: *const spa_pod_control) -> *mut spa_pod_control;
3975}
3976unsafe extern "C" {
3977 #[link_name = "spa_pod_from_data_libspa_rs"]
3978 pub fn spa_pod_from_data(
3979 data: *mut ::std::os::raw::c_void,
3980 maxsize: usize,
3981 offset: off_t,
3982 size: usize,
3983 ) -> *mut ::std::os::raw::c_void;
3984}
3985unsafe extern "C" {
3986 #[link_name = "spa_pod_is_none_libspa_rs"]
3987 pub fn spa_pod_is_none(pod: *const spa_pod) -> ::std::os::raw::c_int;
3988}
3989unsafe extern "C" {
3990 #[link_name = "spa_pod_is_bool_libspa_rs"]
3991 pub fn spa_pod_is_bool(pod: *const spa_pod) -> ::std::os::raw::c_int;
3992}
3993unsafe extern "C" {
3994 #[link_name = "spa_pod_get_bool_libspa_rs"]
3995 pub fn spa_pod_get_bool(pod: *const spa_pod, value: *mut bool) -> ::std::os::raw::c_int;
3996}
3997unsafe extern "C" {
3998 #[link_name = "spa_pod_is_id_libspa_rs"]
3999 pub fn spa_pod_is_id(pod: *const spa_pod) -> ::std::os::raw::c_int;
4000}
4001unsafe extern "C" {
4002 #[link_name = "spa_pod_get_id_libspa_rs"]
4003 pub fn spa_pod_get_id(pod: *const spa_pod, value: *mut u32) -> ::std::os::raw::c_int;
4004}
4005unsafe extern "C" {
4006 #[link_name = "spa_pod_is_int_libspa_rs"]
4007 pub fn spa_pod_is_int(pod: *const spa_pod) -> ::std::os::raw::c_int;
4008}
4009unsafe extern "C" {
4010 #[link_name = "spa_pod_get_int_libspa_rs"]
4011 pub fn spa_pod_get_int(pod: *const spa_pod, value: *mut i32) -> ::std::os::raw::c_int;
4012}
4013unsafe extern "C" {
4014 #[link_name = "spa_pod_is_long_libspa_rs"]
4015 pub fn spa_pod_is_long(pod: *const spa_pod) -> ::std::os::raw::c_int;
4016}
4017unsafe extern "C" {
4018 #[link_name = "spa_pod_get_long_libspa_rs"]
4019 pub fn spa_pod_get_long(pod: *const spa_pod, value: *mut i64) -> ::std::os::raw::c_int;
4020}
4021unsafe extern "C" {
4022 #[link_name = "spa_pod_is_float_libspa_rs"]
4023 pub fn spa_pod_is_float(pod: *const spa_pod) -> ::std::os::raw::c_int;
4024}
4025unsafe extern "C" {
4026 #[link_name = "spa_pod_get_float_libspa_rs"]
4027 pub fn spa_pod_get_float(pod: *const spa_pod, value: *mut f32) -> ::std::os::raw::c_int;
4028}
4029unsafe extern "C" {
4030 #[link_name = "spa_pod_is_double_libspa_rs"]
4031 pub fn spa_pod_is_double(pod: *const spa_pod) -> ::std::os::raw::c_int;
4032}
4033unsafe extern "C" {
4034 #[link_name = "spa_pod_get_double_libspa_rs"]
4035 pub fn spa_pod_get_double(pod: *const spa_pod, value: *mut f64) -> ::std::os::raw::c_int;
4036}
4037unsafe extern "C" {
4038 #[link_name = "spa_pod_is_string_libspa_rs"]
4039 pub fn spa_pod_is_string(pod: *const spa_pod) -> ::std::os::raw::c_int;
4040}
4041unsafe extern "C" {
4042 #[link_name = "spa_pod_get_string_libspa_rs"]
4043 pub fn spa_pod_get_string(
4044 pod: *const spa_pod,
4045 value: *mut *const ::std::os::raw::c_char,
4046 ) -> ::std::os::raw::c_int;
4047}
4048unsafe extern "C" {
4049 #[link_name = "spa_pod_copy_string_libspa_rs"]
4050 pub fn spa_pod_copy_string(
4051 pod: *const spa_pod,
4052 maxlen: usize,
4053 dest: *mut ::std::os::raw::c_char,
4054 ) -> ::std::os::raw::c_int;
4055}
4056unsafe extern "C" {
4057 #[link_name = "spa_pod_is_bytes_libspa_rs"]
4058 pub fn spa_pod_is_bytes(pod: *const spa_pod) -> ::std::os::raw::c_int;
4059}
4060unsafe extern "C" {
4061 #[link_name = "spa_pod_get_bytes_libspa_rs"]
4062 pub fn spa_pod_get_bytes(
4063 pod: *const spa_pod,
4064 value: *mut *const ::std::os::raw::c_void,
4065 len: *mut u32,
4066 ) -> ::std::os::raw::c_int;
4067}
4068unsafe extern "C" {
4069 #[link_name = "spa_pod_is_pointer_libspa_rs"]
4070 pub fn spa_pod_is_pointer(pod: *const spa_pod) -> ::std::os::raw::c_int;
4071}
4072unsafe extern "C" {
4073 #[link_name = "spa_pod_get_pointer_libspa_rs"]
4074 pub fn spa_pod_get_pointer(
4075 pod: *const spa_pod,
4076 type_: *mut u32,
4077 value: *mut *const ::std::os::raw::c_void,
4078 ) -> ::std::os::raw::c_int;
4079}
4080unsafe extern "C" {
4081 #[link_name = "spa_pod_is_fd_libspa_rs"]
4082 pub fn spa_pod_is_fd(pod: *const spa_pod) -> ::std::os::raw::c_int;
4083}
4084unsafe extern "C" {
4085 #[link_name = "spa_pod_get_fd_libspa_rs"]
4086 pub fn spa_pod_get_fd(pod: *const spa_pod, value: *mut i64) -> ::std::os::raw::c_int;
4087}
4088unsafe extern "C" {
4089 #[link_name = "spa_pod_is_rectangle_libspa_rs"]
4090 pub fn spa_pod_is_rectangle(pod: *const spa_pod) -> ::std::os::raw::c_int;
4091}
4092unsafe extern "C" {
4093 #[link_name = "spa_pod_get_rectangle_libspa_rs"]
4094 pub fn spa_pod_get_rectangle(
4095 pod: *const spa_pod,
4096 value: *mut spa_rectangle,
4097 ) -> ::std::os::raw::c_int;
4098}
4099unsafe extern "C" {
4100 #[link_name = "spa_pod_is_fraction_libspa_rs"]
4101 pub fn spa_pod_is_fraction(pod: *const spa_pod) -> ::std::os::raw::c_int;
4102}
4103unsafe extern "C" {
4104 #[link_name = "spa_pod_get_fraction_libspa_rs"]
4105 pub fn spa_pod_get_fraction(
4106 pod: *const spa_pod,
4107 value: *mut spa_fraction,
4108 ) -> ::std::os::raw::c_int;
4109}
4110unsafe extern "C" {
4111 #[link_name = "spa_pod_is_bitmap_libspa_rs"]
4112 pub fn spa_pod_is_bitmap(pod: *const spa_pod) -> ::std::os::raw::c_int;
4113}
4114unsafe extern "C" {
4115 #[link_name = "spa_pod_is_array_libspa_rs"]
4116 pub fn spa_pod_is_array(pod: *const spa_pod) -> ::std::os::raw::c_int;
4117}
4118unsafe extern "C" {
4119 #[link_name = "spa_pod_get_array_libspa_rs"]
4120 pub fn spa_pod_get_array(
4121 pod: *const spa_pod,
4122 n_values: *mut u32,
4123 ) -> *mut ::std::os::raw::c_void;
4124}
4125unsafe extern "C" {
4126 #[link_name = "spa_pod_copy_array_libspa_rs"]
4127 pub fn spa_pod_copy_array(
4128 pod: *const spa_pod,
4129 type_: u32,
4130 values: *mut ::std::os::raw::c_void,
4131 max_values: u32,
4132 ) -> u32;
4133}
4134unsafe extern "C" {
4135 #[link_name = "spa_pod_is_choice_libspa_rs"]
4136 pub fn spa_pod_is_choice(pod: *const spa_pod) -> ::std::os::raw::c_int;
4137}
4138unsafe extern "C" {
4139 #[link_name = "spa_pod_get_values_libspa_rs"]
4140 pub fn spa_pod_get_values(
4141 pod: *const spa_pod,
4142 n_vals: *mut u32,
4143 choice: *mut u32,
4144 ) -> *mut spa_pod;
4145}
4146unsafe extern "C" {
4147 #[link_name = "spa_pod_is_struct_libspa_rs"]
4148 pub fn spa_pod_is_struct(pod: *const spa_pod) -> ::std::os::raw::c_int;
4149}
4150unsafe extern "C" {
4151 #[link_name = "spa_pod_is_object_libspa_rs"]
4152 pub fn spa_pod_is_object(pod: *const spa_pod) -> ::std::os::raw::c_int;
4153}
4154unsafe extern "C" {
4155 #[link_name = "spa_pod_is_object_type_libspa_rs"]
4156 pub fn spa_pod_is_object_type(pod: *const spa_pod, type_: u32) -> bool;
4157}
4158unsafe extern "C" {
4159 #[link_name = "spa_pod_is_object_id_libspa_rs"]
4160 pub fn spa_pod_is_object_id(pod: *const spa_pod, id: u32) -> bool;
4161}
4162unsafe extern "C" {
4163 #[link_name = "spa_pod_is_sequence_libspa_rs"]
4164 pub fn spa_pod_is_sequence(pod: *const spa_pod) -> ::std::os::raw::c_int;
4165}
4166unsafe extern "C" {
4167 #[link_name = "spa_pod_object_find_prop_libspa_rs"]
4168 pub fn spa_pod_object_find_prop(
4169 pod: *const spa_pod_object,
4170 start: *const spa_pod_prop,
4171 key: u32,
4172 ) -> *const spa_pod_prop;
4173}
4174unsafe extern "C" {
4175 #[link_name = "spa_pod_find_prop_libspa_rs"]
4176 pub fn spa_pod_find_prop(
4177 pod: *const spa_pod,
4178 start: *const spa_pod_prop,
4179 key: u32,
4180 ) -> *const spa_pod_prop;
4181}
4182unsafe extern "C" {
4183 #[link_name = "spa_pod_object_fixate_libspa_rs"]
4184 pub fn spa_pod_object_fixate(pod: *mut spa_pod_object) -> ::std::os::raw::c_int;
4185}
4186unsafe extern "C" {
4187 #[link_name = "spa_pod_fixate_libspa_rs"]
4188 pub fn spa_pod_fixate(pod: *mut spa_pod) -> ::std::os::raw::c_int;
4189}
4190unsafe extern "C" {
4191 #[link_name = "spa_pod_object_is_fixated_libspa_rs"]
4192 pub fn spa_pod_object_is_fixated(pod: *const spa_pod_object) -> ::std::os::raw::c_int;
4193}
4194unsafe extern "C" {
4195 #[link_name = "spa_pod_object_has_props_libspa_rs"]
4196 pub fn spa_pod_object_has_props(pod: *const spa_pod_object) -> ::std::os::raw::c_int;
4197}
4198unsafe extern "C" {
4199 #[link_name = "spa_pod_is_fixated_libspa_rs"]
4200 pub fn spa_pod_is_fixated(pod: *const spa_pod) -> ::std::os::raw::c_int;
4201}
4202#[doc = " \\addtogroup spa_pod\n \\{"]
4203#[repr(C)]
4204#[derive(Debug, Copy, Clone, PartialEq, Eq)]
4205pub struct spa_pod_parser_state {
4206 pub offset: u32,
4207 pub flags: u32,
4208 pub frame: *mut spa_pod_frame,
4209}
4210#[allow(clippy::unnecessary_operation, clippy::identity_op)]
4211const _: () = {
4212 ["Size of spa_pod_parser_state"][::std::mem::size_of::<spa_pod_parser_state>() - 16usize];
4213 ["Alignment of spa_pod_parser_state"][::std::mem::align_of::<spa_pod_parser_state>() - 8usize];
4214 ["Offset of field: spa_pod_parser_state::offset"]
4215 [::std::mem::offset_of!(spa_pod_parser_state, offset) - 0usize];
4216 ["Offset of field: spa_pod_parser_state::flags"]
4217 [::std::mem::offset_of!(spa_pod_parser_state, flags) - 4usize];
4218 ["Offset of field: spa_pod_parser_state::frame"]
4219 [::std::mem::offset_of!(spa_pod_parser_state, frame) - 8usize];
4220};
4221#[repr(C)]
4222#[derive(Debug, Copy, Clone, PartialEq, Eq)]
4223pub struct spa_pod_parser {
4224 pub data: *const ::std::os::raw::c_void,
4225 pub size: u32,
4226 pub _padding: u32,
4227 pub state: spa_pod_parser_state,
4228}
4229#[allow(clippy::unnecessary_operation, clippy::identity_op)]
4230const _: () = {
4231 ["Size of spa_pod_parser"][::std::mem::size_of::<spa_pod_parser>() - 32usize];
4232 ["Alignment of spa_pod_parser"][::std::mem::align_of::<spa_pod_parser>() - 8usize];
4233 ["Offset of field: spa_pod_parser::data"]
4234 [::std::mem::offset_of!(spa_pod_parser, data) - 0usize];
4235 ["Offset of field: spa_pod_parser::size"]
4236 [::std::mem::offset_of!(spa_pod_parser, size) - 8usize];
4237 ["Offset of field: spa_pod_parser::_padding"]
4238 [::std::mem::offset_of!(spa_pod_parser, _padding) - 12usize];
4239 ["Offset of field: spa_pod_parser::state"]
4240 [::std::mem::offset_of!(spa_pod_parser, state) - 16usize];
4241};
4242unsafe extern "C" {
4243 #[link_name = "spa_pod_parser_init_libspa_rs"]
4244 pub fn spa_pod_parser_init(
4245 parser: *mut spa_pod_parser,
4246 data: *const ::std::os::raw::c_void,
4247 size: u32,
4248 );
4249}
4250unsafe extern "C" {
4251 #[link_name = "spa_pod_parser_pod_libspa_rs"]
4252 pub fn spa_pod_parser_pod(parser: *mut spa_pod_parser, pod: *const spa_pod);
4253}
4254unsafe extern "C" {
4255 #[link_name = "spa_pod_parser_get_state_libspa_rs"]
4256 pub fn spa_pod_parser_get_state(parser: *mut spa_pod_parser, state: *mut spa_pod_parser_state);
4257}
4258unsafe extern "C" {
4259 #[link_name = "spa_pod_parser_reset_libspa_rs"]
4260 pub fn spa_pod_parser_reset(parser: *mut spa_pod_parser, state: *mut spa_pod_parser_state);
4261}
4262unsafe extern "C" {
4263 #[link_name = "spa_pod_parser_deref_libspa_rs"]
4264 pub fn spa_pod_parser_deref(
4265 parser: *mut spa_pod_parser,
4266 offset: u32,
4267 size: u32,
4268 ) -> *mut spa_pod;
4269}
4270unsafe extern "C" {
4271 #[link_name = "spa_pod_parser_frame_libspa_rs"]
4272 pub fn spa_pod_parser_frame(
4273 parser: *mut spa_pod_parser,
4274 frame: *mut spa_pod_frame,
4275 ) -> *mut spa_pod;
4276}
4277unsafe extern "C" {
4278 #[link_name = "spa_pod_parser_push_libspa_rs"]
4279 pub fn spa_pod_parser_push(
4280 parser: *mut spa_pod_parser,
4281 frame: *mut spa_pod_frame,
4282 pod: *const spa_pod,
4283 offset: u32,
4284 );
4285}
4286unsafe extern "C" {
4287 #[link_name = "spa_pod_parser_current_libspa_rs"]
4288 pub fn spa_pod_parser_current(parser: *mut spa_pod_parser) -> *mut spa_pod;
4289}
4290unsafe extern "C" {
4291 #[link_name = "spa_pod_parser_advance_libspa_rs"]
4292 pub fn spa_pod_parser_advance(parser: *mut spa_pod_parser, pod: *const spa_pod);
4293}
4294unsafe extern "C" {
4295 #[link_name = "spa_pod_parser_next_libspa_rs"]
4296 pub fn spa_pod_parser_next(parser: *mut spa_pod_parser) -> *mut spa_pod;
4297}
4298unsafe extern "C" {
4299 #[link_name = "spa_pod_parser_pop_libspa_rs"]
4300 pub fn spa_pod_parser_pop(
4301 parser: *mut spa_pod_parser,
4302 frame: *mut spa_pod_frame,
4303 ) -> ::std::os::raw::c_int;
4304}
4305unsafe extern "C" {
4306 #[link_name = "spa_pod_parser_get_bool_libspa_rs"]
4307 pub fn spa_pod_parser_get_bool(
4308 parser: *mut spa_pod_parser,
4309 value: *mut bool,
4310 ) -> ::std::os::raw::c_int;
4311}
4312unsafe extern "C" {
4313 #[link_name = "spa_pod_parser_get_id_libspa_rs"]
4314 pub fn spa_pod_parser_get_id(
4315 parser: *mut spa_pod_parser,
4316 value: *mut u32,
4317 ) -> ::std::os::raw::c_int;
4318}
4319unsafe extern "C" {
4320 #[link_name = "spa_pod_parser_get_int_libspa_rs"]
4321 pub fn spa_pod_parser_get_int(
4322 parser: *mut spa_pod_parser,
4323 value: *mut i32,
4324 ) -> ::std::os::raw::c_int;
4325}
4326unsafe extern "C" {
4327 #[link_name = "spa_pod_parser_get_long_libspa_rs"]
4328 pub fn spa_pod_parser_get_long(
4329 parser: *mut spa_pod_parser,
4330 value: *mut i64,
4331 ) -> ::std::os::raw::c_int;
4332}
4333unsafe extern "C" {
4334 #[link_name = "spa_pod_parser_get_float_libspa_rs"]
4335 pub fn spa_pod_parser_get_float(
4336 parser: *mut spa_pod_parser,
4337 value: *mut f32,
4338 ) -> ::std::os::raw::c_int;
4339}
4340unsafe extern "C" {
4341 #[link_name = "spa_pod_parser_get_double_libspa_rs"]
4342 pub fn spa_pod_parser_get_double(
4343 parser: *mut spa_pod_parser,
4344 value: *mut f64,
4345 ) -> ::std::os::raw::c_int;
4346}
4347unsafe extern "C" {
4348 #[link_name = "spa_pod_parser_get_string_libspa_rs"]
4349 pub fn spa_pod_parser_get_string(
4350 parser: *mut spa_pod_parser,
4351 value: *mut *const ::std::os::raw::c_char,
4352 ) -> ::std::os::raw::c_int;
4353}
4354unsafe extern "C" {
4355 #[link_name = "spa_pod_parser_get_bytes_libspa_rs"]
4356 pub fn spa_pod_parser_get_bytes(
4357 parser: *mut spa_pod_parser,
4358 value: *mut *const ::std::os::raw::c_void,
4359 len: *mut u32,
4360 ) -> ::std::os::raw::c_int;
4361}
4362unsafe extern "C" {
4363 #[link_name = "spa_pod_parser_get_pointer_libspa_rs"]
4364 pub fn spa_pod_parser_get_pointer(
4365 parser: *mut spa_pod_parser,
4366 type_: *mut u32,
4367 value: *mut *const ::std::os::raw::c_void,
4368 ) -> ::std::os::raw::c_int;
4369}
4370unsafe extern "C" {
4371 #[link_name = "spa_pod_parser_get_fd_libspa_rs"]
4372 pub fn spa_pod_parser_get_fd(
4373 parser: *mut spa_pod_parser,
4374 value: *mut i64,
4375 ) -> ::std::os::raw::c_int;
4376}
4377unsafe extern "C" {
4378 #[link_name = "spa_pod_parser_get_rectangle_libspa_rs"]
4379 pub fn spa_pod_parser_get_rectangle(
4380 parser: *mut spa_pod_parser,
4381 value: *mut spa_rectangle,
4382 ) -> ::std::os::raw::c_int;
4383}
4384unsafe extern "C" {
4385 #[link_name = "spa_pod_parser_get_fraction_libspa_rs"]
4386 pub fn spa_pod_parser_get_fraction(
4387 parser: *mut spa_pod_parser,
4388 value: *mut spa_fraction,
4389 ) -> ::std::os::raw::c_int;
4390}
4391unsafe extern "C" {
4392 #[link_name = "spa_pod_parser_get_pod_libspa_rs"]
4393 pub fn spa_pod_parser_get_pod(
4394 parser: *mut spa_pod_parser,
4395 value: *mut *mut spa_pod,
4396 ) -> ::std::os::raw::c_int;
4397}
4398unsafe extern "C" {
4399 #[link_name = "spa_pod_parser_push_struct_libspa_rs"]
4400 pub fn spa_pod_parser_push_struct(
4401 parser: *mut spa_pod_parser,
4402 frame: *mut spa_pod_frame,
4403 ) -> ::std::os::raw::c_int;
4404}
4405unsafe extern "C" {
4406 #[link_name = "spa_pod_parser_push_object_libspa_rs"]
4407 pub fn spa_pod_parser_push_object(
4408 parser: *mut spa_pod_parser,
4409 frame: *mut spa_pod_frame,
4410 type_: u32,
4411 id: *mut u32,
4412 ) -> ::std::os::raw::c_int;
4413}
4414unsafe extern "C" {
4415 #[link_name = "spa_pod_parser_can_collect_libspa_rs"]
4416 pub fn spa_pod_parser_can_collect(pod: *const spa_pod, type_: ::std::os::raw::c_char) -> bool;
4417}
4418unsafe extern "C" {
4419 #[link_name = "spa_pod_parser_getv_libspa_rs"]
4420 pub fn spa_pod_parser_getv(
4421 parser: *mut spa_pod_parser,
4422 args: *mut __va_list_tag,
4423 ) -> ::std::os::raw::c_int;
4424}
4425unsafe extern "C" {
4426 #[link_name = "spa_format_parse_libspa_rs"]
4427 pub fn spa_format_parse(
4428 format: *const spa_pod,
4429 media_type: *mut u32,
4430 media_subtype: *mut u32,
4431 ) -> ::std::os::raw::c_int;
4432}
4433unsafe extern "C" {
4434 #[link_name = "spa_debug_strbuf_format_value_libspa_rs"]
4435 pub fn spa_debug_strbuf_format_value(
4436 buffer: *mut spa_strbuf,
4437 info: *const spa_type_info,
4438 type_: u32,
4439 body: *mut ::std::os::raw::c_void,
4440 size: u32,
4441 ) -> ::std::os::raw::c_int;
4442}
4443unsafe extern "C" {
4444 #[link_name = "spa_debug_format_value_libspa_rs"]
4445 pub fn spa_debug_format_value(
4446 info: *const spa_type_info,
4447 type_: u32,
4448 body: *mut ::std::os::raw::c_void,
4449 size: u32,
4450 ) -> ::std::os::raw::c_int;
4451}
4452unsafe extern "C" {
4453 #[link_name = "spa_debugc_format_libspa_rs"]
4454 pub fn spa_debugc_format(
4455 ctx: *mut spa_debug_context,
4456 indent: ::std::os::raw::c_int,
4457 info: *const spa_type_info,
4458 format: *const spa_pod,
4459 ) -> ::std::os::raw::c_int;
4460}
4461unsafe extern "C" {
4462 #[link_name = "spa_debug_format_libspa_rs"]
4463 pub fn spa_debug_format(
4464 indent: ::std::os::raw::c_int,
4465 info: *const spa_type_info,
4466 format: *const spa_pod,
4467 ) -> ::std::os::raw::c_int;
4468}
4469#[doc = " \\addtogroup spa_list List\n \\{"]
4470#[repr(C)]
4471#[derive(Debug, Copy, Clone, PartialEq, Eq)]
4472pub struct spa_list {
4473 pub next: *mut spa_list,
4474 pub prev: *mut spa_list,
4475}
4476#[allow(clippy::unnecessary_operation, clippy::identity_op)]
4477const _: () = {
4478 ["Size of spa_list"][::std::mem::size_of::<spa_list>() - 16usize];
4479 ["Alignment of spa_list"][::std::mem::align_of::<spa_list>() - 8usize];
4480 ["Offset of field: spa_list::next"][::std::mem::offset_of!(spa_list, next) - 0usize];
4481 ["Offset of field: spa_list::prev"][::std::mem::offset_of!(spa_list, prev) - 8usize];
4482};
4483unsafe extern "C" {
4484 #[link_name = "spa_list_init_libspa_rs"]
4485 pub fn spa_list_init(list: *mut spa_list);
4486}
4487unsafe extern "C" {
4488 #[link_name = "spa_list_is_initialized_libspa_rs"]
4489 pub fn spa_list_is_initialized(list: *mut spa_list) -> ::std::os::raw::c_int;
4490}
4491unsafe extern "C" {
4492 #[link_name = "spa_list_insert_libspa_rs"]
4493 pub fn spa_list_insert(list: *mut spa_list, elem: *mut spa_list);
4494}
4495unsafe extern "C" {
4496 #[link_name = "spa_list_insert_list_libspa_rs"]
4497 pub fn spa_list_insert_list(list: *mut spa_list, other: *mut spa_list);
4498}
4499unsafe extern "C" {
4500 #[link_name = "spa_list_remove_libspa_rs"]
4501 pub fn spa_list_remove(elem: *mut spa_list);
4502}
4503#[doc = " \\struct spa_callbacks\n Callbacks, contains the structure with functions and the data passed\n to the functions. The structure should also contain a version field that\n is checked."]
4504#[repr(C)]
4505#[derive(Debug, Copy, Clone, PartialEq, Eq)]
4506pub struct spa_callbacks {
4507 pub funcs: *const ::std::os::raw::c_void,
4508 pub data: *mut ::std::os::raw::c_void,
4509}
4510#[allow(clippy::unnecessary_operation, clippy::identity_op)]
4511const _: () = {
4512 ["Size of spa_callbacks"][::std::mem::size_of::<spa_callbacks>() - 16usize];
4513 ["Alignment of spa_callbacks"][::std::mem::align_of::<spa_callbacks>() - 8usize];
4514 ["Offset of field: spa_callbacks::funcs"]
4515 [::std::mem::offset_of!(spa_callbacks, funcs) - 0usize];
4516 ["Offset of field: spa_callbacks::data"][::std::mem::offset_of!(spa_callbacks, data) - 8usize];
4517};
4518#[doc = " \\struct spa_interface"]
4519#[repr(C)]
4520#[derive(Debug, Copy, Clone, PartialEq, Eq)]
4521pub struct spa_interface {
4522 pub type_: *const ::std::os::raw::c_char,
4523 pub version: u32,
4524 pub cb: spa_callbacks,
4525}
4526#[allow(clippy::unnecessary_operation, clippy::identity_op)]
4527const _: () = {
4528 ["Size of spa_interface"][::std::mem::size_of::<spa_interface>() - 32usize];
4529 ["Alignment of spa_interface"][::std::mem::align_of::<spa_interface>() - 8usize];
4530 ["Offset of field: spa_interface::type_"]
4531 [::std::mem::offset_of!(spa_interface, type_) - 0usize];
4532 ["Offset of field: spa_interface::version"]
4533 [::std::mem::offset_of!(spa_interface, version) - 8usize];
4534 ["Offset of field: spa_interface::cb"][::std::mem::offset_of!(spa_interface, cb) - 16usize];
4535};
4536#[doc = " \\struct spa_hook_list\n A list of hooks. This struct is primarily used by\n implementation that use multiple caller-provided \\ref spa_hook."]
4537#[repr(C)]
4538#[derive(Debug, Copy, Clone, PartialEq, Eq)]
4539pub struct spa_hook_list {
4540 pub list: spa_list,
4541}
4542#[allow(clippy::unnecessary_operation, clippy::identity_op)]
4543const _: () = {
4544 ["Size of spa_hook_list"][::std::mem::size_of::<spa_hook_list>() - 16usize];
4545 ["Alignment of spa_hook_list"][::std::mem::align_of::<spa_hook_list>() - 8usize];
4546 ["Offset of field: spa_hook_list::list"][::std::mem::offset_of!(spa_hook_list, list) - 0usize];
4547};
4548#[doc = " \\struct spa_hook\n A hook, contains the structure with functions and the data passed\n to the functions.\n\n A hook should be treated as opaque by the caller."]
4549#[repr(C)]
4550#[derive(Debug, Copy, Clone, PartialEq, Eq)]
4551pub struct spa_hook {
4552 pub link: spa_list,
4553 pub cb: spa_callbacks,
4554 #[doc = " callback and data for the hook list, private to the\n hook_list implementor"]
4555 pub removed: ::std::option::Option<unsafe extern "C" fn(hook: *mut spa_hook)>,
4556 pub priv_: *mut ::std::os::raw::c_void,
4557}
4558#[allow(clippy::unnecessary_operation, clippy::identity_op)]
4559const _: () = {
4560 ["Size of spa_hook"][::std::mem::size_of::<spa_hook>() - 48usize];
4561 ["Alignment of spa_hook"][::std::mem::align_of::<spa_hook>() - 8usize];
4562 ["Offset of field: spa_hook::link"][::std::mem::offset_of!(spa_hook, link) - 0usize];
4563 ["Offset of field: spa_hook::cb"][::std::mem::offset_of!(spa_hook, cb) - 16usize];
4564 ["Offset of field: spa_hook::removed"][::std::mem::offset_of!(spa_hook, removed) - 32usize];
4565 ["Offset of field: spa_hook::priv_"][::std::mem::offset_of!(spa_hook, priv_) - 40usize];
4566};
4567unsafe extern "C" {
4568 #[doc = " Initialize a hook list to the empty list"]
4569 #[link_name = "spa_hook_list_init_libspa_rs"]
4570 pub fn spa_hook_list_init(list: *mut spa_hook_list);
4571}
4572unsafe extern "C" {
4573 #[link_name = "spa_hook_list_is_empty_libspa_rs"]
4574 pub fn spa_hook_list_is_empty(list: *mut spa_hook_list) -> bool;
4575}
4576unsafe extern "C" {
4577 #[doc = " Append a hook."]
4578 #[link_name = "spa_hook_list_append_libspa_rs"]
4579 pub fn spa_hook_list_append(
4580 list: *mut spa_hook_list,
4581 hook: *mut spa_hook,
4582 funcs: *const ::std::os::raw::c_void,
4583 data: *mut ::std::os::raw::c_void,
4584 );
4585}
4586unsafe extern "C" {
4587 #[doc = " Prepend a hook"]
4588 #[link_name = "spa_hook_list_prepend_libspa_rs"]
4589 pub fn spa_hook_list_prepend(
4590 list: *mut spa_hook_list,
4591 hook: *mut spa_hook,
4592 funcs: *const ::std::os::raw::c_void,
4593 data: *mut ::std::os::raw::c_void,
4594 );
4595}
4596unsafe extern "C" {
4597 #[doc = " Remove a hook"]
4598 #[link_name = "spa_hook_remove_libspa_rs"]
4599 pub fn spa_hook_remove(hook: *mut spa_hook);
4600}
4601unsafe extern "C" {
4602 #[doc = " Remove all hooks from the list"]
4603 #[link_name = "spa_hook_list_clean_libspa_rs"]
4604 pub fn spa_hook_list_clean(list: *mut spa_hook_list);
4605}
4606unsafe extern "C" {
4607 #[link_name = "spa_hook_list_isolate_libspa_rs"]
4608 pub fn spa_hook_list_isolate(
4609 list: *mut spa_hook_list,
4610 save: *mut spa_hook_list,
4611 hook: *mut spa_hook,
4612 funcs: *const ::std::os::raw::c_void,
4613 data: *mut ::std::os::raw::c_void,
4614 );
4615}
4616unsafe extern "C" {
4617 #[link_name = "spa_hook_list_join_libspa_rs"]
4618 pub fn spa_hook_list_join(list: *mut spa_hook_list, save: *mut spa_hook_list);
4619}
4620#[repr(C)]
4621#[derive(Debug, Copy, Clone, PartialEq, Eq)]
4622pub struct spa_node {
4623 pub iface: spa_interface,
4624}
4625#[allow(clippy::unnecessary_operation, clippy::identity_op)]
4626const _: () = {
4627 ["Size of spa_node"][::std::mem::size_of::<spa_node>() - 32usize];
4628 ["Alignment of spa_node"][::std::mem::align_of::<spa_node>() - 8usize];
4629 ["Offset of field: spa_node::iface"][::std::mem::offset_of!(spa_node, iface) - 0usize];
4630};
4631#[doc = " Node information structure\n\n Contains the basic node information."]
4632#[repr(C)]
4633#[derive(Debug, Copy, Clone, PartialEq, Eq)]
4634pub struct spa_node_info {
4635 pub max_input_ports: u32,
4636 pub max_output_ports: u32,
4637 pub change_mask: u64,
4638 pub flags: u64,
4639 #[doc = "< extra node properties"]
4640 pub props: *mut spa_dict,
4641 #[doc = "< parameter information"]
4642 pub params: *mut spa_param_info,
4643 #[doc = "< number of items in \\a params"]
4644 pub n_params: u32,
4645}
4646#[allow(clippy::unnecessary_operation, clippy::identity_op)]
4647const _: () = {
4648 ["Size of spa_node_info"][::std::mem::size_of::<spa_node_info>() - 48usize];
4649 ["Alignment of spa_node_info"][::std::mem::align_of::<spa_node_info>() - 8usize];
4650 ["Offset of field: spa_node_info::max_input_ports"]
4651 [::std::mem::offset_of!(spa_node_info, max_input_ports) - 0usize];
4652 ["Offset of field: spa_node_info::max_output_ports"]
4653 [::std::mem::offset_of!(spa_node_info, max_output_ports) - 4usize];
4654 ["Offset of field: spa_node_info::change_mask"]
4655 [::std::mem::offset_of!(spa_node_info, change_mask) - 8usize];
4656 ["Offset of field: spa_node_info::flags"]
4657 [::std::mem::offset_of!(spa_node_info, flags) - 16usize];
4658 ["Offset of field: spa_node_info::props"]
4659 [::std::mem::offset_of!(spa_node_info, props) - 24usize];
4660 ["Offset of field: spa_node_info::params"]
4661 [::std::mem::offset_of!(spa_node_info, params) - 32usize];
4662 ["Offset of field: spa_node_info::n_params"]
4663 [::std::mem::offset_of!(spa_node_info, n_params) - 40usize];
4664};
4665#[doc = " Port information structure\n\n Contains the basic port information."]
4666#[repr(C)]
4667#[derive(Debug, Copy, Clone, PartialEq, Eq)]
4668pub struct spa_port_info {
4669 pub change_mask: u64,
4670 #[doc = "< port flags"]
4671 pub flags: u64,
4672 #[doc = "< rate of sequence numbers on port"]
4673 pub rate: spa_fraction,
4674 #[doc = "< extra port properties"]
4675 pub props: *const spa_dict,
4676 #[doc = "< parameter information"]
4677 pub params: *mut spa_param_info,
4678 #[doc = "< number of items in \\a params"]
4679 pub n_params: u32,
4680}
4681#[allow(clippy::unnecessary_operation, clippy::identity_op)]
4682const _: () = {
4683 ["Size of spa_port_info"][::std::mem::size_of::<spa_port_info>() - 48usize];
4684 ["Alignment of spa_port_info"][::std::mem::align_of::<spa_port_info>() - 8usize];
4685 ["Offset of field: spa_port_info::change_mask"]
4686 [::std::mem::offset_of!(spa_port_info, change_mask) - 0usize];
4687 ["Offset of field: spa_port_info::flags"]
4688 [::std::mem::offset_of!(spa_port_info, flags) - 8usize];
4689 ["Offset of field: spa_port_info::rate"][::std::mem::offset_of!(spa_port_info, rate) - 16usize];
4690 ["Offset of field: spa_port_info::props"]
4691 [::std::mem::offset_of!(spa_port_info, props) - 24usize];
4692 ["Offset of field: spa_port_info::params"]
4693 [::std::mem::offset_of!(spa_port_info, params) - 32usize];
4694 ["Offset of field: spa_port_info::n_params"]
4695 [::std::mem::offset_of!(spa_port_info, n_params) - 40usize];
4696};
4697#[doc = " an error result"]
4698#[repr(C)]
4699#[derive(Debug, Copy, Clone, PartialEq, Eq)]
4700pub struct spa_result_node_error {
4701 pub message: *const ::std::os::raw::c_char,
4702}
4703#[allow(clippy::unnecessary_operation, clippy::identity_op)]
4704const _: () = {
4705 ["Size of spa_result_node_error"][::std::mem::size_of::<spa_result_node_error>() - 8usize];
4706 ["Alignment of spa_result_node_error"]
4707 [::std::mem::align_of::<spa_result_node_error>() - 8usize];
4708 ["Offset of field: spa_result_node_error::message"]
4709 [::std::mem::offset_of!(spa_result_node_error, message) - 0usize];
4710};
4711#[doc = " the result of enum_params or port_enum_params."]
4712#[repr(C)]
4713#[derive(Debug, Copy, Clone, PartialEq, Eq)]
4714pub struct spa_result_node_params {
4715 #[doc = "< id of parameter"]
4716 pub id: u32,
4717 #[doc = "< index of parameter"]
4718 pub index: u32,
4719 #[doc = "< next index of iteration"]
4720 pub next: u32,
4721 #[doc = "< the result param"]
4722 pub param: *mut spa_pod,
4723}
4724#[allow(clippy::unnecessary_operation, clippy::identity_op)]
4725const _: () = {
4726 ["Size of spa_result_node_params"][::std::mem::size_of::<spa_result_node_params>() - 24usize];
4727 ["Alignment of spa_result_node_params"]
4728 [::std::mem::align_of::<spa_result_node_params>() - 8usize];
4729 ["Offset of field: spa_result_node_params::id"]
4730 [::std::mem::offset_of!(spa_result_node_params, id) - 0usize];
4731 ["Offset of field: spa_result_node_params::index"]
4732 [::std::mem::offset_of!(spa_result_node_params, index) - 4usize];
4733 ["Offset of field: spa_result_node_params::next"]
4734 [::std::mem::offset_of!(spa_result_node_params, next) - 8usize];
4735 ["Offset of field: spa_result_node_params::param"]
4736 [::std::mem::offset_of!(spa_result_node_params, param) - 16usize];
4737};
4738#[doc = " events from the spa_node.\n\n All event are called from the main thread and multiple\n listeners can be registered for the events with\n spa_node_add_listener()."]
4739#[repr(C)]
4740#[derive(Debug, Copy, Clone, PartialEq, Eq)]
4741pub struct spa_node_events {
4742 #[doc = "< version of this structure"]
4743 pub version: u32,
4744 #[doc = " Emitted when info changes"]
4745 pub info: ::std::option::Option<
4746 unsafe extern "C" fn(data: *mut ::std::os::raw::c_void, info: *const spa_node_info),
4747 >,
4748 #[doc = " Emitted when port info changes, NULL when port is removed"]
4749 pub port_info: ::std::option::Option<
4750 unsafe extern "C" fn(
4751 data: *mut ::std::os::raw::c_void,
4752 direction: spa_direction,
4753 port: u32,
4754 info: *const spa_port_info,
4755 ),
4756 >,
4757 #[doc = " notify a result.\n\n Some methods will trigger a result event with an optional\n result of the given type. Look at the documentation of the\n method to know when to expect a result event.\n\n The result event can be called synchronously, as an event\n called from inside the method itself, in which case the seq\n number passed to the method will be passed unchanged.\n\n The result event will be called asynchronously when the\n method returned an async return value. In this case, the seq\n number in the result will match the async return value of\n the method call. Users should match the seq number from\n request to the reply."]
4758 pub result: ::std::option::Option<
4759 unsafe extern "C" fn(
4760 data: *mut ::std::os::raw::c_void,
4761 seq: ::std::os::raw::c_int,
4762 res: ::std::os::raw::c_int,
4763 type_: u32,
4764 result: *const ::std::os::raw::c_void,
4765 ),
4766 >,
4767 #[doc = " \\param node a spa_node\n \\param event the event that was emitted\n\n This will be called when an out-of-bound event is notified\n on \\a node."]
4768 pub event: ::std::option::Option<
4769 unsafe extern "C" fn(data: *mut ::std::os::raw::c_void, event: *const spa_event),
4770 >,
4771}
4772#[allow(clippy::unnecessary_operation, clippy::identity_op)]
4773const _: () = {
4774 ["Size of spa_node_events"][::std::mem::size_of::<spa_node_events>() - 40usize];
4775 ["Alignment of spa_node_events"][::std::mem::align_of::<spa_node_events>() - 8usize];
4776 ["Offset of field: spa_node_events::version"]
4777 [::std::mem::offset_of!(spa_node_events, version) - 0usize];
4778 ["Offset of field: spa_node_events::info"]
4779 [::std::mem::offset_of!(spa_node_events, info) - 8usize];
4780 ["Offset of field: spa_node_events::port_info"]
4781 [::std::mem::offset_of!(spa_node_events, port_info) - 16usize];
4782 ["Offset of field: spa_node_events::result"]
4783 [::std::mem::offset_of!(spa_node_events, result) - 24usize];
4784 ["Offset of field: spa_node_events::event"]
4785 [::std::mem::offset_of!(spa_node_events, event) - 32usize];
4786};
4787#[doc = " Node callbacks\n\n Callbacks are called from the real-time data thread. Only\n one callback structure can be set on an spa_node."]
4788#[repr(C)]
4789#[derive(Debug, Copy, Clone, PartialEq, Eq)]
4790pub struct spa_node_callbacks {
4791 pub version: u32,
4792 #[doc = " \\param node a spa_node\n\n The node is ready for processing.\n\n When this function is NULL, synchronous operation is requested\n on the ports."]
4793 pub ready: ::std::option::Option<
4794 unsafe extern "C" fn(
4795 data: *mut ::std::os::raw::c_void,
4796 state: ::std::os::raw::c_int,
4797 ) -> ::std::os::raw::c_int,
4798 >,
4799 #[doc = " \\param node a spa_node\n \\param port_id an input port_id\n \\param buffer_id the buffer id to be reused\n\n The node has a buffer that can be reused.\n\n When this function is NULL, the buffers to reuse will be set in\n the io area of the input ports."]
4800 pub reuse_buffer: ::std::option::Option<
4801 unsafe extern "C" fn(
4802 data: *mut ::std::os::raw::c_void,
4803 port_id: u32,
4804 buffer_id: u32,
4805 ) -> ::std::os::raw::c_int,
4806 >,
4807 #[doc = " \\param data user data\n \\param trigger the timestamp in microseconds when the xrun happened\n \\param delay the amount of microseconds of xrun.\n \\param info an object with extra info (NULL for now)\n\n The node has encountered an over or underrun\n\n The info contains an object with more information"]
4808 pub xrun: ::std::option::Option<
4809 unsafe extern "C" fn(
4810 data: *mut ::std::os::raw::c_void,
4811 trigger: u64,
4812 delay: u64,
4813 info: *mut spa_pod,
4814 ) -> ::std::os::raw::c_int,
4815 >,
4816}
4817#[allow(clippy::unnecessary_operation, clippy::identity_op)]
4818const _: () = {
4819 ["Size of spa_node_callbacks"][::std::mem::size_of::<spa_node_callbacks>() - 32usize];
4820 ["Alignment of spa_node_callbacks"][::std::mem::align_of::<spa_node_callbacks>() - 8usize];
4821 ["Offset of field: spa_node_callbacks::version"]
4822 [::std::mem::offset_of!(spa_node_callbacks, version) - 0usize];
4823 ["Offset of field: spa_node_callbacks::ready"]
4824 [::std::mem::offset_of!(spa_node_callbacks, ready) - 8usize];
4825 ["Offset of field: spa_node_callbacks::reuse_buffer"]
4826 [::std::mem::offset_of!(spa_node_callbacks, reuse_buffer) - 16usize];
4827 ["Offset of field: spa_node_callbacks::xrun"]
4828 [::std::mem::offset_of!(spa_node_callbacks, xrun) - 24usize];
4829};
4830#[doc = " Node methods"]
4831#[repr(C)]
4832#[derive(Debug, Copy, Clone, PartialEq, Eq)]
4833pub struct spa_node_methods {
4834 pub version: u32,
4835 #[doc = " Adds an event listener on \\a node.\n\n Setting the events will trigger the info event and a\n port_info event for each managed port on the new\n listener.\n\n \\param node a #spa_node\n \\param listener a listener\n \\param events a struct \\ref spa_node_events\n \\param data data passed as first argument in functions of \\a events\n \\return 0 on success\n\t < 0 errno on error"]
4836 pub add_listener: ::std::option::Option<
4837 unsafe extern "C" fn(
4838 object: *mut ::std::os::raw::c_void,
4839 listener: *mut spa_hook,
4840 events: *const spa_node_events,
4841 data: *mut ::std::os::raw::c_void,
4842 ) -> ::std::os::raw::c_int,
4843 >,
4844 #[doc = " Set callbacks to on \\a node.\n if \\a callbacks is NULL, the current callbacks are removed.\n\n This function must be called from the main thread.\n\n All callbacks are called from the data thread.\n\n \\param node a spa_node\n \\param callbacks callbacks to set\n \\return 0 on success\n -EINVAL when node is NULL"]
4845 pub set_callbacks: ::std::option::Option<
4846 unsafe extern "C" fn(
4847 object: *mut ::std::os::raw::c_void,
4848 callbacks: *const spa_node_callbacks,
4849 data: *mut ::std::os::raw::c_void,
4850 ) -> ::std::os::raw::c_int,
4851 >,
4852 #[doc = " Perform a sync operation.\n\n This method will emit the result event with the given sequence\n number synchronously or with the returned async return value\n asynchronously.\n\n Because all methods are serialized in the node, this can be used\n to wait for completion of all previous method calls.\n\n \\param seq a sequence number\n \\return 0 on success\n -EINVAL when node is NULL\n an async result"]
4853 pub sync: ::std::option::Option<
4854 unsafe extern "C" fn(
4855 object: *mut ::std::os::raw::c_void,
4856 seq: ::std::os::raw::c_int,
4857 ) -> ::std::os::raw::c_int,
4858 >,
4859 #[doc = " Enumerate the parameters of a node.\n\n Parameters are identified with an \\a id. Some parameters can have\n multiple values, see the documentation of the parameter id.\n\n Parameters can be filtered by passing a non-NULL \\a filter.\n\n The function will emit the result event up to \\a max times with\n the result value. The seq in the result will either be the \\a seq\n number when executed synchronously or the async return value of\n this function when executed asynchronously.\n\n This function must be called from the main thread.\n\n \\param node a \\ref spa_node\n \\param seq a sequence number to pass to the result event when\n\tthis method is executed synchronously.\n \\param id the param id to enumerate\n \\param start the index of enumeration, pass 0 for the first item\n \\param max the maximum number of parameters to enumerate\n \\param filter and optional filter to use\n\n \\return 0 when no more items can be iterated.\n -EINVAL when invalid arguments are given\n -ENOENT the parameter \\a id is unknown\n -ENOTSUP when there are no parameters\n implemented on \\a node\n an async return value when the result event will be\n emitted later."]
4860 pub enum_params: ::std::option::Option<
4861 unsafe extern "C" fn(
4862 object: *mut ::std::os::raw::c_void,
4863 seq: ::std::os::raw::c_int,
4864 id: u32,
4865 start: u32,
4866 max: u32,
4867 filter: *const spa_pod,
4868 ) -> ::std::os::raw::c_int,
4869 >,
4870 #[doc = " Set the configurable parameter in \\a node.\n\n Usually, \\a param will be obtained from enum_params and then\n modified but it is also possible to set another spa_pod\n as long as its keys and types match a supported object.\n\n Objects with property keys that are not known are ignored.\n\n This function must be called from the main thread.\n\n \\param node a \\ref spa_node\n \\param id the parameter id to configure\n \\param flags additional flags\n \\param param the parameter to configure\n\n \\return 0 on success\n -EINVAL when node is NULL\n -ENOTSUP when there are no parameters implemented on \\a node\n -ENOENT the parameter is unknown"]
4871 pub set_param: ::std::option::Option<
4872 unsafe extern "C" fn(
4873 object: *mut ::std::os::raw::c_void,
4874 id: u32,
4875 flags: u32,
4876 param: *const spa_pod,
4877 ) -> ::std::os::raw::c_int,
4878 >,
4879 #[doc = " Configure the given memory area with \\a id on \\a node. This\n structure is allocated by the host and is used to exchange\n data and parameters with the node.\n\n Setting an \\a io of NULL will disable the node io.\n\n This function must be called from the main thread.\n\n \\param id the id of the io area, the available ids can be\n enumerated with the node parameters.\n \\param data a io area memory\n \\param size the size of \\a data\n \\return 0 on success\n -EINVAL when invalid input is given\n -ENOENT when \\a id is unknown\n -ENOSPC when \\a size is too small"]
4880 pub set_io: ::std::option::Option<
4881 unsafe extern "C" fn(
4882 object: *mut ::std::os::raw::c_void,
4883 id: u32,
4884 data: *mut ::std::os::raw::c_void,
4885 size: usize,
4886 ) -> ::std::os::raw::c_int,
4887 >,
4888 #[doc = " Send a command to a node.\n\n Upon completion, a command might change the state of a node.\n\n This function must be called from the main thread.\n\n \\param node a spa_node\n \\param command a spa_command\n \\return 0 on success\n -EINVAL when node or command is NULL\n -ENOTSUP when this node can't process commands\n -EINVAL \\a command is an invalid command"]
4889 pub send_command: ::std::option::Option<
4890 unsafe extern "C" fn(
4891 object: *mut ::std::os::raw::c_void,
4892 command: *const spa_command,
4893 ) -> ::std::os::raw::c_int,
4894 >,
4895 #[doc = " Make a new port with \\a port_id. The caller should use the lowest unused\n port id for the given \\a direction.\n\n Port ids should be between 0 and max_ports as obtained from the info\n event.\n\n This function must be called from the main thread.\n\n \\param node a spa_node\n \\param direction a enum \\ref spa_direction\n \\param port_id an unused port id\n \\param props extra properties\n \\return 0 on success\n -EINVAL when node is NULL"]
4896 pub add_port: ::std::option::Option<
4897 unsafe extern "C" fn(
4898 object: *mut ::std::os::raw::c_void,
4899 direction: spa_direction,
4900 port_id: u32,
4901 props: *const spa_dict,
4902 ) -> ::std::os::raw::c_int,
4903 >,
4904 #[doc = " Remove a port with \\a port_id.\n\n \\param node a spa_node\n \\param direction a enum \\ref spa_direction\n \\param port_id a port id\n \\return 0 on success\n -EINVAL when node is NULL or when port_id is unknown or\n\t\twhen the port can't be removed."]
4905 pub remove_port: ::std::option::Option<
4906 unsafe extern "C" fn(
4907 object: *mut ::std::os::raw::c_void,
4908 direction: spa_direction,
4909 port_id: u32,
4910 ) -> ::std::os::raw::c_int,
4911 >,
4912 #[doc = " Enumerate all possible parameters of \\a id on \\a port_id of \\a node\n that are compatible with \\a filter.\n\n When SPA_ID_INVALID is given as the port_id, the node will reply with\n the params that would be returned for a new port in the given direction.\n\n The result parameters can be queried and modified and ultimately be used\n to call port_set_param.\n\n The function will emit the result event up to \\a max times with\n the result value. The seq in the result event will either be the\n \\a seq number when executed synchronously or the async return\n value of this function when executed asynchronously.\n\n This function must be called from the main thread.\n\n \\param node a spa_node\n \\param seq a sequence number to pass to the result event when\n\tthis method is executed synchronously.\n \\param direction an spa_direction\n \\param port_id the port to query or SPA_ID_INVALID\n \\param id the parameter id to query\n \\param start the first index to query, 0 to get the first item\n \\param max the maximum number of params to query\n \\param filter a parameter filter or NULL for no filter\n\n \\return 0 when no more items can be iterated.\n -EINVAL when invalid parameters are given\n -ENOENT when \\a id is unknown\n an async return value when the result event will be\n emitted later."]
4913 pub port_enum_params: ::std::option::Option<
4914 unsafe extern "C" fn(
4915 object: *mut ::std::os::raw::c_void,
4916 seq: ::std::os::raw::c_int,
4917 direction: spa_direction,
4918 port_id: u32,
4919 id: u32,
4920 start: u32,
4921 max: u32,
4922 filter: *const spa_pod,
4923 ) -> ::std::os::raw::c_int,
4924 >,
4925 #[doc = " Set a parameter on \\a port_id of \\a node.\n\n When \\a param is NULL, the parameter will be unset.\n\n This function must be called from the main thread. The node muse be paused\n or the port SPA_IO_Buffers area is NULL when this function is called with\n a param that changes the processing state (like a format change).\n\n \\param node a struct \\ref spa_node\n \\param direction a enum \\ref spa_direction\n \\param port_id the port to configure\n \\param id the parameter id to set\n \\param flags optional flags\n \\param param a struct \\ref spa_pod with the parameter to set\n \\return 0 on success\n 1 on success, the value of \\a param might have been\n changed depending on \\a flags and the final value can be found by\n doing port_enum_params.\n -EINVAL when node is NULL or invalid arguments are given\n -ESRCH when one of the mandatory param\n properties is not specified and SPA_NODE_PARAM_FLAG_FIXATE was\n not set in \\a flags.\n -ESRCH when the type or size of a property is not correct.\n -ENOENT when the param id is not found"]
4926 pub port_set_param: ::std::option::Option<
4927 unsafe extern "C" fn(
4928 object: *mut ::std::os::raw::c_void,
4929 direction: spa_direction,
4930 port_id: u32,
4931 id: u32,
4932 flags: u32,
4933 param: *const spa_pod,
4934 ) -> ::std::os::raw::c_int,
4935 >,
4936 #[doc = " Tell the port to use the given buffers\n\n When \\a flags contains SPA_NODE_BUFFERS_FLAG_ALLOC, the data\n in the buffers should point to an array of at least 1 data entry\n with the desired supported type that will be filled by this function.\n\n The port should also have a spa_io_buffers io area configured to exchange\n the buffers with the port.\n\n For an input port, all the buffers will remain dequeued.\n Once a buffer has been queued on a port in the spa_io_buffers,\n it should not be reused until the reuse_buffer callback is notified\n or when the buffer has been returned in the spa_io_buffers of\n the port.\n\n For output ports, all buffers will be queued in the port. When process\n returns SPA_STATUS_HAVE_DATA, buffers are available in one or more\n of the spa_io_buffers areas.\n\n When a buffer can be reused, port_reuse_buffer() should be called or the\n buffer_id should be placed in the spa_io_buffers area before calling\n process.\n\n Passing NULL as \\a buffers will remove the reference that the port has\n on the buffers.\n\n When this function returns async, use the spa_node_sync operation to\n wait for completion.\n\n This function must be called from the main thread. The node muse be paused\n or the port SPA_IO_Buffers area is NULL when this function is called.\n\n \\param object an object implementing the interface\n \\param direction a port direction\n \\param port_id a port id\n \\param flags extra flags\n \\param buffers an array of buffer pointers\n \\param n_buffers number of elements in \\a buffers\n \\return 0 on success"]
4937 pub port_use_buffers: ::std::option::Option<
4938 unsafe extern "C" fn(
4939 object: *mut ::std::os::raw::c_void,
4940 direction: spa_direction,
4941 port_id: u32,
4942 flags: u32,
4943 buffers: *mut *mut spa_buffer,
4944 n_buffers: u32,
4945 ) -> ::std::os::raw::c_int,
4946 >,
4947 #[doc = " Configure the given memory area with \\a id on \\a port_id. This\n structure is allocated by the host and is used to exchange\n data and parameters with the port.\n\n Setting an \\a io of NULL will disable the port io.\n\n This function must be called from the main thread.\n\n This function can be called when the node is running and the node\n must be prepared to handle changes in io areas while running. This\n is normally done by synchronizing the port io updates with the\n data processing loop.\n\n \\param direction a spa_direction\n \\param port_id a port id\n \\param id the id of the io area, the available ids can be\n enumerated with the port parameters.\n \\param data a io area memory\n \\param size the size of \\a data\n \\return 0 on success\n -EINVAL when invalid input is given\n -ENOENT when \\a id is unknown\n -ENOSPC when \\a size is too small"]
4948 pub port_set_io: ::std::option::Option<
4949 unsafe extern "C" fn(
4950 object: *mut ::std::os::raw::c_void,
4951 direction: spa_direction,
4952 port_id: u32,
4953 id: u32,
4954 data: *mut ::std::os::raw::c_void,
4955 size: usize,
4956 ) -> ::std::os::raw::c_int,
4957 >,
4958 #[doc = " Tell an output port to reuse a buffer.\n\n This function must be called from the data thread.\n\n \\param node a spa_node\n \\param port_id a port id\n \\param buffer_id a buffer id to reuse\n \\return 0 on success\n -EINVAL when node is NULL"]
4959 pub port_reuse_buffer: ::std::option::Option<
4960 unsafe extern "C" fn(
4961 object: *mut ::std::os::raw::c_void,
4962 port_id: u32,
4963 buffer_id: u32,
4964 ) -> ::std::os::raw::c_int,
4965 >,
4966 #[doc = " Process the node\n\n This function must be called from the data thread.\n\n Output io areas with SPA_STATUS_NEED_DATA will recycle the\n buffers if any.\n\n Input areas with SPA_STATUS_HAVE_DATA are consumed if possible\n and the status is set to SPA_STATUS_NEED_DATA or SPA_STATUS_OK.\n\n When the node has new output buffers, the SPA_STATUS_HAVE_DATA\n bit will be set.\n\n When the node can accept new input in the next cycle, the\n SPA_STATUS_NEED_DATA bit will be set.\n\n Note that the node might return SPA_STATUS_NEED_DATA even when\n no input ports have this status. This means that the amount of\n data still available on the input ports is likely not going to\n be enough for the next cycle and the host might need to prefetch\n data for the next cycle."]
4967 pub process: ::std::option::Option<
4968 unsafe extern "C" fn(object: *mut ::std::os::raw::c_void) -> ::std::os::raw::c_int,
4969 >,
4970}
4971#[allow(clippy::unnecessary_operation, clippy::identity_op)]
4972const _: () = {
4973 ["Size of spa_node_methods"][::std::mem::size_of::<spa_node_methods>() - 128usize];
4974 ["Alignment of spa_node_methods"][::std::mem::align_of::<spa_node_methods>() - 8usize];
4975 ["Offset of field: spa_node_methods::version"]
4976 [::std::mem::offset_of!(spa_node_methods, version) - 0usize];
4977 ["Offset of field: spa_node_methods::add_listener"]
4978 [::std::mem::offset_of!(spa_node_methods, add_listener) - 8usize];
4979 ["Offset of field: spa_node_methods::set_callbacks"]
4980 [::std::mem::offset_of!(spa_node_methods, set_callbacks) - 16usize];
4981 ["Offset of field: spa_node_methods::sync"]
4982 [::std::mem::offset_of!(spa_node_methods, sync) - 24usize];
4983 ["Offset of field: spa_node_methods::enum_params"]
4984 [::std::mem::offset_of!(spa_node_methods, enum_params) - 32usize];
4985 ["Offset of field: spa_node_methods::set_param"]
4986 [::std::mem::offset_of!(spa_node_methods, set_param) - 40usize];
4987 ["Offset of field: spa_node_methods::set_io"]
4988 [::std::mem::offset_of!(spa_node_methods, set_io) - 48usize];
4989 ["Offset of field: spa_node_methods::send_command"]
4990 [::std::mem::offset_of!(spa_node_methods, send_command) - 56usize];
4991 ["Offset of field: spa_node_methods::add_port"]
4992 [::std::mem::offset_of!(spa_node_methods, add_port) - 64usize];
4993 ["Offset of field: spa_node_methods::remove_port"]
4994 [::std::mem::offset_of!(spa_node_methods, remove_port) - 72usize];
4995 ["Offset of field: spa_node_methods::port_enum_params"]
4996 [::std::mem::offset_of!(spa_node_methods, port_enum_params) - 80usize];
4997 ["Offset of field: spa_node_methods::port_set_param"]
4998 [::std::mem::offset_of!(spa_node_methods, port_set_param) - 88usize];
4999 ["Offset of field: spa_node_methods::port_use_buffers"]
5000 [::std::mem::offset_of!(spa_node_methods, port_use_buffers) - 96usize];
5001 ["Offset of field: spa_node_methods::port_set_io"]
5002 [::std::mem::offset_of!(spa_node_methods, port_set_io) - 104usize];
5003 ["Offset of field: spa_node_methods::port_reuse_buffer"]
5004 [::std::mem::offset_of!(spa_node_methods, port_reuse_buffer) - 112usize];
5005 ["Offset of field: spa_node_methods::process"]
5006 [::std::mem::offset_of!(spa_node_methods, process) - 120usize];
5007};
5008unsafe extern "C" {
5009 #[link_name = "spa_node_add_listener_libspa_rs"]
5010 pub fn spa_node_add_listener(
5011 object: *mut spa_node,
5012 listener: *mut spa_hook,
5013 events: *const spa_node_events,
5014 data: *mut ::std::os::raw::c_void,
5015 ) -> ::std::os::raw::c_int;
5016}
5017unsafe extern "C" {
5018 #[link_name = "spa_node_set_callbacks_libspa_rs"]
5019 pub fn spa_node_set_callbacks(
5020 object: *mut spa_node,
5021 callbacks: *const spa_node_callbacks,
5022 data: *mut ::std::os::raw::c_void,
5023 ) -> ::std::os::raw::c_int;
5024}
5025unsafe extern "C" {
5026 #[link_name = "spa_node_sync_libspa_rs"]
5027 pub fn spa_node_sync(
5028 object: *mut spa_node,
5029 seq: ::std::os::raw::c_int,
5030 ) -> ::std::os::raw::c_int;
5031}
5032unsafe extern "C" {
5033 #[link_name = "spa_node_enum_params_libspa_rs"]
5034 pub fn spa_node_enum_params(
5035 object: *mut spa_node,
5036 seq: ::std::os::raw::c_int,
5037 id: u32,
5038 start: u32,
5039 max: u32,
5040 filter: *const spa_pod,
5041 ) -> ::std::os::raw::c_int;
5042}
5043unsafe extern "C" {
5044 #[link_name = "spa_node_set_param_libspa_rs"]
5045 pub fn spa_node_set_param(
5046 object: *mut spa_node,
5047 id: u32,
5048 flags: u32,
5049 param: *const spa_pod,
5050 ) -> ::std::os::raw::c_int;
5051}
5052unsafe extern "C" {
5053 #[link_name = "spa_node_set_io_libspa_rs"]
5054 pub fn spa_node_set_io(
5055 object: *mut spa_node,
5056 id: u32,
5057 data: *mut ::std::os::raw::c_void,
5058 size: usize,
5059 ) -> ::std::os::raw::c_int;
5060}
5061unsafe extern "C" {
5062 #[link_name = "spa_node_send_command_libspa_rs"]
5063 pub fn spa_node_send_command(
5064 object: *mut spa_node,
5065 command: *const spa_command,
5066 ) -> ::std::os::raw::c_int;
5067}
5068unsafe extern "C" {
5069 #[link_name = "spa_node_add_port_libspa_rs"]
5070 pub fn spa_node_add_port(
5071 object: *mut spa_node,
5072 direction: spa_direction,
5073 port_id: u32,
5074 props: *const spa_dict,
5075 ) -> ::std::os::raw::c_int;
5076}
5077unsafe extern "C" {
5078 #[link_name = "spa_node_remove_port_libspa_rs"]
5079 pub fn spa_node_remove_port(
5080 object: *mut spa_node,
5081 direction: spa_direction,
5082 port_id: u32,
5083 ) -> ::std::os::raw::c_int;
5084}
5085unsafe extern "C" {
5086 #[link_name = "spa_node_port_enum_params_libspa_rs"]
5087 pub fn spa_node_port_enum_params(
5088 object: *mut spa_node,
5089 seq: ::std::os::raw::c_int,
5090 direction: spa_direction,
5091 port_id: u32,
5092 id: u32,
5093 start: u32,
5094 max: u32,
5095 filter: *const spa_pod,
5096 ) -> ::std::os::raw::c_int;
5097}
5098unsafe extern "C" {
5099 #[link_name = "spa_node_port_set_param_libspa_rs"]
5100 pub fn spa_node_port_set_param(
5101 object: *mut spa_node,
5102 direction: spa_direction,
5103 port_id: u32,
5104 id: u32,
5105 flags: u32,
5106 param: *const spa_pod,
5107 ) -> ::std::os::raw::c_int;
5108}
5109unsafe extern "C" {
5110 #[link_name = "spa_node_port_use_buffers_libspa_rs"]
5111 pub fn spa_node_port_use_buffers(
5112 object: *mut spa_node,
5113 direction: spa_direction,
5114 port_id: u32,
5115 flags: u32,
5116 buffers: *mut *mut spa_buffer,
5117 n_buffers: u32,
5118 ) -> ::std::os::raw::c_int;
5119}
5120unsafe extern "C" {
5121 #[link_name = "spa_node_port_set_io_libspa_rs"]
5122 pub fn spa_node_port_set_io(
5123 object: *mut spa_node,
5124 direction: spa_direction,
5125 port_id: u32,
5126 id: u32,
5127 data: *mut ::std::os::raw::c_void,
5128 size: usize,
5129 ) -> ::std::os::raw::c_int;
5130}
5131unsafe extern "C" {
5132 #[link_name = "spa_node_port_reuse_buffer_libspa_rs"]
5133 pub fn spa_node_port_reuse_buffer(
5134 object: *mut spa_node,
5135 port_id: u32,
5136 buffer_id: u32,
5137 ) -> ::std::os::raw::c_int;
5138}
5139unsafe extern "C" {
5140 #[link_name = "spa_node_port_reuse_buffer_fast_libspa_rs"]
5141 pub fn spa_node_port_reuse_buffer_fast(
5142 object: *mut spa_node,
5143 port_id: u32,
5144 buffer_id: u32,
5145 ) -> ::std::os::raw::c_int;
5146}
5147unsafe extern "C" {
5148 #[link_name = "spa_node_process_libspa_rs"]
5149 pub fn spa_node_process(object: *mut spa_node) -> ::std::os::raw::c_int;
5150}
5151unsafe extern "C" {
5152 #[link_name = "spa_node_process_fast_libspa_rs"]
5153 pub fn spa_node_process_fast(object: *mut spa_node) -> ::std::os::raw::c_int;
5154}
5155unsafe extern "C" {
5156 #[link_name = "spa_debugc_port_info_libspa_rs"]
5157 pub fn spa_debugc_port_info(
5158 ctx: *mut spa_debug_context,
5159 indent: ::std::os::raw::c_int,
5160 info: *const spa_port_info,
5161 ) -> ::std::os::raw::c_int;
5162}
5163unsafe extern "C" {
5164 #[link_name = "spa_debug_port_info_libspa_rs"]
5165 pub fn spa_debug_port_info(
5166 indent: ::std::os::raw::c_int,
5167 info: *const spa_port_info,
5168 ) -> ::std::os::raw::c_int;
5169}
5170unsafe extern "C" {
5171 #[link_name = "spa_debugc_pod_value_libspa_rs"]
5172 pub fn spa_debugc_pod_value(
5173 ctx: *mut spa_debug_context,
5174 indent: ::std::os::raw::c_int,
5175 info: *const spa_type_info,
5176 type_: u32,
5177 body: *mut ::std::os::raw::c_void,
5178 size: u32,
5179 ) -> ::std::os::raw::c_int;
5180}
5181unsafe extern "C" {
5182 #[link_name = "spa_debugc_pod_libspa_rs"]
5183 pub fn spa_debugc_pod(
5184 ctx: *mut spa_debug_context,
5185 indent: ::std::os::raw::c_int,
5186 info: *const spa_type_info,
5187 pod: *const spa_pod,
5188 ) -> ::std::os::raw::c_int;
5189}
5190unsafe extern "C" {
5191 #[link_name = "spa_debug_pod_value_libspa_rs"]
5192 pub fn spa_debug_pod_value(
5193 indent: ::std::os::raw::c_int,
5194 info: *const spa_type_info,
5195 type_: u32,
5196 body: *mut ::std::os::raw::c_void,
5197 size: u32,
5198 ) -> ::std::os::raw::c_int;
5199}
5200unsafe extern "C" {
5201 #[link_name = "spa_debug_pod_libspa_rs"]
5202 pub fn spa_debug_pod(
5203 indent: ::std::os::raw::c_int,
5204 info: *const spa_type_info,
5205 pod: *const spa_pod,
5206 ) -> ::std::os::raw::c_int;
5207}
5208#[repr(C)]
5209#[derive(Debug, Copy, Clone, PartialEq, Eq)]
5210pub struct spa_graph_state {
5211 #[doc = "< current status"]
5212 pub status: ::std::os::raw::c_int,
5213 #[doc = "< required number of signals"]
5214 pub required: i32,
5215 #[doc = "< number of pending signals"]
5216 pub pending: i32,
5217}
5218#[allow(clippy::unnecessary_operation, clippy::identity_op)]
5219const _: () = {
5220 ["Size of spa_graph_state"][::std::mem::size_of::<spa_graph_state>() - 12usize];
5221 ["Alignment of spa_graph_state"][::std::mem::align_of::<spa_graph_state>() - 4usize];
5222 ["Offset of field: spa_graph_state::status"]
5223 [::std::mem::offset_of!(spa_graph_state, status) - 0usize];
5224 ["Offset of field: spa_graph_state::required"]
5225 [::std::mem::offset_of!(spa_graph_state, required) - 4usize];
5226 ["Offset of field: spa_graph_state::pending"]
5227 [::std::mem::offset_of!(spa_graph_state, pending) - 8usize];
5228};
5229unsafe extern "C" {
5230 #[link_name = "spa_graph_state_reset_libspa_rs"]
5231 pub fn spa_graph_state_reset(state: *mut spa_graph_state);
5232}
5233#[repr(C)]
5234#[derive(Debug, Copy, Clone, PartialEq, Eq)]
5235pub struct spa_graph_link {
5236 pub link: spa_list,
5237 pub state: *mut spa_graph_state,
5238 pub signal: ::std::option::Option<
5239 unsafe extern "C" fn(data: *mut ::std::os::raw::c_void) -> ::std::os::raw::c_int,
5240 >,
5241 pub signal_data: *mut ::std::os::raw::c_void,
5242}
5243#[allow(clippy::unnecessary_operation, clippy::identity_op)]
5244const _: () = {
5245 ["Size of spa_graph_link"][::std::mem::size_of::<spa_graph_link>() - 40usize];
5246 ["Alignment of spa_graph_link"][::std::mem::align_of::<spa_graph_link>() - 8usize];
5247 ["Offset of field: spa_graph_link::link"]
5248 [::std::mem::offset_of!(spa_graph_link, link) - 0usize];
5249 ["Offset of field: spa_graph_link::state"]
5250 [::std::mem::offset_of!(spa_graph_link, state) - 16usize];
5251 ["Offset of field: spa_graph_link::signal"]
5252 [::std::mem::offset_of!(spa_graph_link, signal) - 24usize];
5253 ["Offset of field: spa_graph_link::signal_data"]
5254 [::std::mem::offset_of!(spa_graph_link, signal_data) - 32usize];
5255};
5256unsafe extern "C" {
5257 #[link_name = "spa_graph_link_trigger_libspa_rs"]
5258 pub fn spa_graph_link_trigger(link: *mut spa_graph_link) -> ::std::os::raw::c_int;
5259}
5260#[repr(C)]
5261#[derive(Debug, Copy, Clone, PartialEq, Eq)]
5262pub struct spa_graph {
5263 pub flags: u32,
5264 pub parent: *mut spa_graph_node,
5265 pub state: *mut spa_graph_state,
5266 pub nodes: spa_list,
5267}
5268#[allow(clippy::unnecessary_operation, clippy::identity_op)]
5269const _: () = {
5270 ["Size of spa_graph"][::std::mem::size_of::<spa_graph>() - 40usize];
5271 ["Alignment of spa_graph"][::std::mem::align_of::<spa_graph>() - 8usize];
5272 ["Offset of field: spa_graph::flags"][::std::mem::offset_of!(spa_graph, flags) - 0usize];
5273 ["Offset of field: spa_graph::parent"][::std::mem::offset_of!(spa_graph, parent) - 8usize];
5274 ["Offset of field: spa_graph::state"][::std::mem::offset_of!(spa_graph, state) - 16usize];
5275 ["Offset of field: spa_graph::nodes"][::std::mem::offset_of!(spa_graph, nodes) - 24usize];
5276};
5277#[repr(C)]
5278#[derive(Debug, Copy, Clone, PartialEq, Eq)]
5279pub struct spa_graph_node_callbacks {
5280 pub version: u32,
5281 pub process: ::std::option::Option<
5282 unsafe extern "C" fn(
5283 data: *mut ::std::os::raw::c_void,
5284 node: *mut spa_graph_node,
5285 ) -> ::std::os::raw::c_int,
5286 >,
5287 pub reuse_buffer: ::std::option::Option<
5288 unsafe extern "C" fn(
5289 data: *mut ::std::os::raw::c_void,
5290 node: *mut spa_graph_node,
5291 port_id: u32,
5292 buffer_id: u32,
5293 ) -> ::std::os::raw::c_int,
5294 >,
5295}
5296#[allow(clippy::unnecessary_operation, clippy::identity_op)]
5297const _: () = {
5298 ["Size of spa_graph_node_callbacks"]
5299 [::std::mem::size_of::<spa_graph_node_callbacks>() - 24usize];
5300 ["Alignment of spa_graph_node_callbacks"]
5301 [::std::mem::align_of::<spa_graph_node_callbacks>() - 8usize];
5302 ["Offset of field: spa_graph_node_callbacks::version"]
5303 [::std::mem::offset_of!(spa_graph_node_callbacks, version) - 0usize];
5304 ["Offset of field: spa_graph_node_callbacks::process"]
5305 [::std::mem::offset_of!(spa_graph_node_callbacks, process) - 8usize];
5306 ["Offset of field: spa_graph_node_callbacks::reuse_buffer"]
5307 [::std::mem::offset_of!(spa_graph_node_callbacks, reuse_buffer) - 16usize];
5308};
5309#[repr(C)]
5310#[derive(Debug, Copy, Clone, PartialEq, Eq)]
5311pub struct spa_graph_node {
5312 #[doc = "< link in graph nodes list"]
5313 pub link: spa_list,
5314 #[doc = "< owner graph"]
5315 pub graph: *mut spa_graph,
5316 #[doc = "< list of input and output ports"]
5317 pub ports: [spa_list; 2usize],
5318 #[doc = "< list of links to next nodes"]
5319 pub links: spa_list,
5320 #[doc = "< node flags"]
5321 pub flags: u32,
5322 #[doc = "< state of the node"]
5323 pub state: *mut spa_graph_state,
5324 #[doc = "< link in graph"]
5325 pub graph_link: spa_graph_link,
5326 #[doc = "< subgraph or NULL"]
5327 pub subgraph: *mut spa_graph,
5328 pub callbacks: spa_callbacks,
5329 #[doc = "< link for scheduler"]
5330 pub sched_link: spa_list,
5331}
5332#[allow(clippy::unnecessary_operation, clippy::identity_op)]
5333const _: () = {
5334 ["Size of spa_graph_node"][::std::mem::size_of::<spa_graph_node>() - 168usize];
5335 ["Alignment of spa_graph_node"][::std::mem::align_of::<spa_graph_node>() - 8usize];
5336 ["Offset of field: spa_graph_node::link"]
5337 [::std::mem::offset_of!(spa_graph_node, link) - 0usize];
5338 ["Offset of field: spa_graph_node::graph"]
5339 [::std::mem::offset_of!(spa_graph_node, graph) - 16usize];
5340 ["Offset of field: spa_graph_node::ports"]
5341 [::std::mem::offset_of!(spa_graph_node, ports) - 24usize];
5342 ["Offset of field: spa_graph_node::links"]
5343 [::std::mem::offset_of!(spa_graph_node, links) - 56usize];
5344 ["Offset of field: spa_graph_node::flags"]
5345 [::std::mem::offset_of!(spa_graph_node, flags) - 72usize];
5346 ["Offset of field: spa_graph_node::state"]
5347 [::std::mem::offset_of!(spa_graph_node, state) - 80usize];
5348 ["Offset of field: spa_graph_node::graph_link"]
5349 [::std::mem::offset_of!(spa_graph_node, graph_link) - 88usize];
5350 ["Offset of field: spa_graph_node::subgraph"]
5351 [::std::mem::offset_of!(spa_graph_node, subgraph) - 128usize];
5352 ["Offset of field: spa_graph_node::callbacks"]
5353 [::std::mem::offset_of!(spa_graph_node, callbacks) - 136usize];
5354 ["Offset of field: spa_graph_node::sched_link"]
5355 [::std::mem::offset_of!(spa_graph_node, sched_link) - 152usize];
5356};
5357#[repr(C)]
5358#[derive(Debug, Copy, Clone, PartialEq, Eq)]
5359pub struct spa_graph_port {
5360 #[doc = "< link in node port list"]
5361 pub link: spa_list,
5362 #[doc = "< owner node"]
5363 pub node: *mut spa_graph_node,
5364 #[doc = "< port direction"]
5365 pub direction: spa_direction,
5366 #[doc = "< port id"]
5367 pub port_id: u32,
5368 #[doc = "< port flags"]
5369 pub flags: u32,
5370 #[doc = "< peer"]
5371 pub peer: *mut spa_graph_port,
5372}
5373#[allow(clippy::unnecessary_operation, clippy::identity_op)]
5374const _: () = {
5375 ["Size of spa_graph_port"][::std::mem::size_of::<spa_graph_port>() - 48usize];
5376 ["Alignment of spa_graph_port"][::std::mem::align_of::<spa_graph_port>() - 8usize];
5377 ["Offset of field: spa_graph_port::link"]
5378 [::std::mem::offset_of!(spa_graph_port, link) - 0usize];
5379 ["Offset of field: spa_graph_port::node"]
5380 [::std::mem::offset_of!(spa_graph_port, node) - 16usize];
5381 ["Offset of field: spa_graph_port::direction"]
5382 [::std::mem::offset_of!(spa_graph_port, direction) - 24usize];
5383 ["Offset of field: spa_graph_port::port_id"]
5384 [::std::mem::offset_of!(spa_graph_port, port_id) - 28usize];
5385 ["Offset of field: spa_graph_port::flags"]
5386 [::std::mem::offset_of!(spa_graph_port, flags) - 32usize];
5387 ["Offset of field: spa_graph_port::peer"]
5388 [::std::mem::offset_of!(spa_graph_port, peer) - 40usize];
5389};
5390unsafe extern "C" {
5391 #[link_name = "spa_graph_node_trigger_libspa_rs"]
5392 pub fn spa_graph_node_trigger(node: *mut spa_graph_node) -> ::std::os::raw::c_int;
5393}
5394unsafe extern "C" {
5395 #[link_name = "spa_graph_run_libspa_rs"]
5396 pub fn spa_graph_run(graph: *mut spa_graph) -> ::std::os::raw::c_int;
5397}
5398unsafe extern "C" {
5399 #[link_name = "spa_graph_finish_libspa_rs"]
5400 pub fn spa_graph_finish(graph: *mut spa_graph) -> ::std::os::raw::c_int;
5401}
5402unsafe extern "C" {
5403 #[link_name = "spa_graph_link_signal_node_libspa_rs"]
5404 pub fn spa_graph_link_signal_node(data: *mut ::std::os::raw::c_void) -> ::std::os::raw::c_int;
5405}
5406unsafe extern "C" {
5407 #[link_name = "spa_graph_link_signal_graph_libspa_rs"]
5408 pub fn spa_graph_link_signal_graph(data: *mut ::std::os::raw::c_void) -> ::std::os::raw::c_int;
5409}
5410unsafe extern "C" {
5411 #[link_name = "spa_graph_init_libspa_rs"]
5412 pub fn spa_graph_init(graph: *mut spa_graph, state: *mut spa_graph_state);
5413}
5414unsafe extern "C" {
5415 #[link_name = "spa_graph_link_add_libspa_rs"]
5416 pub fn spa_graph_link_add(
5417 out: *mut spa_graph_node,
5418 state: *mut spa_graph_state,
5419 link: *mut spa_graph_link,
5420 );
5421}
5422unsafe extern "C" {
5423 #[link_name = "spa_graph_link_remove_libspa_rs"]
5424 pub fn spa_graph_link_remove(link: *mut spa_graph_link);
5425}
5426unsafe extern "C" {
5427 #[link_name = "spa_graph_node_init_libspa_rs"]
5428 pub fn spa_graph_node_init(node: *mut spa_graph_node, state: *mut spa_graph_state);
5429}
5430unsafe extern "C" {
5431 #[link_name = "spa_graph_node_impl_sub_process_libspa_rs"]
5432 pub fn spa_graph_node_impl_sub_process(
5433 data: *mut ::std::os::raw::c_void,
5434 node: *mut spa_graph_node,
5435 ) -> ::std::os::raw::c_int;
5436}
5437unsafe extern "C" {
5438 #[link_name = "spa_graph_node_set_subgraph_libspa_rs"]
5439 pub fn spa_graph_node_set_subgraph(node: *mut spa_graph_node, subgraph: *mut spa_graph);
5440}
5441unsafe extern "C" {
5442 #[link_name = "spa_graph_node_set_callbacks_libspa_rs"]
5443 pub fn spa_graph_node_set_callbacks(
5444 node: *mut spa_graph_node,
5445 callbacks: *const spa_graph_node_callbacks,
5446 data: *mut ::std::os::raw::c_void,
5447 );
5448}
5449unsafe extern "C" {
5450 #[link_name = "spa_graph_node_add_libspa_rs"]
5451 pub fn spa_graph_node_add(graph: *mut spa_graph, node: *mut spa_graph_node);
5452}
5453unsafe extern "C" {
5454 #[link_name = "spa_graph_node_remove_libspa_rs"]
5455 pub fn spa_graph_node_remove(node: *mut spa_graph_node);
5456}
5457unsafe extern "C" {
5458 #[link_name = "spa_graph_port_init_libspa_rs"]
5459 pub fn spa_graph_port_init(
5460 port: *mut spa_graph_port,
5461 direction: spa_direction,
5462 port_id: u32,
5463 flags: u32,
5464 );
5465}
5466unsafe extern "C" {
5467 #[link_name = "spa_graph_port_add_libspa_rs"]
5468 pub fn spa_graph_port_add(node: *mut spa_graph_node, port: *mut spa_graph_port);
5469}
5470unsafe extern "C" {
5471 #[link_name = "spa_graph_port_remove_libspa_rs"]
5472 pub fn spa_graph_port_remove(port: *mut spa_graph_port);
5473}
5474unsafe extern "C" {
5475 #[link_name = "spa_graph_port_link_libspa_rs"]
5476 pub fn spa_graph_port_link(out: *mut spa_graph_port, in_: *mut spa_graph_port);
5477}
5478unsafe extern "C" {
5479 #[link_name = "spa_graph_port_unlink_libspa_rs"]
5480 pub fn spa_graph_port_unlink(port: *mut spa_graph_port);
5481}
5482unsafe extern "C" {
5483 #[link_name = "spa_graph_node_impl_process_libspa_rs"]
5484 pub fn spa_graph_node_impl_process(
5485 data: *mut ::std::os::raw::c_void,
5486 node: *mut spa_graph_node,
5487 ) -> ::std::os::raw::c_int;
5488}
5489unsafe extern "C" {
5490 #[link_name = "spa_graph_node_impl_reuse_buffer_libspa_rs"]
5491 pub fn spa_graph_node_impl_reuse_buffer(
5492 data: *mut ::std::os::raw::c_void,
5493 node: *mut spa_graph_node,
5494 port_id: u32,
5495 buffer_id: u32,
5496 ) -> ::std::os::raw::c_int;
5497}
5498#[repr(C)]
5499#[derive(Debug, Copy, Clone, PartialEq, Eq)]
5500pub struct spa_device {
5501 pub iface: spa_interface,
5502}
5503#[allow(clippy::unnecessary_operation, clippy::identity_op)]
5504const _: () = {
5505 ["Size of spa_device"][::std::mem::size_of::<spa_device>() - 32usize];
5506 ["Alignment of spa_device"][::std::mem::align_of::<spa_device>() - 8usize];
5507 ["Offset of field: spa_device::iface"][::std::mem::offset_of!(spa_device, iface) - 0usize];
5508};
5509#[doc = " Information about the device and parameters it supports\n\n This information is part of the info event on a device."]
5510#[repr(C)]
5511#[derive(Debug, Copy, Clone, PartialEq, Eq)]
5512pub struct spa_device_info {
5513 pub version: u32,
5514 pub change_mask: u64,
5515 pub flags: u64,
5516 #[doc = "< device properties"]
5517 pub props: *const spa_dict,
5518 #[doc = "< supported parameters"]
5519 pub params: *mut spa_param_info,
5520 #[doc = "< number of elements in params"]
5521 pub n_params: u32,
5522}
5523#[allow(clippy::unnecessary_operation, clippy::identity_op)]
5524const _: () = {
5525 ["Size of spa_device_info"][::std::mem::size_of::<spa_device_info>() - 48usize];
5526 ["Alignment of spa_device_info"][::std::mem::align_of::<spa_device_info>() - 8usize];
5527 ["Offset of field: spa_device_info::version"]
5528 [::std::mem::offset_of!(spa_device_info, version) - 0usize];
5529 ["Offset of field: spa_device_info::change_mask"]
5530 [::std::mem::offset_of!(spa_device_info, change_mask) - 8usize];
5531 ["Offset of field: spa_device_info::flags"]
5532 [::std::mem::offset_of!(spa_device_info, flags) - 16usize];
5533 ["Offset of field: spa_device_info::props"]
5534 [::std::mem::offset_of!(spa_device_info, props) - 24usize];
5535 ["Offset of field: spa_device_info::params"]
5536 [::std::mem::offset_of!(spa_device_info, params) - 32usize];
5537 ["Offset of field: spa_device_info::n_params"]
5538 [::std::mem::offset_of!(spa_device_info, n_params) - 40usize];
5539};
5540#[doc = " Information about a device object\n\n This information is part of the object_info event on the device."]
5541#[repr(C)]
5542#[derive(Debug, Copy, Clone, PartialEq, Eq)]
5543pub struct spa_device_object_info {
5544 pub version: u32,
5545 #[doc = "< the object type managed by this device"]
5546 pub type_: *const ::std::os::raw::c_char,
5547 #[doc = "< a factory name that implements the object"]
5548 pub factory_name: *const ::std::os::raw::c_char,
5549 pub change_mask: u64,
5550 pub flags: u64,
5551 #[doc = "< extra object properties"]
5552 pub props: *const spa_dict,
5553}
5554#[allow(clippy::unnecessary_operation, clippy::identity_op)]
5555const _: () = {
5556 ["Size of spa_device_object_info"][::std::mem::size_of::<spa_device_object_info>() - 48usize];
5557 ["Alignment of spa_device_object_info"]
5558 [::std::mem::align_of::<spa_device_object_info>() - 8usize];
5559 ["Offset of field: spa_device_object_info::version"]
5560 [::std::mem::offset_of!(spa_device_object_info, version) - 0usize];
5561 ["Offset of field: spa_device_object_info::type_"]
5562 [::std::mem::offset_of!(spa_device_object_info, type_) - 8usize];
5563 ["Offset of field: spa_device_object_info::factory_name"]
5564 [::std::mem::offset_of!(spa_device_object_info, factory_name) - 16usize];
5565 ["Offset of field: spa_device_object_info::change_mask"]
5566 [::std::mem::offset_of!(spa_device_object_info, change_mask) - 24usize];
5567 ["Offset of field: spa_device_object_info::flags"]
5568 [::std::mem::offset_of!(spa_device_object_info, flags) - 32usize];
5569 ["Offset of field: spa_device_object_info::props"]
5570 [::std::mem::offset_of!(spa_device_object_info, props) - 40usize];
5571};
5572#[repr(C)]
5573#[derive(Debug, Copy, Clone, PartialEq, Eq)]
5574pub struct spa_result_device_params {
5575 pub id: u32,
5576 pub index: u32,
5577 pub next: u32,
5578 pub param: *mut spa_pod,
5579}
5580#[allow(clippy::unnecessary_operation, clippy::identity_op)]
5581const _: () = {
5582 ["Size of spa_result_device_params"]
5583 [::std::mem::size_of::<spa_result_device_params>() - 24usize];
5584 ["Alignment of spa_result_device_params"]
5585 [::std::mem::align_of::<spa_result_device_params>() - 8usize];
5586 ["Offset of field: spa_result_device_params::id"]
5587 [::std::mem::offset_of!(spa_result_device_params, id) - 0usize];
5588 ["Offset of field: spa_result_device_params::index"]
5589 [::std::mem::offset_of!(spa_result_device_params, index) - 4usize];
5590 ["Offset of field: spa_result_device_params::next"]
5591 [::std::mem::offset_of!(spa_result_device_params, next) - 8usize];
5592 ["Offset of field: spa_result_device_params::param"]
5593 [::std::mem::offset_of!(spa_result_device_params, param) - 16usize];
5594};
5595#[doc = " spa_device_events:\n\n Events are always emitted from the main thread"]
5596#[repr(C)]
5597#[derive(Debug, Copy, Clone, PartialEq, Eq)]
5598pub struct spa_device_events {
5599 pub version: u32,
5600 #[doc = " notify extra information about the device"]
5601 pub info: ::std::option::Option<
5602 unsafe extern "C" fn(data: *mut ::std::os::raw::c_void, info: *const spa_device_info),
5603 >,
5604 #[doc = " notify a result"]
5605 pub result: ::std::option::Option<
5606 unsafe extern "C" fn(
5607 data: *mut ::std::os::raw::c_void,
5608 seq: ::std::os::raw::c_int,
5609 res: ::std::os::raw::c_int,
5610 type_: u32,
5611 result: *const ::std::os::raw::c_void,
5612 ),
5613 >,
5614 #[doc = " a device event"]
5615 pub event: ::std::option::Option<
5616 unsafe extern "C" fn(data: *mut ::std::os::raw::c_void, event: *const spa_event),
5617 >,
5618 #[doc = " info changed for an object managed by the device, info is NULL when\n the object is removed"]
5619 pub object_info: ::std::option::Option<
5620 unsafe extern "C" fn(
5621 data: *mut ::std::os::raw::c_void,
5622 id: u32,
5623 info: *const spa_device_object_info,
5624 ),
5625 >,
5626}
5627#[allow(clippy::unnecessary_operation, clippy::identity_op)]
5628const _: () = {
5629 ["Size of spa_device_events"][::std::mem::size_of::<spa_device_events>() - 40usize];
5630 ["Alignment of spa_device_events"][::std::mem::align_of::<spa_device_events>() - 8usize];
5631 ["Offset of field: spa_device_events::version"]
5632 [::std::mem::offset_of!(spa_device_events, version) - 0usize];
5633 ["Offset of field: spa_device_events::info"]
5634 [::std::mem::offset_of!(spa_device_events, info) - 8usize];
5635 ["Offset of field: spa_device_events::result"]
5636 [::std::mem::offset_of!(spa_device_events, result) - 16usize];
5637 ["Offset of field: spa_device_events::event"]
5638 [::std::mem::offset_of!(spa_device_events, event) - 24usize];
5639 ["Offset of field: spa_device_events::object_info"]
5640 [::std::mem::offset_of!(spa_device_events, object_info) - 32usize];
5641};
5642#[doc = " spa_device_methods:"]
5643#[repr(C)]
5644#[derive(Debug, Copy, Clone, PartialEq, Eq)]
5645pub struct spa_device_methods {
5646 pub version: u32,
5647 #[doc = " Set events to receive asynchronous notifications from\n the device.\n\n Setting the events will trigger the info event and an\n object_info event for each managed object on the new\n listener.\n\n \\param object a \\ref spa_device\n \\param listener a listener\n \\param events a struct \\ref spa_device_events\n \\param data data passed as first argument in functions of \\a events\n \\return 0 on success\n\t < 0 errno on error"]
5648 pub add_listener: ::std::option::Option<
5649 unsafe extern "C" fn(
5650 object: *mut ::std::os::raw::c_void,
5651 listener: *mut spa_hook,
5652 events: *const spa_device_events,
5653 data: *mut ::std::os::raw::c_void,
5654 ) -> ::std::os::raw::c_int,
5655 >,
5656 #[doc = " Perform a sync operation.\n\n This method will emit the result event with the given sequence\n number synchronously or with the returned async return value\n asynchronously.\n\n Because all methods are serialized in the device, this can be used\n to wait for completion of all previous method calls.\n\n \\param seq a sequence number\n \\return 0 on success\n -EINVAL when node is NULL\n an async result"]
5657 pub sync: ::std::option::Option<
5658 unsafe extern "C" fn(
5659 object: *mut ::std::os::raw::c_void,
5660 seq: ::std::os::raw::c_int,
5661 ) -> ::std::os::raw::c_int,
5662 >,
5663 #[doc = " Enumerate the parameters of a device.\n\n Parameters are identified with an \\a id. Some parameters can have\n multiple values, see the documentation of the parameter id.\n\n Parameters can be filtered by passing a non-NULL \\a filter.\n\n The result callback will be called at most \\a max times with a\n struct spa_result_device_params as the result.\n\n This function must be called from the main thread.\n\n \\param device a \\ref spa_device\n \\param seq a sequence number to pass to the result function\n \\param id the param id to enumerate\n \\param index the index of enumeration, pass 0 for the first item.\n \\param max the maximum number of items to iterate\n \\param filter and optional filter to use\n \\return 0 when there are no more parameters to enumerate\n -EINVAL when invalid arguments are given\n -ENOENT the parameter \\a id is unknown\n -ENOTSUP when there are no parameters\n implemented on \\a device"]
5664 pub enum_params: ::std::option::Option<
5665 unsafe extern "C" fn(
5666 object: *mut ::std::os::raw::c_void,
5667 seq: ::std::os::raw::c_int,
5668 id: u32,
5669 index: u32,
5670 max: u32,
5671 filter: *const spa_pod,
5672 ) -> ::std::os::raw::c_int,
5673 >,
5674 #[doc = " Set the configurable parameter in \\a device.\n\n Usually, \\a param will be obtained from enum_params and then\n modified but it is also possible to set another spa_pod\n as long as its keys and types match a supported object.\n\n Objects with property keys that are not known are ignored.\n\n This function must be called from the main thread.\n\n \\param object \\ref spa_device\n \\param id the parameter id to configure\n \\param flags additional flags\n \\param param the parameter to configure\n\n \\return 0 on success\n -EINVAL when invalid arguments are given\n -ENOTSUP when there are no parameters implemented on \\a device\n -ENOENT the parameter is unknown"]
5675 pub set_param: ::std::option::Option<
5676 unsafe extern "C" fn(
5677 object: *mut ::std::os::raw::c_void,
5678 id: u32,
5679 flags: u32,
5680 param: *const spa_pod,
5681 ) -> ::std::os::raw::c_int,
5682 >,
5683}
5684#[allow(clippy::unnecessary_operation, clippy::identity_op)]
5685const _: () = {
5686 ["Size of spa_device_methods"][::std::mem::size_of::<spa_device_methods>() - 40usize];
5687 ["Alignment of spa_device_methods"][::std::mem::align_of::<spa_device_methods>() - 8usize];
5688 ["Offset of field: spa_device_methods::version"]
5689 [::std::mem::offset_of!(spa_device_methods, version) - 0usize];
5690 ["Offset of field: spa_device_methods::add_listener"]
5691 [::std::mem::offset_of!(spa_device_methods, add_listener) - 8usize];
5692 ["Offset of field: spa_device_methods::sync"]
5693 [::std::mem::offset_of!(spa_device_methods, sync) - 16usize];
5694 ["Offset of field: spa_device_methods::enum_params"]
5695 [::std::mem::offset_of!(spa_device_methods, enum_params) - 24usize];
5696 ["Offset of field: spa_device_methods::set_param"]
5697 [::std::mem::offset_of!(spa_device_methods, set_param) - 32usize];
5698};
5699unsafe extern "C" {
5700 #[link_name = "spa_device_add_listener_libspa_rs"]
5701 pub fn spa_device_add_listener(
5702 object: *mut spa_device,
5703 listener: *mut spa_hook,
5704 events: *const spa_device_events,
5705 data: *mut ::std::os::raw::c_void,
5706 ) -> ::std::os::raw::c_int;
5707}
5708unsafe extern "C" {
5709 #[link_name = "spa_device_sync_libspa_rs"]
5710 pub fn spa_device_sync(
5711 object: *mut spa_device,
5712 seq: ::std::os::raw::c_int,
5713 ) -> ::std::os::raw::c_int;
5714}
5715unsafe extern "C" {
5716 #[link_name = "spa_device_enum_params_libspa_rs"]
5717 pub fn spa_device_enum_params(
5718 object: *mut spa_device,
5719 seq: ::std::os::raw::c_int,
5720 id: u32,
5721 index: u32,
5722 max: u32,
5723 filter: *const spa_pod,
5724 ) -> ::std::os::raw::c_int;
5725}
5726unsafe extern "C" {
5727 #[link_name = "spa_device_set_param_libspa_rs"]
5728 pub fn spa_device_set_param(
5729 object: *mut spa_device,
5730 id: u32,
5731 flags: u32,
5732 param: *const spa_pod,
5733 ) -> ::std::os::raw::c_int;
5734}
5735#[repr(C)]
5736#[derive(Debug, Copy, Clone, PartialEq, Eq)]
5737pub struct spa_pod_builder_state {
5738 pub offset: u32,
5739 pub flags: u32,
5740 pub frame: *mut spa_pod_frame,
5741}
5742#[allow(clippy::unnecessary_operation, clippy::identity_op)]
5743const _: () = {
5744 ["Size of spa_pod_builder_state"][::std::mem::size_of::<spa_pod_builder_state>() - 16usize];
5745 ["Alignment of spa_pod_builder_state"]
5746 [::std::mem::align_of::<spa_pod_builder_state>() - 8usize];
5747 ["Offset of field: spa_pod_builder_state::offset"]
5748 [::std::mem::offset_of!(spa_pod_builder_state, offset) - 0usize];
5749 ["Offset of field: spa_pod_builder_state::flags"]
5750 [::std::mem::offset_of!(spa_pod_builder_state, flags) - 4usize];
5751 ["Offset of field: spa_pod_builder_state::frame"]
5752 [::std::mem::offset_of!(spa_pod_builder_state, frame) - 8usize];
5753};
5754#[repr(C)]
5755#[derive(Debug, Copy, Clone, PartialEq, Eq)]
5756pub struct spa_pod_builder_callbacks {
5757 pub version: u32,
5758 pub overflow: ::std::option::Option<
5759 unsafe extern "C" fn(data: *mut ::std::os::raw::c_void, size: u32) -> ::std::os::raw::c_int,
5760 >,
5761}
5762#[allow(clippy::unnecessary_operation, clippy::identity_op)]
5763const _: () = {
5764 ["Size of spa_pod_builder_callbacks"]
5765 [::std::mem::size_of::<spa_pod_builder_callbacks>() - 16usize];
5766 ["Alignment of spa_pod_builder_callbacks"]
5767 [::std::mem::align_of::<spa_pod_builder_callbacks>() - 8usize];
5768 ["Offset of field: spa_pod_builder_callbacks::version"]
5769 [::std::mem::offset_of!(spa_pod_builder_callbacks, version) - 0usize];
5770 ["Offset of field: spa_pod_builder_callbacks::overflow"]
5771 [::std::mem::offset_of!(spa_pod_builder_callbacks, overflow) - 8usize];
5772};
5773#[repr(C)]
5774#[derive(Debug, Copy, Clone, PartialEq, Eq)]
5775pub struct spa_pod_builder {
5776 pub data: *mut ::std::os::raw::c_void,
5777 pub size: u32,
5778 pub _padding: u32,
5779 pub state: spa_pod_builder_state,
5780 pub callbacks: spa_callbacks,
5781}
5782#[allow(clippy::unnecessary_operation, clippy::identity_op)]
5783const _: () = {
5784 ["Size of spa_pod_builder"][::std::mem::size_of::<spa_pod_builder>() - 48usize];
5785 ["Alignment of spa_pod_builder"][::std::mem::align_of::<spa_pod_builder>() - 8usize];
5786 ["Offset of field: spa_pod_builder::data"]
5787 [::std::mem::offset_of!(spa_pod_builder, data) - 0usize];
5788 ["Offset of field: spa_pod_builder::size"]
5789 [::std::mem::offset_of!(spa_pod_builder, size) - 8usize];
5790 ["Offset of field: spa_pod_builder::_padding"]
5791 [::std::mem::offset_of!(spa_pod_builder, _padding) - 12usize];
5792 ["Offset of field: spa_pod_builder::state"]
5793 [::std::mem::offset_of!(spa_pod_builder, state) - 16usize];
5794 ["Offset of field: spa_pod_builder::callbacks"]
5795 [::std::mem::offset_of!(spa_pod_builder, callbacks) - 32usize];
5796};
5797unsafe extern "C" {
5798 #[link_name = "spa_pod_builder_get_state_libspa_rs"]
5799 pub fn spa_pod_builder_get_state(
5800 builder: *mut spa_pod_builder,
5801 state: *mut spa_pod_builder_state,
5802 );
5803}
5804unsafe extern "C" {
5805 #[link_name = "spa_pod_builder_set_callbacks_libspa_rs"]
5806 pub fn spa_pod_builder_set_callbacks(
5807 builder: *mut spa_pod_builder,
5808 callbacks: *const spa_pod_builder_callbacks,
5809 data: *mut ::std::os::raw::c_void,
5810 );
5811}
5812unsafe extern "C" {
5813 #[link_name = "spa_pod_builder_reset_libspa_rs"]
5814 pub fn spa_pod_builder_reset(builder: *mut spa_pod_builder, state: *mut spa_pod_builder_state);
5815}
5816unsafe extern "C" {
5817 #[link_name = "spa_pod_builder_init_libspa_rs"]
5818 pub fn spa_pod_builder_init(
5819 builder: *mut spa_pod_builder,
5820 data: *mut ::std::os::raw::c_void,
5821 size: u32,
5822 );
5823}
5824unsafe extern "C" {
5825 #[link_name = "spa_pod_builder_deref_libspa_rs"]
5826 pub fn spa_pod_builder_deref(builder: *mut spa_pod_builder, offset: u32) -> *mut spa_pod;
5827}
5828unsafe extern "C" {
5829 #[link_name = "spa_pod_builder_frame_libspa_rs"]
5830 pub fn spa_pod_builder_frame(
5831 builder: *mut spa_pod_builder,
5832 frame: *mut spa_pod_frame,
5833 ) -> *mut spa_pod;
5834}
5835unsafe extern "C" {
5836 #[link_name = "spa_pod_builder_push_libspa_rs"]
5837 pub fn spa_pod_builder_push(
5838 builder: *mut spa_pod_builder,
5839 frame: *mut spa_pod_frame,
5840 pod: *const spa_pod,
5841 offset: u32,
5842 );
5843}
5844unsafe extern "C" {
5845 #[link_name = "spa_pod_builder_raw_libspa_rs"]
5846 pub fn spa_pod_builder_raw(
5847 builder: *mut spa_pod_builder,
5848 data: *const ::std::os::raw::c_void,
5849 size: u32,
5850 ) -> ::std::os::raw::c_int;
5851}
5852unsafe extern "C" {
5853 #[link_name = "spa_pod_builder_pad_libspa_rs"]
5854 pub fn spa_pod_builder_pad(builder: *mut spa_pod_builder, size: u32) -> ::std::os::raw::c_int;
5855}
5856unsafe extern "C" {
5857 #[link_name = "spa_pod_builder_raw_padded_libspa_rs"]
5858 pub fn spa_pod_builder_raw_padded(
5859 builder: *mut spa_pod_builder,
5860 data: *const ::std::os::raw::c_void,
5861 size: u32,
5862 ) -> ::std::os::raw::c_int;
5863}
5864unsafe extern "C" {
5865 #[link_name = "spa_pod_builder_pop_libspa_rs"]
5866 pub fn spa_pod_builder_pop(
5867 builder: *mut spa_pod_builder,
5868 frame: *mut spa_pod_frame,
5869 ) -> *mut ::std::os::raw::c_void;
5870}
5871unsafe extern "C" {
5872 #[link_name = "spa_pod_builder_primitive_libspa_rs"]
5873 pub fn spa_pod_builder_primitive(
5874 builder: *mut spa_pod_builder,
5875 p: *const spa_pod,
5876 ) -> ::std::os::raw::c_int;
5877}
5878unsafe extern "C" {
5879 #[link_name = "spa_pod_builder_none_libspa_rs"]
5880 pub fn spa_pod_builder_none(builder: *mut spa_pod_builder) -> ::std::os::raw::c_int;
5881}
5882unsafe extern "C" {
5883 #[link_name = "spa_pod_builder_child_libspa_rs"]
5884 pub fn spa_pod_builder_child(
5885 builder: *mut spa_pod_builder,
5886 size: u32,
5887 type_: u32,
5888 ) -> ::std::os::raw::c_int;
5889}
5890unsafe extern "C" {
5891 #[link_name = "spa_pod_builder_bool_libspa_rs"]
5892 pub fn spa_pod_builder_bool(builder: *mut spa_pod_builder, val: bool) -> ::std::os::raw::c_int;
5893}
5894unsafe extern "C" {
5895 #[link_name = "spa_pod_builder_id_libspa_rs"]
5896 pub fn spa_pod_builder_id(builder: *mut spa_pod_builder, val: u32) -> ::std::os::raw::c_int;
5897}
5898unsafe extern "C" {
5899 #[link_name = "spa_pod_builder_int_libspa_rs"]
5900 pub fn spa_pod_builder_int(builder: *mut spa_pod_builder, val: i32) -> ::std::os::raw::c_int;
5901}
5902unsafe extern "C" {
5903 #[link_name = "spa_pod_builder_long_libspa_rs"]
5904 pub fn spa_pod_builder_long(builder: *mut spa_pod_builder, val: i64) -> ::std::os::raw::c_int;
5905}
5906unsafe extern "C" {
5907 #[link_name = "spa_pod_builder_float_libspa_rs"]
5908 pub fn spa_pod_builder_float(builder: *mut spa_pod_builder, val: f32) -> ::std::os::raw::c_int;
5909}
5910unsafe extern "C" {
5911 #[link_name = "spa_pod_builder_double_libspa_rs"]
5912 pub fn spa_pod_builder_double(builder: *mut spa_pod_builder, val: f64)
5913 -> ::std::os::raw::c_int;
5914}
5915unsafe extern "C" {
5916 #[link_name = "spa_pod_builder_write_string_libspa_rs"]
5917 pub fn spa_pod_builder_write_string(
5918 builder: *mut spa_pod_builder,
5919 str_: *const ::std::os::raw::c_char,
5920 len: u32,
5921 ) -> ::std::os::raw::c_int;
5922}
5923unsafe extern "C" {
5924 #[link_name = "spa_pod_builder_string_len_libspa_rs"]
5925 pub fn spa_pod_builder_string_len(
5926 builder: *mut spa_pod_builder,
5927 str_: *const ::std::os::raw::c_char,
5928 len: u32,
5929 ) -> ::std::os::raw::c_int;
5930}
5931unsafe extern "C" {
5932 #[link_name = "spa_pod_builder_string_libspa_rs"]
5933 pub fn spa_pod_builder_string(
5934 builder: *mut spa_pod_builder,
5935 str_: *const ::std::os::raw::c_char,
5936 ) -> ::std::os::raw::c_int;
5937}
5938unsafe extern "C" {
5939 #[link_name = "spa_pod_builder_bytes_libspa_rs"]
5940 pub fn spa_pod_builder_bytes(
5941 builder: *mut spa_pod_builder,
5942 bytes: *const ::std::os::raw::c_void,
5943 len: u32,
5944 ) -> ::std::os::raw::c_int;
5945}
5946unsafe extern "C" {
5947 #[link_name = "spa_pod_builder_reserve_bytes_libspa_rs"]
5948 pub fn spa_pod_builder_reserve_bytes(
5949 builder: *mut spa_pod_builder,
5950 len: u32,
5951 ) -> *mut ::std::os::raw::c_void;
5952}
5953unsafe extern "C" {
5954 #[link_name = "spa_pod_builder_bytes_start_libspa_rs"]
5955 pub fn spa_pod_builder_bytes_start(builder: *mut spa_pod_builder) -> u32;
5956}
5957unsafe extern "C" {
5958 #[link_name = "spa_pod_builder_bytes_append_libspa_rs"]
5959 pub fn spa_pod_builder_bytes_append(
5960 builder: *mut spa_pod_builder,
5961 offset: u32,
5962 data: *const ::std::os::raw::c_void,
5963 size: u32,
5964 ) -> ::std::os::raw::c_int;
5965}
5966unsafe extern "C" {
5967 #[link_name = "spa_pod_builder_bytes_end_libspa_rs"]
5968 pub fn spa_pod_builder_bytes_end(
5969 builder: *mut spa_pod_builder,
5970 offset: u32,
5971 ) -> ::std::os::raw::c_int;
5972}
5973unsafe extern "C" {
5974 #[link_name = "spa_pod_builder_pointer_libspa_rs"]
5975 pub fn spa_pod_builder_pointer(
5976 builder: *mut spa_pod_builder,
5977 type_: u32,
5978 val: *const ::std::os::raw::c_void,
5979 ) -> ::std::os::raw::c_int;
5980}
5981unsafe extern "C" {
5982 #[link_name = "spa_pod_builder_fd_libspa_rs"]
5983 pub fn spa_pod_builder_fd(builder: *mut spa_pod_builder, fd: i64) -> ::std::os::raw::c_int;
5984}
5985unsafe extern "C" {
5986 #[link_name = "spa_pod_builder_rectangle_libspa_rs"]
5987 pub fn spa_pod_builder_rectangle(
5988 builder: *mut spa_pod_builder,
5989 width: u32,
5990 height: u32,
5991 ) -> ::std::os::raw::c_int;
5992}
5993unsafe extern "C" {
5994 #[link_name = "spa_pod_builder_fraction_libspa_rs"]
5995 pub fn spa_pod_builder_fraction(
5996 builder: *mut spa_pod_builder,
5997 num: u32,
5998 denom: u32,
5999 ) -> ::std::os::raw::c_int;
6000}
6001unsafe extern "C" {
6002 #[link_name = "spa_pod_builder_push_array_libspa_rs"]
6003 pub fn spa_pod_builder_push_array(
6004 builder: *mut spa_pod_builder,
6005 frame: *mut spa_pod_frame,
6006 ) -> ::std::os::raw::c_int;
6007}
6008unsafe extern "C" {
6009 #[link_name = "spa_pod_builder_array_libspa_rs"]
6010 pub fn spa_pod_builder_array(
6011 builder: *mut spa_pod_builder,
6012 child_size: u32,
6013 child_type: u32,
6014 n_elems: u32,
6015 elems: *const ::std::os::raw::c_void,
6016 ) -> ::std::os::raw::c_int;
6017}
6018unsafe extern "C" {
6019 #[link_name = "spa_pod_builder_push_choice_libspa_rs"]
6020 pub fn spa_pod_builder_push_choice(
6021 builder: *mut spa_pod_builder,
6022 frame: *mut spa_pod_frame,
6023 type_: u32,
6024 flags: u32,
6025 ) -> ::std::os::raw::c_int;
6026}
6027unsafe extern "C" {
6028 #[link_name = "spa_pod_builder_push_struct_libspa_rs"]
6029 pub fn spa_pod_builder_push_struct(
6030 builder: *mut spa_pod_builder,
6031 frame: *mut spa_pod_frame,
6032 ) -> ::std::os::raw::c_int;
6033}
6034unsafe extern "C" {
6035 #[link_name = "spa_pod_builder_push_object_libspa_rs"]
6036 pub fn spa_pod_builder_push_object(
6037 builder: *mut spa_pod_builder,
6038 frame: *mut spa_pod_frame,
6039 type_: u32,
6040 id: u32,
6041 ) -> ::std::os::raw::c_int;
6042}
6043unsafe extern "C" {
6044 #[link_name = "spa_pod_builder_prop_libspa_rs"]
6045 pub fn spa_pod_builder_prop(
6046 builder: *mut spa_pod_builder,
6047 key: u32,
6048 flags: u32,
6049 ) -> ::std::os::raw::c_int;
6050}
6051unsafe extern "C" {
6052 #[link_name = "spa_pod_builder_push_sequence_libspa_rs"]
6053 pub fn spa_pod_builder_push_sequence(
6054 builder: *mut spa_pod_builder,
6055 frame: *mut spa_pod_frame,
6056 unit: u32,
6057 ) -> ::std::os::raw::c_int;
6058}
6059unsafe extern "C" {
6060 #[link_name = "spa_pod_builder_control_libspa_rs"]
6061 pub fn spa_pod_builder_control(
6062 builder: *mut spa_pod_builder,
6063 offset: u32,
6064 type_: u32,
6065 ) -> ::std::os::raw::c_int;
6066}
6067unsafe extern "C" {
6068 #[link_name = "spa_choice_from_id_libspa_rs"]
6069 pub fn spa_choice_from_id(id: ::std::os::raw::c_char) -> u32;
6070}
6071unsafe extern "C" {
6072 #[link_name = "spa_pod_builder_addv_libspa_rs"]
6073 pub fn spa_pod_builder_addv(
6074 builder: *mut spa_pod_builder,
6075 args: *mut __va_list_tag,
6076 ) -> ::std::os::raw::c_int;
6077}
6078unsafe extern "C" {
6079 #[doc = " Copy a pod structure"]
6080 #[link_name = "spa_pod_copy_libspa_rs"]
6081 pub fn spa_pod_copy(pod: *const spa_pod) -> *mut spa_pod;
6082}
6083#[doc = " \\addtogroup spa_device\n \\{"]
6084#[repr(C)]
6085#[derive(Debug, Copy, Clone, PartialEq, Eq)]
6086pub struct spa_result_device_params_data {
6087 pub builder: *mut spa_pod_builder,
6088 pub data: spa_result_device_params,
6089}
6090#[allow(clippy::unnecessary_operation, clippy::identity_op)]
6091const _: () = {
6092 ["Size of spa_result_device_params_data"]
6093 [::std::mem::size_of::<spa_result_device_params_data>() - 32usize];
6094 ["Alignment of spa_result_device_params_data"]
6095 [::std::mem::align_of::<spa_result_device_params_data>() - 8usize];
6096 ["Offset of field: spa_result_device_params_data::builder"]
6097 [::std::mem::offset_of!(spa_result_device_params_data, builder) - 0usize];
6098 ["Offset of field: spa_result_device_params_data::data"]
6099 [::std::mem::offset_of!(spa_result_device_params_data, data) - 8usize];
6100};
6101unsafe extern "C" {
6102 #[link_name = "spa_result_func_device_params_libspa_rs"]
6103 pub fn spa_result_func_device_params(
6104 data: *mut ::std::os::raw::c_void,
6105 seq: ::std::os::raw::c_int,
6106 res: ::std::os::raw::c_int,
6107 type_: u32,
6108 result: *const ::std::os::raw::c_void,
6109 );
6110}
6111unsafe extern "C" {
6112 #[link_name = "spa_device_enum_params_sync_libspa_rs"]
6113 pub fn spa_device_enum_params_sync(
6114 device: *mut spa_device,
6115 id: u32,
6116 index: *mut u32,
6117 filter: *const spa_pod,
6118 param: *mut *mut spa_pod,
6119 builder: *mut spa_pod_builder,
6120 ) -> ::std::os::raw::c_int;
6121}
6122#[repr(C)]
6123#[derive(Debug, Copy, Clone, PartialEq, Eq)]
6124pub struct spa_result_node_params_data {
6125 pub builder: *mut spa_pod_builder,
6126 pub data: spa_result_node_params,
6127}
6128#[allow(clippy::unnecessary_operation, clippy::identity_op)]
6129const _: () = {
6130 ["Size of spa_result_node_params_data"]
6131 [::std::mem::size_of::<spa_result_node_params_data>() - 32usize];
6132 ["Alignment of spa_result_node_params_data"]
6133 [::std::mem::align_of::<spa_result_node_params_data>() - 8usize];
6134 ["Offset of field: spa_result_node_params_data::builder"]
6135 [::std::mem::offset_of!(spa_result_node_params_data, builder) - 0usize];
6136 ["Offset of field: spa_result_node_params_data::data"]
6137 [::std::mem::offset_of!(spa_result_node_params_data, data) - 8usize];
6138};
6139unsafe extern "C" {
6140 #[link_name = "spa_result_func_node_params_libspa_rs"]
6141 pub fn spa_result_func_node_params(
6142 data: *mut ::std::os::raw::c_void,
6143 seq: ::std::os::raw::c_int,
6144 res: ::std::os::raw::c_int,
6145 type_: u32,
6146 result: *const ::std::os::raw::c_void,
6147 );
6148}
6149unsafe extern "C" {
6150 #[link_name = "spa_node_enum_params_sync_libspa_rs"]
6151 pub fn spa_node_enum_params_sync(
6152 node: *mut spa_node,
6153 id: u32,
6154 index: *mut u32,
6155 filter: *const spa_pod,
6156 param: *mut *mut spa_pod,
6157 builder: *mut spa_pod_builder,
6158 ) -> ::std::os::raw::c_int;
6159}
6160unsafe extern "C" {
6161 #[link_name = "spa_node_port_enum_params_sync_libspa_rs"]
6162 pub fn spa_node_port_enum_params_sync(
6163 node: *mut spa_node,
6164 direction: spa_direction,
6165 port_id: u32,
6166 id: u32,
6167 index: *mut u32,
6168 filter: *const spa_pod,
6169 param: *mut *mut spa_pod,
6170 builder: *mut spa_pod_builder,
6171 ) -> ::std::os::raw::c_int;
6172}
6173unsafe extern "C" {
6174 #[link_name = "spa_latency_info_compare_libspa_rs"]
6175 pub fn spa_latency_info_compare(
6176 a: *const spa_latency_info,
6177 b: *const spa_latency_info,
6178 ) -> ::std::os::raw::c_int;
6179}
6180unsafe extern "C" {
6181 #[link_name = "spa_latency_info_combine_start_libspa_rs"]
6182 pub fn spa_latency_info_combine_start(info: *mut spa_latency_info, direction: spa_direction);
6183}
6184unsafe extern "C" {
6185 #[link_name = "spa_latency_info_combine_finish_libspa_rs"]
6186 pub fn spa_latency_info_combine_finish(info: *mut spa_latency_info);
6187}
6188unsafe extern "C" {
6189 #[link_name = "spa_latency_info_combine_libspa_rs"]
6190 pub fn spa_latency_info_combine(
6191 info: *mut spa_latency_info,
6192 other: *const spa_latency_info,
6193 ) -> ::std::os::raw::c_int;
6194}
6195unsafe extern "C" {
6196 #[link_name = "spa_latency_parse_libspa_rs"]
6197 pub fn spa_latency_parse(
6198 latency: *const spa_pod,
6199 info: *mut spa_latency_info,
6200 ) -> ::std::os::raw::c_int;
6201}
6202unsafe extern "C" {
6203 #[link_name = "spa_latency_build_libspa_rs"]
6204 pub fn spa_latency_build(
6205 builder: *mut spa_pod_builder,
6206 id: u32,
6207 info: *const spa_latency_info,
6208 ) -> *mut spa_pod;
6209}
6210unsafe extern "C" {
6211 #[link_name = "spa_process_latency_parse_libspa_rs"]
6212 pub fn spa_process_latency_parse(
6213 latency: *const spa_pod,
6214 info: *mut spa_process_latency_info,
6215 ) -> ::std::os::raw::c_int;
6216}
6217unsafe extern "C" {
6218 #[link_name = "spa_process_latency_build_libspa_rs"]
6219 pub fn spa_process_latency_build(
6220 builder: *mut spa_pod_builder,
6221 id: u32,
6222 info: *const spa_process_latency_info,
6223 ) -> *mut spa_pod;
6224}
6225unsafe extern "C" {
6226 #[link_name = "spa_process_latency_info_add_libspa_rs"]
6227 pub fn spa_process_latency_info_add(
6228 process: *const spa_process_latency_info,
6229 info: *mut spa_latency_info,
6230 ) -> ::std::os::raw::c_int;
6231}
6232unsafe extern "C" {
6233 #[link_name = "spa_process_latency_info_compare_libspa_rs"]
6234 pub fn spa_process_latency_info_compare(
6235 a: *const spa_process_latency_info,
6236 b: *const spa_process_latency_info,
6237 ) -> ::std::os::raw::c_int;
6238}
6239#[repr(C)]
6240#[derive(Debug, Copy, Clone, PartialEq, Eq)]
6241pub struct spa_audio_info_dsd {
6242 pub bitorder: spa_param_bitorder,
6243 pub flags: u32,
6244 pub interleave: i32,
6245 pub rate: u32,
6246 pub channels: u32,
6247 pub position: [u32; 64usize],
6248}
6249#[allow(clippy::unnecessary_operation, clippy::identity_op)]
6250const _: () = {
6251 ["Size of spa_audio_info_dsd"][::std::mem::size_of::<spa_audio_info_dsd>() - 276usize];
6252 ["Alignment of spa_audio_info_dsd"][::std::mem::align_of::<spa_audio_info_dsd>() - 4usize];
6253 ["Offset of field: spa_audio_info_dsd::bitorder"]
6254 [::std::mem::offset_of!(spa_audio_info_dsd, bitorder) - 0usize];
6255 ["Offset of field: spa_audio_info_dsd::flags"]
6256 [::std::mem::offset_of!(spa_audio_info_dsd, flags) - 4usize];
6257 ["Offset of field: spa_audio_info_dsd::interleave"]
6258 [::std::mem::offset_of!(spa_audio_info_dsd, interleave) - 8usize];
6259 ["Offset of field: spa_audio_info_dsd::rate"]
6260 [::std::mem::offset_of!(spa_audio_info_dsd, rate) - 12usize];
6261 ["Offset of field: spa_audio_info_dsd::channels"]
6262 [::std::mem::offset_of!(spa_audio_info_dsd, channels) - 16usize];
6263 ["Offset of field: spa_audio_info_dsd::position"]
6264 [::std::mem::offset_of!(spa_audio_info_dsd, position) - 20usize];
6265};
6266#[doc = " \\addtogroup spa_param\n \\{"]
6267#[repr(C)]
6268#[derive(Debug, Copy, Clone, PartialEq, Eq)]
6269pub struct spa_audio_info_dsp {
6270 pub format: spa_audio_format,
6271}
6272#[allow(clippy::unnecessary_operation, clippy::identity_op)]
6273const _: () = {
6274 ["Size of spa_audio_info_dsp"][::std::mem::size_of::<spa_audio_info_dsp>() - 4usize];
6275 ["Alignment of spa_audio_info_dsp"][::std::mem::align_of::<spa_audio_info_dsp>() - 4usize];
6276 ["Offset of field: spa_audio_info_dsp::format"]
6277 [::std::mem::offset_of!(spa_audio_info_dsp, format) - 0usize];
6278};
6279#[doc = " \\addtogroup spa_param\n \\{"]
6280#[repr(C)]
6281#[derive(Debug, Copy, Clone, PartialEq, Eq)]
6282pub struct spa_audio_info_vorbis {
6283 pub rate: u32,
6284 pub channels: u32,
6285}
6286#[allow(clippy::unnecessary_operation, clippy::identity_op)]
6287const _: () = {
6288 ["Size of spa_audio_info_vorbis"][::std::mem::size_of::<spa_audio_info_vorbis>() - 8usize];
6289 ["Alignment of spa_audio_info_vorbis"]
6290 [::std::mem::align_of::<spa_audio_info_vorbis>() - 4usize];
6291 ["Offset of field: spa_audio_info_vorbis::rate"]
6292 [::std::mem::offset_of!(spa_audio_info_vorbis, rate) - 0usize];
6293 ["Offset of field: spa_audio_info_vorbis::channels"]
6294 [::std::mem::offset_of!(spa_audio_info_vorbis, channels) - 4usize];
6295};
6296#[doc = " \\addtogroup spa_param\n \\{"]
6297#[repr(C)]
6298#[derive(Debug, Copy, Clone, PartialEq, Eq)]
6299pub struct spa_audio_info_ra {
6300 pub rate: u32,
6301 pub channels: u32,
6302}
6303#[allow(clippy::unnecessary_operation, clippy::identity_op)]
6304const _: () = {
6305 ["Size of spa_audio_info_ra"][::std::mem::size_of::<spa_audio_info_ra>() - 8usize];
6306 ["Alignment of spa_audio_info_ra"][::std::mem::align_of::<spa_audio_info_ra>() - 4usize];
6307 ["Offset of field: spa_audio_info_ra::rate"]
6308 [::std::mem::offset_of!(spa_audio_info_ra, rate) - 0usize];
6309 ["Offset of field: spa_audio_info_ra::channels"]
6310 [::std::mem::offset_of!(spa_audio_info_ra, channels) - 4usize];
6311};
6312#[doc = " \\addtogroup spa_param\n \\{"]
6313#[repr(C)]
6314#[derive(Debug, Copy, Clone, PartialEq, Eq)]
6315pub struct spa_audio_info_alac {
6316 pub rate: u32,
6317 pub channels: u32,
6318}
6319#[allow(clippy::unnecessary_operation, clippy::identity_op)]
6320const _: () = {
6321 ["Size of spa_audio_info_alac"][::std::mem::size_of::<spa_audio_info_alac>() - 8usize];
6322 ["Alignment of spa_audio_info_alac"][::std::mem::align_of::<spa_audio_info_alac>() - 4usize];
6323 ["Offset of field: spa_audio_info_alac::rate"]
6324 [::std::mem::offset_of!(spa_audio_info_alac, rate) - 0usize];
6325 ["Offset of field: spa_audio_info_alac::channels"]
6326 [::std::mem::offset_of!(spa_audio_info_alac, channels) - 4usize];
6327};
6328#[doc = " \\addtogroup spa_param\n \\{"]
6329#[repr(C)]
6330#[derive(Debug, Copy, Clone, PartialEq, Eq)]
6331pub struct spa_audio_info_flac {
6332 pub rate: u32,
6333 pub channels: u32,
6334}
6335#[allow(clippy::unnecessary_operation, clippy::identity_op)]
6336const _: () = {
6337 ["Size of spa_audio_info_flac"][::std::mem::size_of::<spa_audio_info_flac>() - 8usize];
6338 ["Alignment of spa_audio_info_flac"][::std::mem::align_of::<spa_audio_info_flac>() - 4usize];
6339 ["Offset of field: spa_audio_info_flac::rate"]
6340 [::std::mem::offset_of!(spa_audio_info_flac, rate) - 0usize];
6341 ["Offset of field: spa_audio_info_flac::channels"]
6342 [::std::mem::offset_of!(spa_audio_info_flac, channels) - 4usize];
6343};
6344#[doc = " \\addtogroup spa_param\n \\{"]
6345#[repr(C)]
6346#[derive(Debug, Copy, Clone, PartialEq, Eq)]
6347pub struct spa_audio_info_ape {
6348 pub rate: u32,
6349 pub channels: u32,
6350}
6351#[allow(clippy::unnecessary_operation, clippy::identity_op)]
6352const _: () = {
6353 ["Size of spa_audio_info_ape"][::std::mem::size_of::<spa_audio_info_ape>() - 8usize];
6354 ["Alignment of spa_audio_info_ape"][::std::mem::align_of::<spa_audio_info_ape>() - 4usize];
6355 ["Offset of field: spa_audio_info_ape::rate"]
6356 [::std::mem::offset_of!(spa_audio_info_ape, rate) - 0usize];
6357 ["Offset of field: spa_audio_info_ape::channels"]
6358 [::std::mem::offset_of!(spa_audio_info_ape, channels) - 4usize];
6359};
6360#[doc = " \\addtogroup spa_param\n \\{"]
6361#[repr(C)]
6362#[derive(Debug, Copy, Clone, PartialEq, Eq)]
6363pub struct spa_audio_info_opus {
6364 pub rate: u32,
6365 pub channels: u32,
6366}
6367#[allow(clippy::unnecessary_operation, clippy::identity_op)]
6368const _: () = {
6369 ["Size of spa_audio_info_opus"][::std::mem::size_of::<spa_audio_info_opus>() - 8usize];
6370 ["Alignment of spa_audio_info_opus"][::std::mem::align_of::<spa_audio_info_opus>() - 4usize];
6371 ["Offset of field: spa_audio_info_opus::rate"]
6372 [::std::mem::offset_of!(spa_audio_info_opus, rate) - 0usize];
6373 ["Offset of field: spa_audio_info_opus::channels"]
6374 [::std::mem::offset_of!(spa_audio_info_opus, channels) - 4usize];
6375};
6376#[repr(C)]
6377#[derive(Copy, Clone)]
6378pub struct spa_audio_info {
6379 pub media_type: u32,
6380 pub media_subtype: u32,
6381 pub info: spa_audio_info__bindgen_ty_1,
6382}
6383#[repr(C)]
6384#[derive(Copy, Clone)]
6385pub union spa_audio_info__bindgen_ty_1 {
6386 pub raw: spa_audio_info_raw,
6387 pub dsp: spa_audio_info_dsp,
6388 pub iec958: spa_audio_info_iec958,
6389 pub dsd: spa_audio_info_dsd,
6390 pub mp3: spa_audio_info_mp3,
6391 pub aac: spa_audio_info_aac,
6392 pub vorbis: spa_audio_info_vorbis,
6393 pub wma: spa_audio_info_wma,
6394 pub ra: spa_audio_info_ra,
6395 pub amr: spa_audio_info_amr,
6396 pub alac: spa_audio_info_alac,
6397 pub flac: spa_audio_info_flac,
6398 pub ape: spa_audio_info_ape,
6399 pub opus: spa_audio_info_ape,
6400}
6401#[allow(clippy::unnecessary_operation, clippy::identity_op)]
6402const _: () = {
6403 ["Size of spa_audio_info__bindgen_ty_1"]
6404 [::std::mem::size_of::<spa_audio_info__bindgen_ty_1>() - 276usize];
6405 ["Alignment of spa_audio_info__bindgen_ty_1"]
6406 [::std::mem::align_of::<spa_audio_info__bindgen_ty_1>() - 4usize];
6407 ["Offset of field: spa_audio_info__bindgen_ty_1::raw"]
6408 [::std::mem::offset_of!(spa_audio_info__bindgen_ty_1, raw) - 0usize];
6409 ["Offset of field: spa_audio_info__bindgen_ty_1::dsp"]
6410 [::std::mem::offset_of!(spa_audio_info__bindgen_ty_1, dsp) - 0usize];
6411 ["Offset of field: spa_audio_info__bindgen_ty_1::iec958"]
6412 [::std::mem::offset_of!(spa_audio_info__bindgen_ty_1, iec958) - 0usize];
6413 ["Offset of field: spa_audio_info__bindgen_ty_1::dsd"]
6414 [::std::mem::offset_of!(spa_audio_info__bindgen_ty_1, dsd) - 0usize];
6415 ["Offset of field: spa_audio_info__bindgen_ty_1::mp3"]
6416 [::std::mem::offset_of!(spa_audio_info__bindgen_ty_1, mp3) - 0usize];
6417 ["Offset of field: spa_audio_info__bindgen_ty_1::aac"]
6418 [::std::mem::offset_of!(spa_audio_info__bindgen_ty_1, aac) - 0usize];
6419 ["Offset of field: spa_audio_info__bindgen_ty_1::vorbis"]
6420 [::std::mem::offset_of!(spa_audio_info__bindgen_ty_1, vorbis) - 0usize];
6421 ["Offset of field: spa_audio_info__bindgen_ty_1::wma"]
6422 [::std::mem::offset_of!(spa_audio_info__bindgen_ty_1, wma) - 0usize];
6423 ["Offset of field: spa_audio_info__bindgen_ty_1::ra"]
6424 [::std::mem::offset_of!(spa_audio_info__bindgen_ty_1, ra) - 0usize];
6425 ["Offset of field: spa_audio_info__bindgen_ty_1::amr"]
6426 [::std::mem::offset_of!(spa_audio_info__bindgen_ty_1, amr) - 0usize];
6427 ["Offset of field: spa_audio_info__bindgen_ty_1::alac"]
6428 [::std::mem::offset_of!(spa_audio_info__bindgen_ty_1, alac) - 0usize];
6429 ["Offset of field: spa_audio_info__bindgen_ty_1::flac"]
6430 [::std::mem::offset_of!(spa_audio_info__bindgen_ty_1, flac) - 0usize];
6431 ["Offset of field: spa_audio_info__bindgen_ty_1::ape"]
6432 [::std::mem::offset_of!(spa_audio_info__bindgen_ty_1, ape) - 0usize];
6433 ["Offset of field: spa_audio_info__bindgen_ty_1::opus"]
6434 [::std::mem::offset_of!(spa_audio_info__bindgen_ty_1, opus) - 0usize];
6435};
6436#[allow(clippy::unnecessary_operation, clippy::identity_op)]
6437const _: () = {
6438 ["Size of spa_audio_info"][::std::mem::size_of::<spa_audio_info>() - 284usize];
6439 ["Alignment of spa_audio_info"][::std::mem::align_of::<spa_audio_info>() - 4usize];
6440 ["Offset of field: spa_audio_info::media_type"]
6441 [::std::mem::offset_of!(spa_audio_info, media_type) - 0usize];
6442 ["Offset of field: spa_audio_info::media_subtype"]
6443 [::std::mem::offset_of!(spa_audio_info, media_subtype) - 4usize];
6444 ["Offset of field: spa_audio_info::info"]
6445 [::std::mem::offset_of!(spa_audio_info, info) - 8usize];
6446};
6447unsafe extern "C" {
6448 #[link_name = "spa_format_audio_raw_parse_libspa_rs"]
6449 pub fn spa_format_audio_raw_parse(
6450 format: *const spa_pod,
6451 info: *mut spa_audio_info_raw,
6452 ) -> ::std::os::raw::c_int;
6453}
6454unsafe extern "C" {
6455 #[link_name = "spa_format_audio_raw_build_libspa_rs"]
6456 pub fn spa_format_audio_raw_build(
6457 builder: *mut spa_pod_builder,
6458 id: u32,
6459 info: *const spa_audio_info_raw,
6460 ) -> *mut spa_pod;
6461}
6462unsafe extern "C" {
6463 #[link_name = "spa_format_audio_dsp_parse_libspa_rs"]
6464 pub fn spa_format_audio_dsp_parse(
6465 format: *const spa_pod,
6466 info: *mut spa_audio_info_dsp,
6467 ) -> ::std::os::raw::c_int;
6468}
6469unsafe extern "C" {
6470 #[link_name = "spa_format_audio_dsp_build_libspa_rs"]
6471 pub fn spa_format_audio_dsp_build(
6472 builder: *mut spa_pod_builder,
6473 id: u32,
6474 info: *const spa_audio_info_dsp,
6475 ) -> *mut spa_pod;
6476}
6477unsafe extern "C" {
6478 #[link_name = "spa_format_audio_iec958_parse_libspa_rs"]
6479 pub fn spa_format_audio_iec958_parse(
6480 format: *const spa_pod,
6481 info: *mut spa_audio_info_iec958,
6482 ) -> ::std::os::raw::c_int;
6483}
6484unsafe extern "C" {
6485 #[link_name = "spa_format_audio_iec958_build_libspa_rs"]
6486 pub fn spa_format_audio_iec958_build(
6487 builder: *mut spa_pod_builder,
6488 id: u32,
6489 info: *const spa_audio_info_iec958,
6490 ) -> *mut spa_pod;
6491}
6492unsafe extern "C" {
6493 #[link_name = "spa_format_audio_dsd_parse_libspa_rs"]
6494 pub fn spa_format_audio_dsd_parse(
6495 format: *const spa_pod,
6496 info: *mut spa_audio_info_dsd,
6497 ) -> ::std::os::raw::c_int;
6498}
6499unsafe extern "C" {
6500 #[link_name = "spa_format_audio_dsd_build_libspa_rs"]
6501 pub fn spa_format_audio_dsd_build(
6502 builder: *mut spa_pod_builder,
6503 id: u32,
6504 info: *const spa_audio_info_dsd,
6505 ) -> *mut spa_pod;
6506}
6507unsafe extern "C" {
6508 #[link_name = "spa_format_audio_mp3_parse_libspa_rs"]
6509 pub fn spa_format_audio_mp3_parse(
6510 format: *const spa_pod,
6511 info: *mut spa_audio_info_mp3,
6512 ) -> ::std::os::raw::c_int;
6513}
6514unsafe extern "C" {
6515 #[link_name = "spa_format_audio_mp3_build_libspa_rs"]
6516 pub fn spa_format_audio_mp3_build(
6517 builder: *mut spa_pod_builder,
6518 id: u32,
6519 info: *const spa_audio_info_mp3,
6520 ) -> *mut spa_pod;
6521}
6522unsafe extern "C" {
6523 #[link_name = "spa_format_audio_aac_parse_libspa_rs"]
6524 pub fn spa_format_audio_aac_parse(
6525 format: *const spa_pod,
6526 info: *mut spa_audio_info_aac,
6527 ) -> ::std::os::raw::c_int;
6528}
6529unsafe extern "C" {
6530 #[link_name = "spa_format_audio_aac_build_libspa_rs"]
6531 pub fn spa_format_audio_aac_build(
6532 builder: *mut spa_pod_builder,
6533 id: u32,
6534 info: *const spa_audio_info_aac,
6535 ) -> *mut spa_pod;
6536}
6537unsafe extern "C" {
6538 #[link_name = "spa_format_audio_vorbis_parse_libspa_rs"]
6539 pub fn spa_format_audio_vorbis_parse(
6540 format: *const spa_pod,
6541 info: *mut spa_audio_info_vorbis,
6542 ) -> ::std::os::raw::c_int;
6543}
6544unsafe extern "C" {
6545 #[link_name = "spa_format_audio_vorbis_build_libspa_rs"]
6546 pub fn spa_format_audio_vorbis_build(
6547 builder: *mut spa_pod_builder,
6548 id: u32,
6549 info: *const spa_audio_info_vorbis,
6550 ) -> *mut spa_pod;
6551}
6552unsafe extern "C" {
6553 #[link_name = "spa_format_audio_wma_parse_libspa_rs"]
6554 pub fn spa_format_audio_wma_parse(
6555 format: *const spa_pod,
6556 info: *mut spa_audio_info_wma,
6557 ) -> ::std::os::raw::c_int;
6558}
6559unsafe extern "C" {
6560 #[link_name = "spa_format_audio_wma_build_libspa_rs"]
6561 pub fn spa_format_audio_wma_build(
6562 builder: *mut spa_pod_builder,
6563 id: u32,
6564 info: *const spa_audio_info_wma,
6565 ) -> *mut spa_pod;
6566}
6567unsafe extern "C" {
6568 #[link_name = "spa_format_audio_ra_parse_libspa_rs"]
6569 pub fn spa_format_audio_ra_parse(
6570 format: *const spa_pod,
6571 info: *mut spa_audio_info_ra,
6572 ) -> ::std::os::raw::c_int;
6573}
6574unsafe extern "C" {
6575 #[link_name = "spa_format_audio_ra_build_libspa_rs"]
6576 pub fn spa_format_audio_ra_build(
6577 builder: *mut spa_pod_builder,
6578 id: u32,
6579 info: *const spa_audio_info_ra,
6580 ) -> *mut spa_pod;
6581}
6582unsafe extern "C" {
6583 #[link_name = "spa_format_audio_amr_parse_libspa_rs"]
6584 pub fn spa_format_audio_amr_parse(
6585 format: *const spa_pod,
6586 info: *mut spa_audio_info_amr,
6587 ) -> ::std::os::raw::c_int;
6588}
6589unsafe extern "C" {
6590 #[link_name = "spa_format_audio_amr_build_libspa_rs"]
6591 pub fn spa_format_audio_amr_build(
6592 builder: *mut spa_pod_builder,
6593 id: u32,
6594 info: *const spa_audio_info_amr,
6595 ) -> *mut spa_pod;
6596}
6597unsafe extern "C" {
6598 #[link_name = "spa_format_audio_alac_parse_libspa_rs"]
6599 pub fn spa_format_audio_alac_parse(
6600 format: *const spa_pod,
6601 info: *mut spa_audio_info_alac,
6602 ) -> ::std::os::raw::c_int;
6603}
6604unsafe extern "C" {
6605 #[link_name = "spa_format_audio_alac_build_libspa_rs"]
6606 pub fn spa_format_audio_alac_build(
6607 builder: *mut spa_pod_builder,
6608 id: u32,
6609 info: *const spa_audio_info_alac,
6610 ) -> *mut spa_pod;
6611}
6612unsafe extern "C" {
6613 #[link_name = "spa_format_audio_flac_parse_libspa_rs"]
6614 pub fn spa_format_audio_flac_parse(
6615 format: *const spa_pod,
6616 info: *mut spa_audio_info_flac,
6617 ) -> ::std::os::raw::c_int;
6618}
6619unsafe extern "C" {
6620 #[link_name = "spa_format_audio_flac_build_libspa_rs"]
6621 pub fn spa_format_audio_flac_build(
6622 builder: *mut spa_pod_builder,
6623 id: u32,
6624 info: *const spa_audio_info_flac,
6625 ) -> *mut spa_pod;
6626}
6627unsafe extern "C" {
6628 #[link_name = "spa_format_audio_ape_parse_libspa_rs"]
6629 pub fn spa_format_audio_ape_parse(
6630 format: *const spa_pod,
6631 info: *mut spa_audio_info_ape,
6632 ) -> ::std::os::raw::c_int;
6633}
6634unsafe extern "C" {
6635 #[link_name = "spa_format_audio_ape_build_libspa_rs"]
6636 pub fn spa_format_audio_ape_build(
6637 builder: *mut spa_pod_builder,
6638 id: u32,
6639 info: *const spa_audio_info_ape,
6640 ) -> *mut spa_pod;
6641}
6642unsafe extern "C" {
6643 #[link_name = "spa_format_audio_parse_libspa_rs"]
6644 pub fn spa_format_audio_parse(
6645 format: *const spa_pod,
6646 info: *mut spa_audio_info,
6647 ) -> ::std::os::raw::c_int;
6648}
6649unsafe extern "C" {
6650 #[link_name = "spa_format_audio_build_libspa_rs"]
6651 pub fn spa_format_audio_build(
6652 builder: *mut spa_pod_builder,
6653 id: u32,
6654 info: *const spa_audio_info,
6655 ) -> *mut spa_pod;
6656}
6657#[repr(C)]
6658#[derive(Debug, Copy, Clone, PartialEq, Eq)]
6659pub struct spa_audio_layout_info {
6660 pub n_channels: u32,
6661 pub position: [u32; 64usize],
6662}
6663#[allow(clippy::unnecessary_operation, clippy::identity_op)]
6664const _: () = {
6665 ["Size of spa_audio_layout_info"][::std::mem::size_of::<spa_audio_layout_info>() - 260usize];
6666 ["Alignment of spa_audio_layout_info"]
6667 [::std::mem::align_of::<spa_audio_layout_info>() - 4usize];
6668 ["Offset of field: spa_audio_layout_info::n_channels"]
6669 [::std::mem::offset_of!(spa_audio_layout_info, n_channels) - 0usize];
6670 ["Offset of field: spa_audio_layout_info::position"]
6671 [::std::mem::offset_of!(spa_audio_layout_info, position) - 4usize];
6672};
6673pub const SPA_H264_STREAM_FORMAT_UNKNOWN: spa_h264_stream_format = 0;
6674pub const SPA_H264_STREAM_FORMAT_AVC: spa_h264_stream_format = 1;
6675pub const SPA_H264_STREAM_FORMAT_AVC3: spa_h264_stream_format = 2;
6676pub const SPA_H264_STREAM_FORMAT_BYTESTREAM: spa_h264_stream_format = 3;
6677pub type spa_h264_stream_format = ::std::os::raw::c_uint;
6678pub const SPA_H264_ALIGNMENT_UNKNOWN: spa_h264_alignment = 0;
6679pub const SPA_H264_ALIGNMENT_AU: spa_h264_alignment = 1;
6680pub const SPA_H264_ALIGNMENT_NAL: spa_h264_alignment = 2;
6681pub type spa_h264_alignment = ::std::os::raw::c_uint;
6682#[repr(C)]
6683#[derive(Debug, Copy, Clone, PartialEq, Eq)]
6684pub struct spa_video_info_h264 {
6685 pub size: spa_rectangle,
6686 pub framerate: spa_fraction,
6687 pub max_framerate: spa_fraction,
6688 pub stream_format: spa_h264_stream_format,
6689 pub alignment: spa_h264_alignment,
6690}
6691#[allow(clippy::unnecessary_operation, clippy::identity_op)]
6692const _: () = {
6693 ["Size of spa_video_info_h264"][::std::mem::size_of::<spa_video_info_h264>() - 32usize];
6694 ["Alignment of spa_video_info_h264"][::std::mem::align_of::<spa_video_info_h264>() - 4usize];
6695 ["Offset of field: spa_video_info_h264::size"]
6696 [::std::mem::offset_of!(spa_video_info_h264, size) - 0usize];
6697 ["Offset of field: spa_video_info_h264::framerate"]
6698 [::std::mem::offset_of!(spa_video_info_h264, framerate) - 8usize];
6699 ["Offset of field: spa_video_info_h264::max_framerate"]
6700 [::std::mem::offset_of!(spa_video_info_h264, max_framerate) - 16usize];
6701 ["Offset of field: spa_video_info_h264::stream_format"]
6702 [::std::mem::offset_of!(spa_video_info_h264, stream_format) - 24usize];
6703 ["Offset of field: spa_video_info_h264::alignment"]
6704 [::std::mem::offset_of!(spa_video_info_h264, alignment) - 28usize];
6705};
6706#[repr(C)]
6707#[derive(Debug, Copy, Clone, PartialEq, Eq)]
6708pub struct spa_video_info_mjpg {
6709 pub size: spa_rectangle,
6710 pub framerate: spa_fraction,
6711 pub max_framerate: spa_fraction,
6712}
6713#[allow(clippy::unnecessary_operation, clippy::identity_op)]
6714const _: () = {
6715 ["Size of spa_video_info_mjpg"][::std::mem::size_of::<spa_video_info_mjpg>() - 24usize];
6716 ["Alignment of spa_video_info_mjpg"][::std::mem::align_of::<spa_video_info_mjpg>() - 4usize];
6717 ["Offset of field: spa_video_info_mjpg::size"]
6718 [::std::mem::offset_of!(spa_video_info_mjpg, size) - 0usize];
6719 ["Offset of field: spa_video_info_mjpg::framerate"]
6720 [::std::mem::offset_of!(spa_video_info_mjpg, framerate) - 8usize];
6721 ["Offset of field: spa_video_info_mjpg::max_framerate"]
6722 [::std::mem::offset_of!(spa_video_info_mjpg, max_framerate) - 16usize];
6723};
6724#[repr(C)]
6725#[derive(Debug, Copy, Clone, PartialEq, Eq)]
6726pub struct spa_video_info_dsp {
6727 pub format: spa_video_format,
6728 pub flags: u32,
6729 pub modifier: u64,
6730}
6731#[allow(clippy::unnecessary_operation, clippy::identity_op)]
6732const _: () = {
6733 ["Size of spa_video_info_dsp"][::std::mem::size_of::<spa_video_info_dsp>() - 16usize];
6734 ["Alignment of spa_video_info_dsp"][::std::mem::align_of::<spa_video_info_dsp>() - 8usize];
6735 ["Offset of field: spa_video_info_dsp::format"]
6736 [::std::mem::offset_of!(spa_video_info_dsp, format) - 0usize];
6737 ["Offset of field: spa_video_info_dsp::flags"]
6738 [::std::mem::offset_of!(spa_video_info_dsp, flags) - 4usize];
6739 ["Offset of field: spa_video_info_dsp::modifier"]
6740 [::std::mem::offset_of!(spa_video_info_dsp, modifier) - 8usize];
6741};
6742#[repr(C)]
6743#[derive(Copy, Clone)]
6744pub struct spa_video_info {
6745 pub media_type: u32,
6746 pub media_subtype: u32,
6747 pub info: spa_video_info__bindgen_ty_1,
6748}
6749#[repr(C)]
6750#[derive(Copy, Clone)]
6751pub union spa_video_info__bindgen_ty_1 {
6752 pub raw: spa_video_info_raw,
6753 pub dsp: spa_video_info_dsp,
6754 pub h264: spa_video_info_h264,
6755 pub mjpg: spa_video_info_mjpg,
6756}
6757#[allow(clippy::unnecessary_operation, clippy::identity_op)]
6758const _: () = {
6759 ["Size of spa_video_info__bindgen_ty_1"]
6760 [::std::mem::size_of::<spa_video_info__bindgen_ty_1>() - 88usize];
6761 ["Alignment of spa_video_info__bindgen_ty_1"]
6762 [::std::mem::align_of::<spa_video_info__bindgen_ty_1>() - 8usize];
6763 ["Offset of field: spa_video_info__bindgen_ty_1::raw"]
6764 [::std::mem::offset_of!(spa_video_info__bindgen_ty_1, raw) - 0usize];
6765 ["Offset of field: spa_video_info__bindgen_ty_1::dsp"]
6766 [::std::mem::offset_of!(spa_video_info__bindgen_ty_1, dsp) - 0usize];
6767 ["Offset of field: spa_video_info__bindgen_ty_1::h264"]
6768 [::std::mem::offset_of!(spa_video_info__bindgen_ty_1, h264) - 0usize];
6769 ["Offset of field: spa_video_info__bindgen_ty_1::mjpg"]
6770 [::std::mem::offset_of!(spa_video_info__bindgen_ty_1, mjpg) - 0usize];
6771};
6772#[allow(clippy::unnecessary_operation, clippy::identity_op)]
6773const _: () = {
6774 ["Size of spa_video_info"][::std::mem::size_of::<spa_video_info>() - 96usize];
6775 ["Alignment of spa_video_info"][::std::mem::align_of::<spa_video_info>() - 8usize];
6776 ["Offset of field: spa_video_info::media_type"]
6777 [::std::mem::offset_of!(spa_video_info, media_type) - 0usize];
6778 ["Offset of field: spa_video_info::media_subtype"]
6779 [::std::mem::offset_of!(spa_video_info, media_subtype) - 4usize];
6780 ["Offset of field: spa_video_info::info"]
6781 [::std::mem::offset_of!(spa_video_info, info) - 8usize];
6782};
6783unsafe extern "C" {
6784 #[link_name = "spa_format_video_raw_parse_libspa_rs"]
6785 pub fn spa_format_video_raw_parse(
6786 format: *const spa_pod,
6787 info: *mut spa_video_info_raw,
6788 ) -> ::std::os::raw::c_int;
6789}
6790unsafe extern "C" {
6791 #[link_name = "spa_format_video_raw_build_libspa_rs"]
6792 pub fn spa_format_video_raw_build(
6793 builder: *mut spa_pod_builder,
6794 id: u32,
6795 info: *const spa_video_info_raw,
6796 ) -> *mut spa_pod;
6797}
6798unsafe extern "C" {
6799 #[link_name = "spa_format_video_dsp_parse_libspa_rs"]
6800 pub fn spa_format_video_dsp_parse(
6801 format: *const spa_pod,
6802 info: *mut spa_video_info_dsp,
6803 ) -> ::std::os::raw::c_int;
6804}
6805unsafe extern "C" {
6806 #[link_name = "spa_format_video_dsp_build_libspa_rs"]
6807 pub fn spa_format_video_dsp_build(
6808 builder: *mut spa_pod_builder,
6809 id: u32,
6810 info: *const spa_video_info_dsp,
6811 ) -> *mut spa_pod;
6812}
6813unsafe extern "C" {
6814 #[link_name = "spa_format_video_h264_parse_libspa_rs"]
6815 pub fn spa_format_video_h264_parse(
6816 format: *const spa_pod,
6817 info: *mut spa_video_info_h264,
6818 ) -> ::std::os::raw::c_int;
6819}
6820unsafe extern "C" {
6821 #[link_name = "spa_format_video_h264_build_libspa_rs"]
6822 pub fn spa_format_video_h264_build(
6823 builder: *mut spa_pod_builder,
6824 id: u32,
6825 info: *const spa_video_info_h264,
6826 ) -> *mut spa_pod;
6827}
6828unsafe extern "C" {
6829 #[link_name = "spa_format_video_mjpg_parse_libspa_rs"]
6830 pub fn spa_format_video_mjpg_parse(
6831 format: *const spa_pod,
6832 info: *mut spa_video_info_mjpg,
6833 ) -> ::std::os::raw::c_int;
6834}
6835unsafe extern "C" {
6836 #[link_name = "spa_format_video_mjpg_build_libspa_rs"]
6837 pub fn spa_format_video_mjpg_build(
6838 builder: *mut spa_pod_builder,
6839 id: u32,
6840 info: *const spa_video_info_mjpg,
6841 ) -> *mut spa_pod;
6842}
6843unsafe extern "C" {
6844 #[link_name = "spa_format_video_parse_libspa_rs"]
6845 pub fn spa_format_video_parse(
6846 format: *const spa_pod,
6847 info: *mut spa_video_info,
6848 ) -> ::std::os::raw::c_int;
6849}
6850unsafe extern "C" {
6851 #[link_name = "spa_format_video_build_libspa_rs"]
6852 pub fn spa_format_video_build(
6853 builder: *mut spa_pod_builder,
6854 id: u32,
6855 info: *const spa_video_info,
6856 ) -> *mut spa_pod;
6857}
6858unsafe extern "C" {
6859 #[doc = " \\addtogroup spa_pod\n \\{"]
6860 #[link_name = "spa_pod_compare_value_libspa_rs"]
6861 pub fn spa_pod_compare_value(
6862 type_: u32,
6863 r1: *const ::std::os::raw::c_void,
6864 r2: *const ::std::os::raw::c_void,
6865 size: u32,
6866 ) -> ::std::os::raw::c_int;
6867}
6868unsafe extern "C" {
6869 #[link_name = "spa_pod_compare_libspa_rs"]
6870 pub fn spa_pod_compare(pod1: *const spa_pod, pod2: *const spa_pod) -> ::std::os::raw::c_int;
6871}
6872unsafe extern "C" {
6873 #[doc = " \\addtogroup spa_pod\n \\{"]
6874 #[link_name = "spa_pod_choice_fix_default_libspa_rs"]
6875 pub fn spa_pod_choice_fix_default(choice: *mut spa_pod_choice) -> ::std::os::raw::c_int;
6876}
6877unsafe extern "C" {
6878 #[link_name = "spa_pod_filter_flags_value_libspa_rs"]
6879 pub fn spa_pod_filter_flags_value(
6880 b: *mut spa_pod_builder,
6881 type_: u32,
6882 r1: *const ::std::os::raw::c_void,
6883 r2: *const ::std::os::raw::c_void,
6884 size: u32,
6885 ) -> ::std::os::raw::c_int;
6886}
6887unsafe extern "C" {
6888 #[link_name = "spa_pod_filter_is_step_of_libspa_rs"]
6889 pub fn spa_pod_filter_is_step_of(
6890 type_: u32,
6891 r1: *const ::std::os::raw::c_void,
6892 r2: *const ::std::os::raw::c_void,
6893 size: u32,
6894 ) -> ::std::os::raw::c_int;
6895}
6896unsafe extern "C" {
6897 #[link_name = "spa_pod_filter_prop_libspa_rs"]
6898 pub fn spa_pod_filter_prop(
6899 b: *mut spa_pod_builder,
6900 p1: *const spa_pod_prop,
6901 p2: *const spa_pod_prop,
6902 ) -> ::std::os::raw::c_int;
6903}
6904unsafe extern "C" {
6905 #[link_name = "spa_pod_filter_part_libspa_rs"]
6906 pub fn spa_pod_filter_part(
6907 b: *mut spa_pod_builder,
6908 pod: *const spa_pod,
6909 pod_size: u32,
6910 filter: *const spa_pod,
6911 filter_size: u32,
6912 ) -> ::std::os::raw::c_int;
6913}
6914unsafe extern "C" {
6915 #[link_name = "spa_pod_filter_libspa_rs"]
6916 pub fn spa_pod_filter(
6917 b: *mut spa_pod_builder,
6918 result: *mut *mut spa_pod,
6919 pod: *const spa_pod,
6920 filter: *const spa_pod,
6921 ) -> ::std::os::raw::c_int;
6922}
6923#[repr(C)]
6924#[derive(Debug, Copy, Clone, PartialEq, Eq)]
6925pub struct spa_cpu {
6926 pub iface: spa_interface,
6927}
6928#[allow(clippy::unnecessary_operation, clippy::identity_op)]
6929const _: () = {
6930 ["Size of spa_cpu"][::std::mem::size_of::<spa_cpu>() - 32usize];
6931 ["Alignment of spa_cpu"][::std::mem::align_of::<spa_cpu>() - 8usize];
6932 ["Offset of field: spa_cpu::iface"][::std::mem::offset_of!(spa_cpu, iface) - 0usize];
6933};
6934unsafe extern "C" {
6935 #[link_name = "spa_cpu_vm_type_to_string_libspa_rs"]
6936 pub fn spa_cpu_vm_type_to_string(vm_type: u32) -> *const ::std::os::raw::c_char;
6937}
6938#[doc = " methods"]
6939#[repr(C)]
6940#[derive(Debug, Copy, Clone, PartialEq, Eq)]
6941pub struct spa_cpu_methods {
6942 pub version: u32,
6943 #[doc = " get CPU flags"]
6944 pub get_flags:
6945 ::std::option::Option<unsafe extern "C" fn(object: *mut ::std::os::raw::c_void) -> u32>,
6946 #[doc = " force CPU flags, use SPA_CPU_FORCE_AUTODETECT to autodetect CPU flags"]
6947 pub force_flags: ::std::option::Option<
6948 unsafe extern "C" fn(
6949 object: *mut ::std::os::raw::c_void,
6950 flags: u32,
6951 ) -> ::std::os::raw::c_int,
6952 >,
6953 #[doc = " get number of CPU cores"]
6954 pub get_count:
6955 ::std::option::Option<unsafe extern "C" fn(object: *mut ::std::os::raw::c_void) -> u32>,
6956 #[doc = " get maximum required alignment of data"]
6957 pub get_max_align:
6958 ::std::option::Option<unsafe extern "C" fn(object: *mut ::std::os::raw::c_void) -> u32>,
6959 pub get_vm_type:
6960 ::std::option::Option<unsafe extern "C" fn(object: *mut ::std::os::raw::c_void) -> u32>,
6961 pub zero_denormals: ::std::option::Option<
6962 unsafe extern "C" fn(
6963 object: *mut ::std::os::raw::c_void,
6964 enable: bool,
6965 ) -> ::std::os::raw::c_int,
6966 >,
6967}
6968#[allow(clippy::unnecessary_operation, clippy::identity_op)]
6969const _: () = {
6970 ["Size of spa_cpu_methods"][::std::mem::size_of::<spa_cpu_methods>() - 56usize];
6971 ["Alignment of spa_cpu_methods"][::std::mem::align_of::<spa_cpu_methods>() - 8usize];
6972 ["Offset of field: spa_cpu_methods::version"]
6973 [::std::mem::offset_of!(spa_cpu_methods, version) - 0usize];
6974 ["Offset of field: spa_cpu_methods::get_flags"]
6975 [::std::mem::offset_of!(spa_cpu_methods, get_flags) - 8usize];
6976 ["Offset of field: spa_cpu_methods::force_flags"]
6977 [::std::mem::offset_of!(spa_cpu_methods, force_flags) - 16usize];
6978 ["Offset of field: spa_cpu_methods::get_count"]
6979 [::std::mem::offset_of!(spa_cpu_methods, get_count) - 24usize];
6980 ["Offset of field: spa_cpu_methods::get_max_align"]
6981 [::std::mem::offset_of!(spa_cpu_methods, get_max_align) - 32usize];
6982 ["Offset of field: spa_cpu_methods::get_vm_type"]
6983 [::std::mem::offset_of!(spa_cpu_methods, get_vm_type) - 40usize];
6984 ["Offset of field: spa_cpu_methods::zero_denormals"]
6985 [::std::mem::offset_of!(spa_cpu_methods, zero_denormals) - 48usize];
6986};
6987unsafe extern "C" {
6988 #[link_name = "spa_cpu_get_flags_libspa_rs"]
6989 pub fn spa_cpu_get_flags(c: *mut spa_cpu) -> u32;
6990}
6991unsafe extern "C" {
6992 #[link_name = "spa_cpu_force_flags_libspa_rs"]
6993 pub fn spa_cpu_force_flags(c: *mut spa_cpu, flags: u32) -> ::std::os::raw::c_int;
6994}
6995unsafe extern "C" {
6996 #[link_name = "spa_cpu_get_count_libspa_rs"]
6997 pub fn spa_cpu_get_count(c: *mut spa_cpu) -> u32;
6998}
6999unsafe extern "C" {
7000 #[link_name = "spa_cpu_get_max_align_libspa_rs"]
7001 pub fn spa_cpu_get_max_align(c: *mut spa_cpu) -> u32;
7002}
7003unsafe extern "C" {
7004 #[link_name = "spa_cpu_get_vm_type_libspa_rs"]
7005 pub fn spa_cpu_get_vm_type(c: *mut spa_cpu) -> u32;
7006}
7007unsafe extern "C" {
7008 #[link_name = "spa_cpu_zero_denormals_libspa_rs"]
7009 pub fn spa_cpu_zero_denormals(c: *mut spa_cpu, enable: bool) -> ::std::os::raw::c_int;
7010}
7011#[repr(C)]
7012#[derive(Debug, Copy, Clone, PartialEq, Eq)]
7013pub struct itimerspec {
7014 pub it_interval: timespec,
7015 pub it_value: timespec,
7016}
7017#[allow(clippy::unnecessary_operation, clippy::identity_op)]
7018const _: () = {
7019 ["Size of itimerspec"][::std::mem::size_of::<itimerspec>() - 32usize];
7020 ["Alignment of itimerspec"][::std::mem::align_of::<itimerspec>() - 8usize];
7021 ["Offset of field: itimerspec::it_interval"]
7022 [::std::mem::offset_of!(itimerspec, it_interval) - 0usize];
7023 ["Offset of field: itimerspec::it_value"]
7024 [::std::mem::offset_of!(itimerspec, it_value) - 16usize];
7025};
7026#[repr(C)]
7027#[derive(Debug, Copy, Clone, PartialEq, Eq)]
7028pub struct spa_system {
7029 pub iface: spa_interface,
7030}
7031#[allow(clippy::unnecessary_operation, clippy::identity_op)]
7032const _: () = {
7033 ["Size of spa_system"][::std::mem::size_of::<spa_system>() - 32usize];
7034 ["Alignment of spa_system"][::std::mem::align_of::<spa_system>() - 8usize];
7035 ["Offset of field: spa_system::iface"][::std::mem::offset_of!(spa_system, iface) - 0usize];
7036};
7037#[repr(C)]
7038#[derive(Debug, Copy, Clone, PartialEq, Eq)]
7039pub struct spa_poll_event {
7040 pub events: u32,
7041 pub data: *mut ::std::os::raw::c_void,
7042}
7043#[allow(clippy::unnecessary_operation, clippy::identity_op)]
7044const _: () = {
7045 ["Size of spa_poll_event"][::std::mem::size_of::<spa_poll_event>() - 16usize];
7046 ["Alignment of spa_poll_event"][::std::mem::align_of::<spa_poll_event>() - 8usize];
7047 ["Offset of field: spa_poll_event::events"]
7048 [::std::mem::offset_of!(spa_poll_event, events) - 0usize];
7049 ["Offset of field: spa_poll_event::data"]
7050 [::std::mem::offset_of!(spa_poll_event, data) - 8usize];
7051};
7052#[repr(C)]
7053#[derive(Debug, Copy, Clone, PartialEq, Eq)]
7054pub struct spa_system_methods {
7055 pub version: u32,
7056 pub read: ::std::option::Option<
7057 unsafe extern "C" fn(
7058 object: *mut ::std::os::raw::c_void,
7059 fd: ::std::os::raw::c_int,
7060 buf: *mut ::std::os::raw::c_void,
7061 count: usize,
7062 ) -> isize,
7063 >,
7064 pub write: ::std::option::Option<
7065 unsafe extern "C" fn(
7066 object: *mut ::std::os::raw::c_void,
7067 fd: ::std::os::raw::c_int,
7068 buf: *const ::std::os::raw::c_void,
7069 count: usize,
7070 ) -> isize,
7071 >,
7072 pub ioctl: ::std::option::Option<
7073 unsafe extern "C" fn(
7074 object: *mut ::std::os::raw::c_void,
7075 fd: ::std::os::raw::c_int,
7076 request: ::std::os::raw::c_ulong,
7077 ...
7078 ) -> ::std::os::raw::c_int,
7079 >,
7080 pub close: ::std::option::Option<
7081 unsafe extern "C" fn(
7082 object: *mut ::std::os::raw::c_void,
7083 fd: ::std::os::raw::c_int,
7084 ) -> ::std::os::raw::c_int,
7085 >,
7086 pub clock_gettime: ::std::option::Option<
7087 unsafe extern "C" fn(
7088 object: *mut ::std::os::raw::c_void,
7089 clockid: ::std::os::raw::c_int,
7090 value: *mut timespec,
7091 ) -> ::std::os::raw::c_int,
7092 >,
7093 pub clock_getres: ::std::option::Option<
7094 unsafe extern "C" fn(
7095 object: *mut ::std::os::raw::c_void,
7096 clockid: ::std::os::raw::c_int,
7097 res: *mut timespec,
7098 ) -> ::std::os::raw::c_int,
7099 >,
7100 pub pollfd_create: ::std::option::Option<
7101 unsafe extern "C" fn(
7102 object: *mut ::std::os::raw::c_void,
7103 flags: ::std::os::raw::c_int,
7104 ) -> ::std::os::raw::c_int,
7105 >,
7106 pub pollfd_add: ::std::option::Option<
7107 unsafe extern "C" fn(
7108 object: *mut ::std::os::raw::c_void,
7109 pfd: ::std::os::raw::c_int,
7110 fd: ::std::os::raw::c_int,
7111 events: u32,
7112 data: *mut ::std::os::raw::c_void,
7113 ) -> ::std::os::raw::c_int,
7114 >,
7115 pub pollfd_mod: ::std::option::Option<
7116 unsafe extern "C" fn(
7117 object: *mut ::std::os::raw::c_void,
7118 pfd: ::std::os::raw::c_int,
7119 fd: ::std::os::raw::c_int,
7120 events: u32,
7121 data: *mut ::std::os::raw::c_void,
7122 ) -> ::std::os::raw::c_int,
7123 >,
7124 pub pollfd_del: ::std::option::Option<
7125 unsafe extern "C" fn(
7126 object: *mut ::std::os::raw::c_void,
7127 pfd: ::std::os::raw::c_int,
7128 fd: ::std::os::raw::c_int,
7129 ) -> ::std::os::raw::c_int,
7130 >,
7131 pub pollfd_wait: ::std::option::Option<
7132 unsafe extern "C" fn(
7133 object: *mut ::std::os::raw::c_void,
7134 pfd: ::std::os::raw::c_int,
7135 ev: *mut spa_poll_event,
7136 n_ev: ::std::os::raw::c_int,
7137 timeout: ::std::os::raw::c_int,
7138 ) -> ::std::os::raw::c_int,
7139 >,
7140 pub timerfd_create: ::std::option::Option<
7141 unsafe extern "C" fn(
7142 object: *mut ::std::os::raw::c_void,
7143 clockid: ::std::os::raw::c_int,
7144 flags: ::std::os::raw::c_int,
7145 ) -> ::std::os::raw::c_int,
7146 >,
7147 pub timerfd_settime: ::std::option::Option<
7148 unsafe extern "C" fn(
7149 object: *mut ::std::os::raw::c_void,
7150 fd: ::std::os::raw::c_int,
7151 flags: ::std::os::raw::c_int,
7152 new_value: *const itimerspec,
7153 old_value: *mut itimerspec,
7154 ) -> ::std::os::raw::c_int,
7155 >,
7156 pub timerfd_gettime: ::std::option::Option<
7157 unsafe extern "C" fn(
7158 object: *mut ::std::os::raw::c_void,
7159 fd: ::std::os::raw::c_int,
7160 curr_value: *mut itimerspec,
7161 ) -> ::std::os::raw::c_int,
7162 >,
7163 pub timerfd_read: ::std::option::Option<
7164 unsafe extern "C" fn(
7165 object: *mut ::std::os::raw::c_void,
7166 fd: ::std::os::raw::c_int,
7167 expirations: *mut u64,
7168 ) -> ::std::os::raw::c_int,
7169 >,
7170 pub eventfd_create: ::std::option::Option<
7171 unsafe extern "C" fn(
7172 object: *mut ::std::os::raw::c_void,
7173 flags: ::std::os::raw::c_int,
7174 ) -> ::std::os::raw::c_int,
7175 >,
7176 pub eventfd_write: ::std::option::Option<
7177 unsafe extern "C" fn(
7178 object: *mut ::std::os::raw::c_void,
7179 fd: ::std::os::raw::c_int,
7180 count: u64,
7181 ) -> ::std::os::raw::c_int,
7182 >,
7183 pub eventfd_read: ::std::option::Option<
7184 unsafe extern "C" fn(
7185 object: *mut ::std::os::raw::c_void,
7186 fd: ::std::os::raw::c_int,
7187 count: *mut u64,
7188 ) -> ::std::os::raw::c_int,
7189 >,
7190 pub signalfd_create: ::std::option::Option<
7191 unsafe extern "C" fn(
7192 object: *mut ::std::os::raw::c_void,
7193 signal: ::std::os::raw::c_int,
7194 flags: ::std::os::raw::c_int,
7195 ) -> ::std::os::raw::c_int,
7196 >,
7197 pub signalfd_read: ::std::option::Option<
7198 unsafe extern "C" fn(
7199 object: *mut ::std::os::raw::c_void,
7200 fd: ::std::os::raw::c_int,
7201 signal: *mut ::std::os::raw::c_int,
7202 ) -> ::std::os::raw::c_int,
7203 >,
7204}
7205#[allow(clippy::unnecessary_operation, clippy::identity_op)]
7206const _: () = {
7207 ["Size of spa_system_methods"][::std::mem::size_of::<spa_system_methods>() - 168usize];
7208 ["Alignment of spa_system_methods"][::std::mem::align_of::<spa_system_methods>() - 8usize];
7209 ["Offset of field: spa_system_methods::version"]
7210 [::std::mem::offset_of!(spa_system_methods, version) - 0usize];
7211 ["Offset of field: spa_system_methods::read"]
7212 [::std::mem::offset_of!(spa_system_methods, read) - 8usize];
7213 ["Offset of field: spa_system_methods::write"]
7214 [::std::mem::offset_of!(spa_system_methods, write) - 16usize];
7215 ["Offset of field: spa_system_methods::ioctl"]
7216 [::std::mem::offset_of!(spa_system_methods, ioctl) - 24usize];
7217 ["Offset of field: spa_system_methods::close"]
7218 [::std::mem::offset_of!(spa_system_methods, close) - 32usize];
7219 ["Offset of field: spa_system_methods::clock_gettime"]
7220 [::std::mem::offset_of!(spa_system_methods, clock_gettime) - 40usize];
7221 ["Offset of field: spa_system_methods::clock_getres"]
7222 [::std::mem::offset_of!(spa_system_methods, clock_getres) - 48usize];
7223 ["Offset of field: spa_system_methods::pollfd_create"]
7224 [::std::mem::offset_of!(spa_system_methods, pollfd_create) - 56usize];
7225 ["Offset of field: spa_system_methods::pollfd_add"]
7226 [::std::mem::offset_of!(spa_system_methods, pollfd_add) - 64usize];
7227 ["Offset of field: spa_system_methods::pollfd_mod"]
7228 [::std::mem::offset_of!(spa_system_methods, pollfd_mod) - 72usize];
7229 ["Offset of field: spa_system_methods::pollfd_del"]
7230 [::std::mem::offset_of!(spa_system_methods, pollfd_del) - 80usize];
7231 ["Offset of field: spa_system_methods::pollfd_wait"]
7232 [::std::mem::offset_of!(spa_system_methods, pollfd_wait) - 88usize];
7233 ["Offset of field: spa_system_methods::timerfd_create"]
7234 [::std::mem::offset_of!(spa_system_methods, timerfd_create) - 96usize];
7235 ["Offset of field: spa_system_methods::timerfd_settime"]
7236 [::std::mem::offset_of!(spa_system_methods, timerfd_settime) - 104usize];
7237 ["Offset of field: spa_system_methods::timerfd_gettime"]
7238 [::std::mem::offset_of!(spa_system_methods, timerfd_gettime) - 112usize];
7239 ["Offset of field: spa_system_methods::timerfd_read"]
7240 [::std::mem::offset_of!(spa_system_methods, timerfd_read) - 120usize];
7241 ["Offset of field: spa_system_methods::eventfd_create"]
7242 [::std::mem::offset_of!(spa_system_methods, eventfd_create) - 128usize];
7243 ["Offset of field: spa_system_methods::eventfd_write"]
7244 [::std::mem::offset_of!(spa_system_methods, eventfd_write) - 136usize];
7245 ["Offset of field: spa_system_methods::eventfd_read"]
7246 [::std::mem::offset_of!(spa_system_methods, eventfd_read) - 144usize];
7247 ["Offset of field: spa_system_methods::signalfd_create"]
7248 [::std::mem::offset_of!(spa_system_methods, signalfd_create) - 152usize];
7249 ["Offset of field: spa_system_methods::signalfd_read"]
7250 [::std::mem::offset_of!(spa_system_methods, signalfd_read) - 160usize];
7251};
7252unsafe extern "C" {
7253 #[link_name = "spa_system_read_libspa_rs"]
7254 pub fn spa_system_read(
7255 object: *mut spa_system,
7256 fd: ::std::os::raw::c_int,
7257 buf: *mut ::std::os::raw::c_void,
7258 count: usize,
7259 ) -> isize;
7260}
7261unsafe extern "C" {
7262 #[link_name = "spa_system_write_libspa_rs"]
7263 pub fn spa_system_write(
7264 object: *mut spa_system,
7265 fd: ::std::os::raw::c_int,
7266 buf: *const ::std::os::raw::c_void,
7267 count: usize,
7268 ) -> isize;
7269}
7270unsafe extern "C" {
7271 #[link_name = "spa_system_close_libspa_rs"]
7272 pub fn spa_system_close(
7273 object: *mut spa_system,
7274 fd: ::std::os::raw::c_int,
7275 ) -> ::std::os::raw::c_int;
7276}
7277unsafe extern "C" {
7278 #[link_name = "spa_system_clock_gettime_libspa_rs"]
7279 pub fn spa_system_clock_gettime(
7280 object: *mut spa_system,
7281 clockid: ::std::os::raw::c_int,
7282 value: *mut timespec,
7283 ) -> ::std::os::raw::c_int;
7284}
7285unsafe extern "C" {
7286 #[link_name = "spa_system_clock_getres_libspa_rs"]
7287 pub fn spa_system_clock_getres(
7288 object: *mut spa_system,
7289 clockid: ::std::os::raw::c_int,
7290 res: *mut timespec,
7291 ) -> ::std::os::raw::c_int;
7292}
7293unsafe extern "C" {
7294 #[link_name = "spa_system_pollfd_create_libspa_rs"]
7295 pub fn spa_system_pollfd_create(
7296 object: *mut spa_system,
7297 flags: ::std::os::raw::c_int,
7298 ) -> ::std::os::raw::c_int;
7299}
7300unsafe extern "C" {
7301 #[link_name = "spa_system_pollfd_add_libspa_rs"]
7302 pub fn spa_system_pollfd_add(
7303 object: *mut spa_system,
7304 pfd: ::std::os::raw::c_int,
7305 fd: ::std::os::raw::c_int,
7306 events: u32,
7307 data: *mut ::std::os::raw::c_void,
7308 ) -> ::std::os::raw::c_int;
7309}
7310unsafe extern "C" {
7311 #[link_name = "spa_system_pollfd_mod_libspa_rs"]
7312 pub fn spa_system_pollfd_mod(
7313 object: *mut spa_system,
7314 pfd: ::std::os::raw::c_int,
7315 fd: ::std::os::raw::c_int,
7316 events: u32,
7317 data: *mut ::std::os::raw::c_void,
7318 ) -> ::std::os::raw::c_int;
7319}
7320unsafe extern "C" {
7321 #[link_name = "spa_system_pollfd_del_libspa_rs"]
7322 pub fn spa_system_pollfd_del(
7323 object: *mut spa_system,
7324 pfd: ::std::os::raw::c_int,
7325 fd: ::std::os::raw::c_int,
7326 ) -> ::std::os::raw::c_int;
7327}
7328unsafe extern "C" {
7329 #[link_name = "spa_system_pollfd_wait_libspa_rs"]
7330 pub fn spa_system_pollfd_wait(
7331 object: *mut spa_system,
7332 pfd: ::std::os::raw::c_int,
7333 ev: *mut spa_poll_event,
7334 n_ev: ::std::os::raw::c_int,
7335 timeout: ::std::os::raw::c_int,
7336 ) -> ::std::os::raw::c_int;
7337}
7338unsafe extern "C" {
7339 #[link_name = "spa_system_timerfd_create_libspa_rs"]
7340 pub fn spa_system_timerfd_create(
7341 object: *mut spa_system,
7342 clockid: ::std::os::raw::c_int,
7343 flags: ::std::os::raw::c_int,
7344 ) -> ::std::os::raw::c_int;
7345}
7346unsafe extern "C" {
7347 #[link_name = "spa_system_timerfd_settime_libspa_rs"]
7348 pub fn spa_system_timerfd_settime(
7349 object: *mut spa_system,
7350 fd: ::std::os::raw::c_int,
7351 flags: ::std::os::raw::c_int,
7352 new_value: *const itimerspec,
7353 old_value: *mut itimerspec,
7354 ) -> ::std::os::raw::c_int;
7355}
7356unsafe extern "C" {
7357 #[link_name = "spa_system_timerfd_gettime_libspa_rs"]
7358 pub fn spa_system_timerfd_gettime(
7359 object: *mut spa_system,
7360 fd: ::std::os::raw::c_int,
7361 curr_value: *mut itimerspec,
7362 ) -> ::std::os::raw::c_int;
7363}
7364unsafe extern "C" {
7365 #[link_name = "spa_system_timerfd_read_libspa_rs"]
7366 pub fn spa_system_timerfd_read(
7367 object: *mut spa_system,
7368 fd: ::std::os::raw::c_int,
7369 expirations: *mut u64,
7370 ) -> ::std::os::raw::c_int;
7371}
7372unsafe extern "C" {
7373 #[link_name = "spa_system_eventfd_create_libspa_rs"]
7374 pub fn spa_system_eventfd_create(
7375 object: *mut spa_system,
7376 flags: ::std::os::raw::c_int,
7377 ) -> ::std::os::raw::c_int;
7378}
7379unsafe extern "C" {
7380 #[link_name = "spa_system_eventfd_write_libspa_rs"]
7381 pub fn spa_system_eventfd_write(
7382 object: *mut spa_system,
7383 fd: ::std::os::raw::c_int,
7384 count: u64,
7385 ) -> ::std::os::raw::c_int;
7386}
7387unsafe extern "C" {
7388 #[link_name = "spa_system_eventfd_read_libspa_rs"]
7389 pub fn spa_system_eventfd_read(
7390 object: *mut spa_system,
7391 fd: ::std::os::raw::c_int,
7392 count: *mut u64,
7393 ) -> ::std::os::raw::c_int;
7394}
7395unsafe extern "C" {
7396 #[link_name = "spa_system_signalfd_create_libspa_rs"]
7397 pub fn spa_system_signalfd_create(
7398 object: *mut spa_system,
7399 signal: ::std::os::raw::c_int,
7400 flags: ::std::os::raw::c_int,
7401 ) -> ::std::os::raw::c_int;
7402}
7403unsafe extern "C" {
7404 #[link_name = "spa_system_signalfd_read_libspa_rs"]
7405 pub fn spa_system_signalfd_read(
7406 object: *mut spa_system,
7407 fd: ::std::os::raw::c_int,
7408 signal: *mut ::std::os::raw::c_int,
7409 ) -> ::std::os::raw::c_int;
7410}
7411#[repr(C)]
7412#[derive(Debug, Copy, Clone, PartialEq, Eq)]
7413pub struct spa_loop {
7414 pub iface: spa_interface,
7415}
7416#[allow(clippy::unnecessary_operation, clippy::identity_op)]
7417const _: () = {
7418 ["Size of spa_loop"][::std::mem::size_of::<spa_loop>() - 32usize];
7419 ["Alignment of spa_loop"][::std::mem::align_of::<spa_loop>() - 8usize];
7420 ["Offset of field: spa_loop::iface"][::std::mem::offset_of!(spa_loop, iface) - 0usize];
7421};
7422#[repr(C)]
7423#[derive(Debug, Copy, Clone, PartialEq, Eq)]
7424pub struct spa_loop_control {
7425 pub iface: spa_interface,
7426}
7427#[allow(clippy::unnecessary_operation, clippy::identity_op)]
7428const _: () = {
7429 ["Size of spa_loop_control"][::std::mem::size_of::<spa_loop_control>() - 32usize];
7430 ["Alignment of spa_loop_control"][::std::mem::align_of::<spa_loop_control>() - 8usize];
7431 ["Offset of field: spa_loop_control::iface"]
7432 [::std::mem::offset_of!(spa_loop_control, iface) - 0usize];
7433};
7434#[repr(C)]
7435#[derive(Debug, Copy, Clone, PartialEq, Eq)]
7436pub struct spa_loop_utils {
7437 pub iface: spa_interface,
7438}
7439#[allow(clippy::unnecessary_operation, clippy::identity_op)]
7440const _: () = {
7441 ["Size of spa_loop_utils"][::std::mem::size_of::<spa_loop_utils>() - 32usize];
7442 ["Alignment of spa_loop_utils"][::std::mem::align_of::<spa_loop_utils>() - 8usize];
7443 ["Offset of field: spa_loop_utils::iface"]
7444 [::std::mem::offset_of!(spa_loop_utils, iface) - 0usize];
7445};
7446pub type spa_source_func_t = ::std::option::Option<unsafe extern "C" fn(source: *mut spa_source)>;
7447#[repr(C)]
7448#[derive(Debug, Copy, Clone, PartialEq, Eq)]
7449pub struct spa_source {
7450 pub loop_: *mut spa_loop,
7451 pub func: spa_source_func_t,
7452 pub data: *mut ::std::os::raw::c_void,
7453 pub fd: ::std::os::raw::c_int,
7454 pub mask: u32,
7455 pub rmask: u32,
7456 pub priv_: *mut ::std::os::raw::c_void,
7457}
7458#[allow(clippy::unnecessary_operation, clippy::identity_op)]
7459const _: () = {
7460 ["Size of spa_source"][::std::mem::size_of::<spa_source>() - 48usize];
7461 ["Alignment of spa_source"][::std::mem::align_of::<spa_source>() - 8usize];
7462 ["Offset of field: spa_source::loop_"][::std::mem::offset_of!(spa_source, loop_) - 0usize];
7463 ["Offset of field: spa_source::func"][::std::mem::offset_of!(spa_source, func) - 8usize];
7464 ["Offset of field: spa_source::data"][::std::mem::offset_of!(spa_source, data) - 16usize];
7465 ["Offset of field: spa_source::fd"][::std::mem::offset_of!(spa_source, fd) - 24usize];
7466 ["Offset of field: spa_source::mask"][::std::mem::offset_of!(spa_source, mask) - 28usize];
7467 ["Offset of field: spa_source::rmask"][::std::mem::offset_of!(spa_source, rmask) - 32usize];
7468 ["Offset of field: spa_source::priv_"][::std::mem::offset_of!(spa_source, priv_) - 40usize];
7469};
7470pub type spa_invoke_func_t = ::std::option::Option<
7471 unsafe extern "C" fn(
7472 loop_: *mut spa_loop,
7473 async_: bool,
7474 seq: u32,
7475 data: *const ::std::os::raw::c_void,
7476 size: usize,
7477 user_data: *mut ::std::os::raw::c_void,
7478 ) -> ::std::os::raw::c_int,
7479>;
7480#[doc = " Register sources and work items to an event loop"]
7481#[repr(C)]
7482#[derive(Debug, Copy, Clone, PartialEq, Eq)]
7483pub struct spa_loop_methods {
7484 pub version: u32,
7485 #[doc = " Add a source to the loop. Must be called from the loop's own thread.\n\n \\param[in] object The callbacks data.\n \\param[in] source The source.\n \\return 0 on success, negative errno-style value on failure."]
7486 pub add_source: ::std::option::Option<
7487 unsafe extern "C" fn(
7488 object: *mut ::std::os::raw::c_void,
7489 source: *mut spa_source,
7490 ) -> ::std::os::raw::c_int,
7491 >,
7492 #[doc = " Update the source io mask. Must be called from the loop's own thread.\n\n \\param[in] object The callbacks data.\n \\param[in] source The source.\n \\return 0 on success, negative errno-style value on failure."]
7493 pub update_source: ::std::option::Option<
7494 unsafe extern "C" fn(
7495 object: *mut ::std::os::raw::c_void,
7496 source: *mut spa_source,
7497 ) -> ::std::os::raw::c_int,
7498 >,
7499 #[doc = " Remove a source from the loop. Must be called from the loop's own thread.\n\n \\param[in] object The callbacks data.\n \\param[in] source The source.\n \\return 0 on success, negative errno-style value on failure."]
7500 pub remove_source: ::std::option::Option<
7501 unsafe extern "C" fn(
7502 object: *mut ::std::os::raw::c_void,
7503 source: *mut spa_source,
7504 ) -> ::std::os::raw::c_int,
7505 >,
7506 #[doc = " Invoke a function in the context of this loop.\n May be called from any thread and multiple threads at the same time.\n If called from the loop's thread, all callbacks previously queued with\n invoke() will be run synchronously, which might cause unexpected\n reentrancy problems.\n\n \\param[in] object The callbacks data.\n \\param func The function to be invoked.\n \\param seq An opaque sequence number. This will be made\n available to func.\n \\param[in] data Data that will be copied into the internal ring buffer and made\n available to func. Because this data is copied, it is okay to\n pass a pointer to a local variable, but do not pass a pointer to\n an object that has identity.\n \\param size The size of data to copy.\n \\param block If \\true, do not return until func has been called. Otherwise,\n returns immediately. Passing \\true does not risk a deadlock because\n the data thread is never allowed to wait on any other thread.\n It the loop requires some locking, it must be acquired before\n calling this function because a blocking invoke will release\n the lock while blocking.\n \\param user_data An opaque pointer passed to func.\n \\return `-EPIPE` if the internal ring buffer filled up,\n if block is \\false, 0 if seq was SPA_ID_INVALID or\n seq with the ASYNC flag set\n or the return value of func otherwise."]
7507 pub invoke: ::std::option::Option<
7508 unsafe extern "C" fn(
7509 object: *mut ::std::os::raw::c_void,
7510 func: spa_invoke_func_t,
7511 seq: u32,
7512 data: *const ::std::os::raw::c_void,
7513 size: usize,
7514 block: bool,
7515 user_data: *mut ::std::os::raw::c_void,
7516 ) -> ::std::os::raw::c_int,
7517 >,
7518}
7519#[allow(clippy::unnecessary_operation, clippy::identity_op)]
7520const _: () = {
7521 ["Size of spa_loop_methods"][::std::mem::size_of::<spa_loop_methods>() - 40usize];
7522 ["Alignment of spa_loop_methods"][::std::mem::align_of::<spa_loop_methods>() - 8usize];
7523 ["Offset of field: spa_loop_methods::version"]
7524 [::std::mem::offset_of!(spa_loop_methods, version) - 0usize];
7525 ["Offset of field: spa_loop_methods::add_source"]
7526 [::std::mem::offset_of!(spa_loop_methods, add_source) - 8usize];
7527 ["Offset of field: spa_loop_methods::update_source"]
7528 [::std::mem::offset_of!(spa_loop_methods, update_source) - 16usize];
7529 ["Offset of field: spa_loop_methods::remove_source"]
7530 [::std::mem::offset_of!(spa_loop_methods, remove_source) - 24usize];
7531 ["Offset of field: spa_loop_methods::invoke"]
7532 [::std::mem::offset_of!(spa_loop_methods, invoke) - 32usize];
7533};
7534unsafe extern "C" {
7535 #[link_name = "spa_loop_add_source_libspa_rs"]
7536 pub fn spa_loop_add_source(
7537 object: *mut spa_loop,
7538 source: *mut spa_source,
7539 ) -> ::std::os::raw::c_int;
7540}
7541unsafe extern "C" {
7542 #[link_name = "spa_loop_update_source_libspa_rs"]
7543 pub fn spa_loop_update_source(
7544 object: *mut spa_loop,
7545 source: *mut spa_source,
7546 ) -> ::std::os::raw::c_int;
7547}
7548unsafe extern "C" {
7549 #[link_name = "spa_loop_remove_source_libspa_rs"]
7550 pub fn spa_loop_remove_source(
7551 object: *mut spa_loop,
7552 source: *mut spa_source,
7553 ) -> ::std::os::raw::c_int;
7554}
7555unsafe extern "C" {
7556 #[link_name = "spa_loop_invoke_libspa_rs"]
7557 pub fn spa_loop_invoke(
7558 object: *mut spa_loop,
7559 func: spa_invoke_func_t,
7560 seq: u32,
7561 data: *const ::std::os::raw::c_void,
7562 size: usize,
7563 block: bool,
7564 user_data: *mut ::std::os::raw::c_void,
7565 ) -> ::std::os::raw::c_int;
7566}
7567#[doc = " Control hooks. These hooks can't be removed from their\n callbacks and must be removed from a safe place (when the loop\n is not running or when it is locked)."]
7568#[repr(C)]
7569#[derive(Debug, Copy, Clone, PartialEq, Eq)]
7570pub struct spa_loop_control_hooks {
7571 pub version: u32,
7572 #[doc = " Executed right before waiting for events. It is typically used to\n release locks."]
7573 pub before: ::std::option::Option<unsafe extern "C" fn(data: *mut ::std::os::raw::c_void)>,
7574 #[doc = " Executed right after waiting for events. It is typically used to\n reacquire locks."]
7575 pub after: ::std::option::Option<unsafe extern "C" fn(data: *mut ::std::os::raw::c_void)>,
7576}
7577#[allow(clippy::unnecessary_operation, clippy::identity_op)]
7578const _: () = {
7579 ["Size of spa_loop_control_hooks"][::std::mem::size_of::<spa_loop_control_hooks>() - 24usize];
7580 ["Alignment of spa_loop_control_hooks"]
7581 [::std::mem::align_of::<spa_loop_control_hooks>() - 8usize];
7582 ["Offset of field: spa_loop_control_hooks::version"]
7583 [::std::mem::offset_of!(spa_loop_control_hooks, version) - 0usize];
7584 ["Offset of field: spa_loop_control_hooks::before"]
7585 [::std::mem::offset_of!(spa_loop_control_hooks, before) - 8usize];
7586 ["Offset of field: spa_loop_control_hooks::after"]
7587 [::std::mem::offset_of!(spa_loop_control_hooks, after) - 16usize];
7588};
7589unsafe extern "C" {
7590 #[link_name = "spa_loop_control_hook_before_libspa_rs"]
7591 pub fn spa_loop_control_hook_before(l: *mut spa_hook_list);
7592}
7593unsafe extern "C" {
7594 #[link_name = "spa_loop_control_hook_after_libspa_rs"]
7595 pub fn spa_loop_control_hook_after(l: *mut spa_hook_list);
7596}
7597#[doc = " Control an event loop\n\n The event loop control function provide API to run the event loop.\n\n The below (pseudo)code is a minimal example outlining the use of the loop\n control:\n \\code{.c}\n spa_loop_control_enter(loop);\n while (running) {\n spa_loop_control_iterate(loop, -1);\n }\n spa_loop_control_leave(loop);\n \\endcode\n\n It is also possible to add the loop to an existing event loop by using the\n spa_loop_control_get_fd() call. This fd will become readable when activity\n has been detected on the sources in the loop. spa_loop_control_iterate() with\n a 0 timeout should be called to process the pending sources.\n\n spa_loop_control_enter() and spa_loop_control_leave() should be called once\n from the thread that will run the iterate() function."]
7598#[repr(C)]
7599#[derive(Debug, Copy, Clone, PartialEq, Eq)]
7600pub struct spa_loop_control_methods {
7601 pub version: u32,
7602 #[doc = " get the loop fd\n \\param object the control to query\n\n Get the fd of this loop control. This fd will be readable when a\n source in the loop has activity. The user should call iterate()\n with a 0 timeout to schedule one iteration of the loop and dispatch\n the sources.\n \\return the fd of the loop"]
7603 pub get_fd: ::std::option::Option<
7604 unsafe extern "C" fn(object: *mut ::std::os::raw::c_void) -> ::std::os::raw::c_int,
7605 >,
7606 #[doc = " Add a hook\n \\param object the control to change\n \\param hooks the hooks to add\n\n Adds hooks to the loop controlled by \\a ctrl."]
7607 pub add_hook: ::std::option::Option<
7608 unsafe extern "C" fn(
7609 object: *mut ::std::os::raw::c_void,
7610 hook: *mut spa_hook,
7611 hooks: *const spa_loop_control_hooks,
7612 data: *mut ::std::os::raw::c_void,
7613 ),
7614 >,
7615 #[doc = " Enter a loop\n \\param object the control\n\n This function should be called before calling iterate and is\n typically used to capture the thread that this loop will run in.\n It should ideally be called once from the thread that will run\n the loop."]
7616 pub enter: ::std::option::Option<unsafe extern "C" fn(object: *mut ::std::os::raw::c_void)>,
7617 #[doc = " Leave a loop\n \\param object the control\n\n It should ideally be called once after calling iterate when the loop\n will no longer be iterated from the thread that called enter()."]
7618 pub leave: ::std::option::Option<unsafe extern "C" fn(object: *mut ::std::os::raw::c_void)>,
7619 #[doc = " Perform one iteration of the loop.\n \\param ctrl the control\n \\param timeout an optional timeout in milliseconds.\n\t0 for no timeout, -1 for infinite timeout.\n\n This function will block\n up to \\a timeout milliseconds and then dispatch the fds with activity.\n The number of dispatched fds is returned."]
7620 pub iterate: ::std::option::Option<
7621 unsafe extern "C" fn(
7622 object: *mut ::std::os::raw::c_void,
7623 timeout: ::std::os::raw::c_int,
7624 ) -> ::std::os::raw::c_int,
7625 >,
7626 #[doc = " Check context of the loop\n \\param ctrl the control\n\n This function will check if the current thread is currently the\n one that did the enter call. Since version 1:1.\n\n returns 1 on success, 0 or negative errno value on error."]
7627 pub check: ::std::option::Option<
7628 unsafe extern "C" fn(object: *mut ::std::os::raw::c_void) -> ::std::os::raw::c_int,
7629 >,
7630}
7631#[allow(clippy::unnecessary_operation, clippy::identity_op)]
7632const _: () = {
7633 ["Size of spa_loop_control_methods"]
7634 [::std::mem::size_of::<spa_loop_control_methods>() - 56usize];
7635 ["Alignment of spa_loop_control_methods"]
7636 [::std::mem::align_of::<spa_loop_control_methods>() - 8usize];
7637 ["Offset of field: spa_loop_control_methods::version"]
7638 [::std::mem::offset_of!(spa_loop_control_methods, version) - 0usize];
7639 ["Offset of field: spa_loop_control_methods::get_fd"]
7640 [::std::mem::offset_of!(spa_loop_control_methods, get_fd) - 8usize];
7641 ["Offset of field: spa_loop_control_methods::add_hook"]
7642 [::std::mem::offset_of!(spa_loop_control_methods, add_hook) - 16usize];
7643 ["Offset of field: spa_loop_control_methods::enter"]
7644 [::std::mem::offset_of!(spa_loop_control_methods, enter) - 24usize];
7645 ["Offset of field: spa_loop_control_methods::leave"]
7646 [::std::mem::offset_of!(spa_loop_control_methods, leave) - 32usize];
7647 ["Offset of field: spa_loop_control_methods::iterate"]
7648 [::std::mem::offset_of!(spa_loop_control_methods, iterate) - 40usize];
7649 ["Offset of field: spa_loop_control_methods::check"]
7650 [::std::mem::offset_of!(spa_loop_control_methods, check) - 48usize];
7651};
7652unsafe extern "C" {
7653 #[link_name = "spa_loop_control_get_fd_libspa_rs"]
7654 pub fn spa_loop_control_get_fd(object: *mut spa_loop_control) -> ::std::os::raw::c_int;
7655}
7656unsafe extern "C" {
7657 #[link_name = "spa_loop_control_add_hook_libspa_rs"]
7658 pub fn spa_loop_control_add_hook(
7659 object: *mut spa_loop_control,
7660 hook: *mut spa_hook,
7661 hooks: *const spa_loop_control_hooks,
7662 data: *mut ::std::os::raw::c_void,
7663 );
7664}
7665unsafe extern "C" {
7666 #[link_name = "spa_loop_control_enter_libspa_rs"]
7667 pub fn spa_loop_control_enter(object: *mut spa_loop_control);
7668}
7669unsafe extern "C" {
7670 #[link_name = "spa_loop_control_leave_libspa_rs"]
7671 pub fn spa_loop_control_leave(object: *mut spa_loop_control);
7672}
7673unsafe extern "C" {
7674 #[link_name = "spa_loop_control_iterate_libspa_rs"]
7675 pub fn spa_loop_control_iterate(
7676 object: *mut spa_loop_control,
7677 timeout: ::std::os::raw::c_int,
7678 ) -> ::std::os::raw::c_int;
7679}
7680unsafe extern "C" {
7681 #[link_name = "spa_loop_control_iterate_fast_libspa_rs"]
7682 pub fn spa_loop_control_iterate_fast(
7683 object: *mut spa_loop_control,
7684 timeout: ::std::os::raw::c_int,
7685 ) -> ::std::os::raw::c_int;
7686}
7687unsafe extern "C" {
7688 #[link_name = "spa_loop_control_check_libspa_rs"]
7689 pub fn spa_loop_control_check(object: *mut spa_loop_control) -> ::std::os::raw::c_int;
7690}
7691pub type spa_source_io_func_t = ::std::option::Option<
7692 unsafe extern "C" fn(data: *mut ::std::os::raw::c_void, fd: ::std::os::raw::c_int, mask: u32),
7693>;
7694pub type spa_source_idle_func_t =
7695 ::std::option::Option<unsafe extern "C" fn(data: *mut ::std::os::raw::c_void)>;
7696pub type spa_source_event_func_t =
7697 ::std::option::Option<unsafe extern "C" fn(data: *mut ::std::os::raw::c_void, count: u64)>;
7698pub type spa_source_timer_func_t = ::std::option::Option<
7699 unsafe extern "C" fn(data: *mut ::std::os::raw::c_void, expirations: u64),
7700>;
7701pub type spa_source_signal_func_t = ::std::option::Option<
7702 unsafe extern "C" fn(data: *mut ::std::os::raw::c_void, signal_number: ::std::os::raw::c_int),
7703>;
7704#[doc = " Create sources for an event loop"]
7705#[repr(C)]
7706#[derive(Debug, Copy, Clone, PartialEq, Eq)]
7707pub struct spa_loop_utils_methods {
7708 pub version: u32,
7709 pub add_io: ::std::option::Option<
7710 unsafe extern "C" fn(
7711 object: *mut ::std::os::raw::c_void,
7712 fd: ::std::os::raw::c_int,
7713 mask: u32,
7714 close: bool,
7715 func: spa_source_io_func_t,
7716 data: *mut ::std::os::raw::c_void,
7717 ) -> *mut spa_source,
7718 >,
7719 pub update_io: ::std::option::Option<
7720 unsafe extern "C" fn(
7721 object: *mut ::std::os::raw::c_void,
7722 source: *mut spa_source,
7723 mask: u32,
7724 ) -> ::std::os::raw::c_int,
7725 >,
7726 pub add_idle: ::std::option::Option<
7727 unsafe extern "C" fn(
7728 object: *mut ::std::os::raw::c_void,
7729 enabled: bool,
7730 func: spa_source_idle_func_t,
7731 data: *mut ::std::os::raw::c_void,
7732 ) -> *mut spa_source,
7733 >,
7734 pub enable_idle: ::std::option::Option<
7735 unsafe extern "C" fn(
7736 object: *mut ::std::os::raw::c_void,
7737 source: *mut spa_source,
7738 enabled: bool,
7739 ) -> ::std::os::raw::c_int,
7740 >,
7741 pub add_event: ::std::option::Option<
7742 unsafe extern "C" fn(
7743 object: *mut ::std::os::raw::c_void,
7744 func: spa_source_event_func_t,
7745 data: *mut ::std::os::raw::c_void,
7746 ) -> *mut spa_source,
7747 >,
7748 pub signal_event: ::std::option::Option<
7749 unsafe extern "C" fn(
7750 object: *mut ::std::os::raw::c_void,
7751 source: *mut spa_source,
7752 ) -> ::std::os::raw::c_int,
7753 >,
7754 pub add_timer: ::std::option::Option<
7755 unsafe extern "C" fn(
7756 object: *mut ::std::os::raw::c_void,
7757 func: spa_source_timer_func_t,
7758 data: *mut ::std::os::raw::c_void,
7759 ) -> *mut spa_source,
7760 >,
7761 pub update_timer: ::std::option::Option<
7762 unsafe extern "C" fn(
7763 object: *mut ::std::os::raw::c_void,
7764 source: *mut spa_source,
7765 value: *mut timespec,
7766 interval: *mut timespec,
7767 absolute: bool,
7768 ) -> ::std::os::raw::c_int,
7769 >,
7770 pub add_signal: ::std::option::Option<
7771 unsafe extern "C" fn(
7772 object: *mut ::std::os::raw::c_void,
7773 signal_number: ::std::os::raw::c_int,
7774 func: spa_source_signal_func_t,
7775 data: *mut ::std::os::raw::c_void,
7776 ) -> *mut spa_source,
7777 >,
7778 #[doc = " destroy a source allocated with this interface. This function\n should only be called when the loop is not running or from the\n context of the running loop"]
7779 pub destroy_source: ::std::option::Option<
7780 unsafe extern "C" fn(object: *mut ::std::os::raw::c_void, source: *mut spa_source),
7781 >,
7782}
7783#[allow(clippy::unnecessary_operation, clippy::identity_op)]
7784const _: () = {
7785 ["Size of spa_loop_utils_methods"][::std::mem::size_of::<spa_loop_utils_methods>() - 88usize];
7786 ["Alignment of spa_loop_utils_methods"]
7787 [::std::mem::align_of::<spa_loop_utils_methods>() - 8usize];
7788 ["Offset of field: spa_loop_utils_methods::version"]
7789 [::std::mem::offset_of!(spa_loop_utils_methods, version) - 0usize];
7790 ["Offset of field: spa_loop_utils_methods::add_io"]
7791 [::std::mem::offset_of!(spa_loop_utils_methods, add_io) - 8usize];
7792 ["Offset of field: spa_loop_utils_methods::update_io"]
7793 [::std::mem::offset_of!(spa_loop_utils_methods, update_io) - 16usize];
7794 ["Offset of field: spa_loop_utils_methods::add_idle"]
7795 [::std::mem::offset_of!(spa_loop_utils_methods, add_idle) - 24usize];
7796 ["Offset of field: spa_loop_utils_methods::enable_idle"]
7797 [::std::mem::offset_of!(spa_loop_utils_methods, enable_idle) - 32usize];
7798 ["Offset of field: spa_loop_utils_methods::add_event"]
7799 [::std::mem::offset_of!(spa_loop_utils_methods, add_event) - 40usize];
7800 ["Offset of field: spa_loop_utils_methods::signal_event"]
7801 [::std::mem::offset_of!(spa_loop_utils_methods, signal_event) - 48usize];
7802 ["Offset of field: spa_loop_utils_methods::add_timer"]
7803 [::std::mem::offset_of!(spa_loop_utils_methods, add_timer) - 56usize];
7804 ["Offset of field: spa_loop_utils_methods::update_timer"]
7805 [::std::mem::offset_of!(spa_loop_utils_methods, update_timer) - 64usize];
7806 ["Offset of field: spa_loop_utils_methods::add_signal"]
7807 [::std::mem::offset_of!(spa_loop_utils_methods, add_signal) - 72usize];
7808 ["Offset of field: spa_loop_utils_methods::destroy_source"]
7809 [::std::mem::offset_of!(spa_loop_utils_methods, destroy_source) - 80usize];
7810};
7811unsafe extern "C" {
7812 #[link_name = "spa_loop_utils_add_io_libspa_rs"]
7813 pub fn spa_loop_utils_add_io(
7814 object: *mut spa_loop_utils,
7815 fd: ::std::os::raw::c_int,
7816 mask: u32,
7817 close: bool,
7818 func: spa_source_io_func_t,
7819 data: *mut ::std::os::raw::c_void,
7820 ) -> *mut spa_source;
7821}
7822unsafe extern "C" {
7823 #[link_name = "spa_loop_utils_update_io_libspa_rs"]
7824 pub fn spa_loop_utils_update_io(
7825 object: *mut spa_loop_utils,
7826 source: *mut spa_source,
7827 mask: u32,
7828 ) -> ::std::os::raw::c_int;
7829}
7830unsafe extern "C" {
7831 #[link_name = "spa_loop_utils_add_idle_libspa_rs"]
7832 pub fn spa_loop_utils_add_idle(
7833 object: *mut spa_loop_utils,
7834 enabled: bool,
7835 func: spa_source_idle_func_t,
7836 data: *mut ::std::os::raw::c_void,
7837 ) -> *mut spa_source;
7838}
7839unsafe extern "C" {
7840 #[link_name = "spa_loop_utils_enable_idle_libspa_rs"]
7841 pub fn spa_loop_utils_enable_idle(
7842 object: *mut spa_loop_utils,
7843 source: *mut spa_source,
7844 enabled: bool,
7845 ) -> ::std::os::raw::c_int;
7846}
7847unsafe extern "C" {
7848 #[link_name = "spa_loop_utils_add_event_libspa_rs"]
7849 pub fn spa_loop_utils_add_event(
7850 object: *mut spa_loop_utils,
7851 func: spa_source_event_func_t,
7852 data: *mut ::std::os::raw::c_void,
7853 ) -> *mut spa_source;
7854}
7855unsafe extern "C" {
7856 #[link_name = "spa_loop_utils_signal_event_libspa_rs"]
7857 pub fn spa_loop_utils_signal_event(
7858 object: *mut spa_loop_utils,
7859 source: *mut spa_source,
7860 ) -> ::std::os::raw::c_int;
7861}
7862unsafe extern "C" {
7863 #[link_name = "spa_loop_utils_add_timer_libspa_rs"]
7864 pub fn spa_loop_utils_add_timer(
7865 object: *mut spa_loop_utils,
7866 func: spa_source_timer_func_t,
7867 data: *mut ::std::os::raw::c_void,
7868 ) -> *mut spa_source;
7869}
7870unsafe extern "C" {
7871 #[link_name = "spa_loop_utils_update_timer_libspa_rs"]
7872 pub fn spa_loop_utils_update_timer(
7873 object: *mut spa_loop_utils,
7874 source: *mut spa_source,
7875 value: *mut timespec,
7876 interval: *mut timespec,
7877 absolute: bool,
7878 ) -> ::std::os::raw::c_int;
7879}
7880unsafe extern "C" {
7881 #[link_name = "spa_loop_utils_add_signal_libspa_rs"]
7882 pub fn spa_loop_utils_add_signal(
7883 object: *mut spa_loop_utils,
7884 signal_number: ::std::os::raw::c_int,
7885 func: spa_source_signal_func_t,
7886 data: *mut ::std::os::raw::c_void,
7887 ) -> *mut spa_source;
7888}
7889unsafe extern "C" {
7890 #[link_name = "spa_loop_utils_destroy_source_libspa_rs"]
7891 pub fn spa_loop_utils_destroy_source(object: *mut spa_loop_utils, source: *mut spa_source);
7892}
7893#[repr(C)]
7894#[derive(Debug, Copy, Clone, PartialEq, Eq)]
7895pub struct spa_dbus {
7896 pub iface: spa_interface,
7897}
7898#[allow(clippy::unnecessary_operation, clippy::identity_op)]
7899const _: () = {
7900 ["Size of spa_dbus"][::std::mem::size_of::<spa_dbus>() - 32usize];
7901 ["Alignment of spa_dbus"][::std::mem::align_of::<spa_dbus>() - 8usize];
7902 ["Offset of field: spa_dbus::iface"][::std::mem::offset_of!(spa_dbus, iface) - 0usize];
7903};
7904#[doc = "< The login session bus"]
7905pub const SPA_DBUS_TYPE_SESSION: spa_dbus_type = 0;
7906#[doc = "< The systemwide bus"]
7907pub const SPA_DBUS_TYPE_SYSTEM: spa_dbus_type = 1;
7908#[doc = "< The bus that started us, if any"]
7909pub const SPA_DBUS_TYPE_STARTER: spa_dbus_type = 2;
7910pub type spa_dbus_type = ::std::os::raw::c_uint;
7911#[repr(C)]
7912#[derive(Debug, Copy, Clone, PartialEq, Eq)]
7913pub struct spa_dbus_connection_events {
7914 pub version: u32,
7915 pub destroy: ::std::option::Option<unsafe extern "C" fn(data: *mut ::std::os::raw::c_void)>,
7916 pub disconnected:
7917 ::std::option::Option<unsafe extern "C" fn(data: *mut ::std::os::raw::c_void)>,
7918}
7919#[allow(clippy::unnecessary_operation, clippy::identity_op)]
7920const _: () = {
7921 ["Size of spa_dbus_connection_events"]
7922 [::std::mem::size_of::<spa_dbus_connection_events>() - 24usize];
7923 ["Alignment of spa_dbus_connection_events"]
7924 [::std::mem::align_of::<spa_dbus_connection_events>() - 8usize];
7925 ["Offset of field: spa_dbus_connection_events::version"]
7926 [::std::mem::offset_of!(spa_dbus_connection_events, version) - 0usize];
7927 ["Offset of field: spa_dbus_connection_events::destroy"]
7928 [::std::mem::offset_of!(spa_dbus_connection_events, destroy) - 8usize];
7929 ["Offset of field: spa_dbus_connection_events::disconnected"]
7930 [::std::mem::offset_of!(spa_dbus_connection_events, disconnected) - 16usize];
7931};
7932#[repr(C)]
7933#[derive(Debug, Copy, Clone, PartialEq, Eq)]
7934pub struct spa_dbus_connection {
7935 pub version: u32,
7936 #[doc = " Get the DBusConnection from a wrapper\n\n Note that the returned handle is closed and unref'd by spa_dbus\n immediately before emitting the asynchronous \"disconnected\" event.\n The caller must either deal with the invalidation, or keep an extra\n ref on the handle returned.\n\n \\param conn the spa_dbus_connection wrapper\n \\return a pointer of type DBusConnection"]
7937 pub get: ::std::option::Option<
7938 unsafe extern "C" fn(conn: *mut spa_dbus_connection) -> *mut ::std::os::raw::c_void,
7939 >,
7940 #[doc = " Destroy a dbus connection wrapper\n\n \\param conn the wrapper to destroy"]
7941 pub destroy: ::std::option::Option<unsafe extern "C" fn(conn: *mut spa_dbus_connection)>,
7942 #[doc = " Add a listener for events\n\n Since version 1"]
7943 pub add_listener: ::std::option::Option<
7944 unsafe extern "C" fn(
7945 conn: *mut spa_dbus_connection,
7946 listener: *mut spa_hook,
7947 events: *const spa_dbus_connection_events,
7948 data: *mut ::std::os::raw::c_void,
7949 ),
7950 >,
7951}
7952#[allow(clippy::unnecessary_operation, clippy::identity_op)]
7953const _: () = {
7954 ["Size of spa_dbus_connection"][::std::mem::size_of::<spa_dbus_connection>() - 32usize];
7955 ["Alignment of spa_dbus_connection"][::std::mem::align_of::<spa_dbus_connection>() - 8usize];
7956 ["Offset of field: spa_dbus_connection::version"]
7957 [::std::mem::offset_of!(spa_dbus_connection, version) - 0usize];
7958 ["Offset of field: spa_dbus_connection::get"]
7959 [::std::mem::offset_of!(spa_dbus_connection, get) - 8usize];
7960 ["Offset of field: spa_dbus_connection::destroy"]
7961 [::std::mem::offset_of!(spa_dbus_connection, destroy) - 16usize];
7962 ["Offset of field: spa_dbus_connection::add_listener"]
7963 [::std::mem::offset_of!(spa_dbus_connection, add_listener) - 24usize];
7964};
7965unsafe extern "C" {
7966 #[doc = " \\copydoc spa_dbus_connection.get\n \\sa spa_dbus_connection.get"]
7967 #[link_name = "spa_dbus_connection_get_libspa_rs"]
7968 pub fn spa_dbus_connection_get(conn: *mut spa_dbus_connection) -> *mut ::std::os::raw::c_void;
7969}
7970unsafe extern "C" {
7971 #[doc = " \\copydoc spa_dbus_connection.destroy\n \\sa spa_dbus_connection.destroy"]
7972 #[link_name = "spa_dbus_connection_destroy_libspa_rs"]
7973 pub fn spa_dbus_connection_destroy(conn: *mut spa_dbus_connection);
7974}
7975unsafe extern "C" {
7976 #[doc = " \\copydoc spa_dbus_connection.add_listener\n \\sa spa_dbus_connection.add_listener"]
7977 #[link_name = "spa_dbus_connection_add_listener_libspa_rs"]
7978 pub fn spa_dbus_connection_add_listener(
7979 conn: *mut spa_dbus_connection,
7980 listener: *mut spa_hook,
7981 events: *const spa_dbus_connection_events,
7982 data: *mut ::std::os::raw::c_void,
7983 );
7984}
7985#[repr(C)]
7986#[derive(Debug, Copy, Clone, PartialEq, Eq)]
7987pub struct spa_dbus_methods {
7988 pub version: u32,
7989 #[doc = " Get a new connection wrapper for the given bus type.\n\n The connection wrapper is completely configured to operate\n in the main context of the handle that manages the spa_dbus\n interface.\n\n \\param dbus the dbus manager\n \\param type the bus type to wrap\n \\param error location for the DBusError\n \\return a new dbus connection wrapper or NULL on error"]
7990 pub get_connection: ::std::option::Option<
7991 unsafe extern "C" fn(
7992 object: *mut ::std::os::raw::c_void,
7993 type_: spa_dbus_type,
7994 ) -> *mut spa_dbus_connection,
7995 >,
7996}
7997#[allow(clippy::unnecessary_operation, clippy::identity_op)]
7998const _: () = {
7999 ["Size of spa_dbus_methods"][::std::mem::size_of::<spa_dbus_methods>() - 16usize];
8000 ["Alignment of spa_dbus_methods"][::std::mem::align_of::<spa_dbus_methods>() - 8usize];
8001 ["Offset of field: spa_dbus_methods::version"]
8002 [::std::mem::offset_of!(spa_dbus_methods, version) - 0usize];
8003 ["Offset of field: spa_dbus_methods::get_connection"]
8004 [::std::mem::offset_of!(spa_dbus_methods, get_connection) - 8usize];
8005};
8006unsafe extern "C" {
8007 #[doc = " \\copydoc spa_dbus_methods.get_connection\n \\sa spa_dbus_methods.get_connection"]
8008 #[link_name = "spa_dbus_get_connection_libspa_rs"]
8009 pub fn spa_dbus_get_connection(
8010 dbus: *mut spa_dbus,
8011 type_: spa_dbus_type,
8012 ) -> *mut spa_dbus_connection;
8013}
8014#[repr(C)]
8015#[derive(Debug, Copy, Clone, PartialEq, Eq)]
8016pub struct spa_i18n {
8017 pub iface: spa_interface,
8018}
8019#[allow(clippy::unnecessary_operation, clippy::identity_op)]
8020const _: () = {
8021 ["Size of spa_i18n"][::std::mem::size_of::<spa_i18n>() - 32usize];
8022 ["Alignment of spa_i18n"][::std::mem::align_of::<spa_i18n>() - 8usize];
8023 ["Offset of field: spa_i18n::iface"][::std::mem::offset_of!(spa_i18n, iface) - 0usize];
8024};
8025#[repr(C)]
8026#[derive(Debug, Copy, Clone, PartialEq, Eq)]
8027pub struct spa_i18n_methods {
8028 pub version: u32,
8029 #[doc = " Translate a message\n\n \\param object the i18n interface\n \\param msgid the message\n \\return a translated message"]
8030 pub text: ::std::option::Option<
8031 unsafe extern "C" fn(
8032 object: *mut ::std::os::raw::c_void,
8033 msgid: *const ::std::os::raw::c_char,
8034 ) -> *const ::std::os::raw::c_char,
8035 >,
8036 #[doc = " Translate a message for a number\n\n \\param object the i18n interface\n \\param msgid the message to translate\n \\param msgid_plural the plural form of \\a msgid\n \\param n a number\n \\return a translated message for the number \\a n"]
8037 pub ntext: ::std::option::Option<
8038 unsafe extern "C" fn(
8039 object: *mut ::std::os::raw::c_void,
8040 msgid: *const ::std::os::raw::c_char,
8041 msgid_plural: *const ::std::os::raw::c_char,
8042 n: ::std::os::raw::c_ulong,
8043 ) -> *const ::std::os::raw::c_char,
8044 >,
8045}
8046#[allow(clippy::unnecessary_operation, clippy::identity_op)]
8047const _: () = {
8048 ["Size of spa_i18n_methods"][::std::mem::size_of::<spa_i18n_methods>() - 24usize];
8049 ["Alignment of spa_i18n_methods"][::std::mem::align_of::<spa_i18n_methods>() - 8usize];
8050 ["Offset of field: spa_i18n_methods::version"]
8051 [::std::mem::offset_of!(spa_i18n_methods, version) - 0usize];
8052 ["Offset of field: spa_i18n_methods::text"]
8053 [::std::mem::offset_of!(spa_i18n_methods, text) - 8usize];
8054 ["Offset of field: spa_i18n_methods::ntext"]
8055 [::std::mem::offset_of!(spa_i18n_methods, ntext) - 16usize];
8056};
8057unsafe extern "C" {
8058 #[link_name = "spa_i18n_text_libspa_rs"]
8059 pub fn spa_i18n_text(
8060 i18n: *mut spa_i18n,
8061 msgid: *const ::std::os::raw::c_char,
8062 ) -> *const ::std::os::raw::c_char;
8063}
8064unsafe extern "C" {
8065 #[link_name = "spa_i18n_ntext_libspa_rs"]
8066 pub fn spa_i18n_ntext(
8067 i18n: *mut spa_i18n,
8068 msgid: *const ::std::os::raw::c_char,
8069 msgid_plural: *const ::std::os::raw::c_char,
8070 n: ::std::os::raw::c_ulong,
8071 ) -> *const ::std::os::raw::c_char;
8072}
8073pub const SPA_LOG_LEVEL_NONE: spa_log_level = 0;
8074pub const SPA_LOG_LEVEL_ERROR: spa_log_level = 1;
8075pub const SPA_LOG_LEVEL_WARN: spa_log_level = 2;
8076pub const SPA_LOG_LEVEL_INFO: spa_log_level = 3;
8077pub const SPA_LOG_LEVEL_DEBUG: spa_log_level = 4;
8078pub const SPA_LOG_LEVEL_TRACE: spa_log_level = 5;
8079pub type spa_log_level = ::std::os::raw::c_uint;
8080#[repr(C)]
8081#[derive(Debug, Copy, Clone, PartialEq, Eq)]
8082pub struct spa_log {
8083 pub iface: spa_interface,
8084 #[doc = " Logging level, everything above this level is not logged"]
8085 pub level: spa_log_level,
8086}
8087#[allow(clippy::unnecessary_operation, clippy::identity_op)]
8088const _: () = {
8089 ["Size of spa_log"][::std::mem::size_of::<spa_log>() - 40usize];
8090 ["Alignment of spa_log"][::std::mem::align_of::<spa_log>() - 8usize];
8091 ["Offset of field: spa_log::iface"][::std::mem::offset_of!(spa_log, iface) - 0usize];
8092 ["Offset of field: spa_log::level"][::std::mem::offset_of!(spa_log, level) - 32usize];
8093};
8094#[doc = " \\struct spa_log_topic\n\n Identifier for a topic. Topics are string-based filters that logically\n group messages together. An implementation may decide to filter different\n topics on different levels, for example the \"protocol\" topic may require\n debug level TRACE while the \"core\" topic defaults to debug level INFO.\n\n spa_log_topics require a spa_log_methods version of 1 or higher."]
8095#[repr(C)]
8096#[derive(Debug, Copy, Clone, PartialEq, Eq)]
8097pub struct spa_log_topic {
8098 #[doc = " the version of this topic. This can be used to expand this\n structure in the future"]
8099 pub version: u32,
8100 #[doc = " The string identifier for the topic"]
8101 pub topic: *const ::std::os::raw::c_char,
8102 #[doc = " Logging level set for this topic"]
8103 pub level: spa_log_level,
8104 #[doc = " False if this topic follows the \\ref spa_log level"]
8105 pub has_custom_level: bool,
8106}
8107#[allow(clippy::unnecessary_operation, clippy::identity_op)]
8108const _: () = {
8109 ["Size of spa_log_topic"][::std::mem::size_of::<spa_log_topic>() - 24usize];
8110 ["Alignment of spa_log_topic"][::std::mem::align_of::<spa_log_topic>() - 8usize];
8111 ["Offset of field: spa_log_topic::version"]
8112 [::std::mem::offset_of!(spa_log_topic, version) - 0usize];
8113 ["Offset of field: spa_log_topic::topic"]
8114 [::std::mem::offset_of!(spa_log_topic, topic) - 8usize];
8115 ["Offset of field: spa_log_topic::level"]
8116 [::std::mem::offset_of!(spa_log_topic, level) - 16usize];
8117 ["Offset of field: spa_log_topic::has_custom_level"]
8118 [::std::mem::offset_of!(spa_log_topic, has_custom_level) - 20usize];
8119};
8120#[doc = " Enumeration of log topics in a plugin\n\n \\since 1.1.0"]
8121#[repr(C)]
8122#[derive(Debug, Copy, Clone, PartialEq, Eq)]
8123pub struct spa_log_topic_enum {
8124 pub version: u32,
8125 #[doc = " Array of pointers to log topics"]
8126 pub topics: *const *mut spa_log_topic,
8127 #[doc = " End of topics array"]
8128 pub topics_end: *const *mut spa_log_topic,
8129}
8130#[allow(clippy::unnecessary_operation, clippy::identity_op)]
8131const _: () = {
8132 ["Size of spa_log_topic_enum"][::std::mem::size_of::<spa_log_topic_enum>() - 24usize];
8133 ["Alignment of spa_log_topic_enum"][::std::mem::align_of::<spa_log_topic_enum>() - 8usize];
8134 ["Offset of field: spa_log_topic_enum::version"]
8135 [::std::mem::offset_of!(spa_log_topic_enum, version) - 0usize];
8136 ["Offset of field: spa_log_topic_enum::topics"]
8137 [::std::mem::offset_of!(spa_log_topic_enum, topics) - 8usize];
8138 ["Offset of field: spa_log_topic_enum::topics_end"]
8139 [::std::mem::offset_of!(spa_log_topic_enum, topics_end) - 16usize];
8140};
8141#[repr(C)]
8142#[derive(Debug, Copy, Clone, PartialEq, Eq)]
8143pub struct spa_log_methods {
8144 pub version: u32,
8145 #[doc = " Log a message with the given log level.\n\n \\note If compiled with this header, this function is only called\n for implementations of version 0. For versions 1 and above, see\n logt() instead.\n\n \\param log a spa_log\n \\param level a spa_log_level\n \\param file the file name\n \\param line the line number\n \\param func the function name\n \\param fmt printf style format\n \\param ... format arguments"]
8146 pub log: ::std::option::Option<
8147 unsafe extern "C" fn(
8148 object: *mut ::std::os::raw::c_void,
8149 level: spa_log_level,
8150 file: *const ::std::os::raw::c_char,
8151 line: ::std::os::raw::c_int,
8152 func: *const ::std::os::raw::c_char,
8153 fmt: *const ::std::os::raw::c_char,
8154 ...
8155 ),
8156 >,
8157 #[doc = " Log a message with the given log level.\n\n \\note If compiled with this header, this function is only called\n for implementations of version 0. For versions 1 and above, see\n logtv() instead.\n\n \\param log a spa_log\n \\param level a spa_log_level\n \\param file the file name\n \\param line the line number\n \\param func the function name\n \\param fmt printf style format\n \\param args format arguments"]
8158 pub logv: ::std::option::Option<
8159 unsafe extern "C" fn(
8160 object: *mut ::std::os::raw::c_void,
8161 level: spa_log_level,
8162 file: *const ::std::os::raw::c_char,
8163 line: ::std::os::raw::c_int,
8164 func: *const ::std::os::raw::c_char,
8165 fmt: *const ::std::os::raw::c_char,
8166 args: *mut __va_list_tag,
8167 ),
8168 >,
8169 #[doc = " Log a message with the given log level for the given topic.\n\n \\note Callers that do not use topic-based logging (version 0), the \\a\n topic is NULL\n\n \\param log a spa_log\n \\param level a spa_log_level\n \\param topic the topic for this message, may be NULL\n \\param file the file name\n \\param line the line number\n \\param func the function name\n \\param fmt printf style format\n \\param ... format arguments\n\n \\since 1"]
8170 pub logt: ::std::option::Option<
8171 unsafe extern "C" fn(
8172 object: *mut ::std::os::raw::c_void,
8173 level: spa_log_level,
8174 topic: *const spa_log_topic,
8175 file: *const ::std::os::raw::c_char,
8176 line: ::std::os::raw::c_int,
8177 func: *const ::std::os::raw::c_char,
8178 fmt: *const ::std::os::raw::c_char,
8179 ...
8180 ),
8181 >,
8182 #[doc = " Log a message with the given log level for the given topic.\n\n \\note For callers that do not use topic-based logging (version 0),\n the \\a topic is NULL\n\n \\param log a spa_log\n \\param level a spa_log_level\n \\param topic the topic for this message, may be NULL\n \\param file the file name\n \\param line the line number\n \\param func the function name\n \\param fmt printf style format\n \\param args format arguments\n\n \\since 1"]
8183 pub logtv: ::std::option::Option<
8184 unsafe extern "C" fn(
8185 object: *mut ::std::os::raw::c_void,
8186 level: spa_log_level,
8187 topic: *const spa_log_topic,
8188 file: *const ::std::os::raw::c_char,
8189 line: ::std::os::raw::c_int,
8190 func: *const ::std::os::raw::c_char,
8191 fmt: *const ::std::os::raw::c_char,
8192 args: *mut __va_list_tag,
8193 ),
8194 >,
8195 #[doc = " Initializes a \\ref spa_log_topic to the correct logging level.\n\n \\deprecated\n Plugin host should obtain log topics from \\ref SPA_LOG_TOPIC_ENUM_NAME\n and update them itself.\n\n \\since 1"]
8196 pub topic_init: ::std::option::Option<
8197 unsafe extern "C" fn(object: *mut ::std::os::raw::c_void, topic: *mut spa_log_topic),
8198 >,
8199}
8200#[allow(clippy::unnecessary_operation, clippy::identity_op)]
8201const _: () = {
8202 ["Size of spa_log_methods"][::std::mem::size_of::<spa_log_methods>() - 48usize];
8203 ["Alignment of spa_log_methods"][::std::mem::align_of::<spa_log_methods>() - 8usize];
8204 ["Offset of field: spa_log_methods::version"]
8205 [::std::mem::offset_of!(spa_log_methods, version) - 0usize];
8206 ["Offset of field: spa_log_methods::log"]
8207 [::std::mem::offset_of!(spa_log_methods, log) - 8usize];
8208 ["Offset of field: spa_log_methods::logv"]
8209 [::std::mem::offset_of!(spa_log_methods, logv) - 16usize];
8210 ["Offset of field: spa_log_methods::logt"]
8211 [::std::mem::offset_of!(spa_log_methods, logt) - 24usize];
8212 ["Offset of field: spa_log_methods::logtv"]
8213 [::std::mem::offset_of!(spa_log_methods, logtv) - 32usize];
8214 ["Offset of field: spa_log_methods::topic_init"]
8215 [::std::mem::offset_of!(spa_log_methods, topic_init) - 40usize];
8216};
8217unsafe extern "C" {
8218 #[link_name = "spa_log_topic_init_libspa_rs"]
8219 pub fn spa_log_topic_init(log: *mut spa_log, topic: *mut spa_log_topic);
8220}
8221unsafe extern "C" {
8222 #[link_name = "spa_log_level_topic_enabled_libspa_rs"]
8223 pub fn spa_log_level_topic_enabled(
8224 log: *const spa_log,
8225 topic: *const spa_log_topic,
8226 level: spa_log_level,
8227 ) -> bool;
8228}
8229unsafe extern "C" {
8230 #[link_name = "spa_log_logtv_libspa_rs"]
8231 pub fn spa_log_logtv(
8232 l: *mut spa_log,
8233 level: spa_log_level,
8234 topic: *const spa_log_topic,
8235 file: *const ::std::os::raw::c_char,
8236 line: ::std::os::raw::c_int,
8237 func: *const ::std::os::raw::c_char,
8238 fmt: *const ::std::os::raw::c_char,
8239 args: *mut __va_list_tag,
8240 );
8241}
8242unsafe extern "C" {
8243 #[doc = " \\addtogroup spa_log\n \\{"]
8244 #[link_name = "spa_log_impl_logtv_libspa_rs"]
8245 pub fn spa_log_impl_logtv(
8246 object: *mut ::std::os::raw::c_void,
8247 level: spa_log_level,
8248 topic: *const spa_log_topic,
8249 file: *const ::std::os::raw::c_char,
8250 line: ::std::os::raw::c_int,
8251 func: *const ::std::os::raw::c_char,
8252 fmt: *const ::std::os::raw::c_char,
8253 args: *mut __va_list_tag,
8254 );
8255}
8256unsafe extern "C" {
8257 #[link_name = "spa_log_impl_logv_libspa_rs"]
8258 pub fn spa_log_impl_logv(
8259 object: *mut ::std::os::raw::c_void,
8260 level: spa_log_level,
8261 file: *const ::std::os::raw::c_char,
8262 line: ::std::os::raw::c_int,
8263 func: *const ::std::os::raw::c_char,
8264 fmt: *const ::std::os::raw::c_char,
8265 args: *mut __va_list_tag,
8266 );
8267}
8268unsafe extern "C" {
8269 #[link_name = "spa_log_impl_topic_init_libspa_rs"]
8270 pub fn spa_log_impl_topic_init(object: *mut ::std::os::raw::c_void, topic: *mut spa_log_topic);
8271}
8272#[repr(C)]
8273#[derive(Debug, Copy, Clone, PartialEq, Eq)]
8274pub struct spa_plugin_loader {
8275 pub iface: spa_interface,
8276}
8277#[allow(clippy::unnecessary_operation, clippy::identity_op)]
8278const _: () = {
8279 ["Size of spa_plugin_loader"][::std::mem::size_of::<spa_plugin_loader>() - 32usize];
8280 ["Alignment of spa_plugin_loader"][::std::mem::align_of::<spa_plugin_loader>() - 8usize];
8281 ["Offset of field: spa_plugin_loader::iface"]
8282 [::std::mem::offset_of!(spa_plugin_loader, iface) - 0usize];
8283};
8284#[repr(C)]
8285#[derive(Debug, Copy, Clone, PartialEq, Eq)]
8286pub struct spa_plugin_loader_methods {
8287 pub version: u32,
8288 #[doc = " Load a SPA plugin.\n\n \\param factory_name Plugin factory name\n \\param info Info dictionary for plugin. NULL if none.\n \\return plugin handle, or NULL on error"]
8289 pub load: ::std::option::Option<
8290 unsafe extern "C" fn(
8291 object: *mut ::std::os::raw::c_void,
8292 factory_name: *const ::std::os::raw::c_char,
8293 info: *const spa_dict,
8294 ) -> *mut spa_handle,
8295 >,
8296 #[doc = " Unload a SPA plugin.\n\n \\param handle Plugin handle.\n \\return 0 on success, < 0 on error"]
8297 pub unload: ::std::option::Option<
8298 unsafe extern "C" fn(
8299 object: *mut ::std::os::raw::c_void,
8300 handle: *mut spa_handle,
8301 ) -> ::std::os::raw::c_int,
8302 >,
8303}
8304#[allow(clippy::unnecessary_operation, clippy::identity_op)]
8305const _: () = {
8306 ["Size of spa_plugin_loader_methods"]
8307 [::std::mem::size_of::<spa_plugin_loader_methods>() - 24usize];
8308 ["Alignment of spa_plugin_loader_methods"]
8309 [::std::mem::align_of::<spa_plugin_loader_methods>() - 8usize];
8310 ["Offset of field: spa_plugin_loader_methods::version"]
8311 [::std::mem::offset_of!(spa_plugin_loader_methods, version) - 0usize];
8312 ["Offset of field: spa_plugin_loader_methods::load"]
8313 [::std::mem::offset_of!(spa_plugin_loader_methods, load) - 8usize];
8314 ["Offset of field: spa_plugin_loader_methods::unload"]
8315 [::std::mem::offset_of!(spa_plugin_loader_methods, unload) - 16usize];
8316};
8317unsafe extern "C" {
8318 #[link_name = "spa_plugin_loader_load_libspa_rs"]
8319 pub fn spa_plugin_loader_load(
8320 loader: *mut spa_plugin_loader,
8321 factory_name: *const ::std::os::raw::c_char,
8322 info: *const spa_dict,
8323 ) -> *mut spa_handle;
8324}
8325unsafe extern "C" {
8326 #[link_name = "spa_plugin_loader_unload_libspa_rs"]
8327 pub fn spa_plugin_loader_unload(
8328 loader: *mut spa_plugin_loader,
8329 handle: *mut spa_handle,
8330 ) -> ::std::os::raw::c_int;
8331}
8332#[doc = " \\addtogroup spa_handle\n \\{"]
8333#[repr(C)]
8334#[derive(Debug, Copy, Clone, PartialEq, Eq)]
8335pub struct spa_handle {
8336 pub version: u32,
8337 #[doc = " Get the interface provided by \\a handle with \\a type.\n\n \\a interface is always a struct spa_interface but depending on\n \\a type, the struct might contain other information.\n\n \\param handle a spa_handle\n \\param type the interface type\n \\param iface result to hold the interface.\n \\return 0 on success\n -ENOTSUP when there are no interfaces\n -EINVAL when handle or info is NULL"]
8338 pub get_interface: ::std::option::Option<
8339 unsafe extern "C" fn(
8340 handle: *mut spa_handle,
8341 type_: *const ::std::os::raw::c_char,
8342 iface: *mut *mut ::std::os::raw::c_void,
8343 ) -> ::std::os::raw::c_int,
8344 >,
8345 #[doc = " Clean up the memory of \\a handle. After this, \\a handle should not be used\n anymore.\n\n \\param handle a pointer to memory\n \\return 0 on success"]
8346 pub clear: ::std::option::Option<
8347 unsafe extern "C" fn(handle: *mut spa_handle) -> ::std::os::raw::c_int,
8348 >,
8349}
8350#[allow(clippy::unnecessary_operation, clippy::identity_op)]
8351const _: () = {
8352 ["Size of spa_handle"][::std::mem::size_of::<spa_handle>() - 24usize];
8353 ["Alignment of spa_handle"][::std::mem::align_of::<spa_handle>() - 8usize];
8354 ["Offset of field: spa_handle::version"][::std::mem::offset_of!(spa_handle, version) - 0usize];
8355 ["Offset of field: spa_handle::get_interface"]
8356 [::std::mem::offset_of!(spa_handle, get_interface) - 8usize];
8357 ["Offset of field: spa_handle::clear"][::std::mem::offset_of!(spa_handle, clear) - 16usize];
8358};
8359unsafe extern "C" {
8360 #[link_name = "spa_handle_get_interface_libspa_rs"]
8361 pub fn spa_handle_get_interface(
8362 object: *mut spa_handle,
8363 type_: *const ::std::os::raw::c_char,
8364 iface: *mut *mut ::std::os::raw::c_void,
8365 ) -> ::std::os::raw::c_int;
8366}
8367unsafe extern "C" {
8368 #[link_name = "spa_handle_clear_libspa_rs"]
8369 pub fn spa_handle_clear(object: *mut spa_handle) -> ::std::os::raw::c_int;
8370}
8371#[doc = " This structure lists the information about available interfaces on\n handles."]
8372#[repr(C)]
8373#[derive(Debug, Copy, Clone, PartialEq, Eq)]
8374pub struct spa_interface_info {
8375 pub type_: *const ::std::os::raw::c_char,
8376}
8377#[allow(clippy::unnecessary_operation, clippy::identity_op)]
8378const _: () = {
8379 ["Size of spa_interface_info"][::std::mem::size_of::<spa_interface_info>() - 8usize];
8380 ["Alignment of spa_interface_info"][::std::mem::align_of::<spa_interface_info>() - 8usize];
8381 ["Offset of field: spa_interface_info::type_"]
8382 [::std::mem::offset_of!(spa_interface_info, type_) - 0usize];
8383};
8384#[doc = " Extra supporting infrastructure passed to the init() function of\n a factory. It can be extra information or interfaces such as logging."]
8385#[repr(C)]
8386#[derive(Debug, Copy, Clone, PartialEq, Eq)]
8387pub struct spa_support {
8388 pub type_: *const ::std::os::raw::c_char,
8389 pub data: *mut ::std::os::raw::c_void,
8390}
8391#[allow(clippy::unnecessary_operation, clippy::identity_op)]
8392const _: () = {
8393 ["Size of spa_support"][::std::mem::size_of::<spa_support>() - 16usize];
8394 ["Alignment of spa_support"][::std::mem::align_of::<spa_support>() - 8usize];
8395 ["Offset of field: spa_support::type_"][::std::mem::offset_of!(spa_support, type_) - 0usize];
8396 ["Offset of field: spa_support::data"][::std::mem::offset_of!(spa_support, data) - 8usize];
8397};
8398unsafe extern "C" {
8399 #[doc = " Find a support item of the given type"]
8400 #[link_name = "spa_support_find_libspa_rs"]
8401 pub fn spa_support_find(
8402 support: *const spa_support,
8403 n_support: u32,
8404 type_: *const ::std::os::raw::c_char,
8405 ) -> *mut ::std::os::raw::c_void;
8406}
8407#[repr(C)]
8408#[derive(Debug, Copy, Clone, PartialEq, Eq)]
8409pub struct spa_handle_factory {
8410 pub version: u32,
8411 #[doc = " The name of the factory contains a logical name that describes\n the function of the handle. Other plugins might contain an alternative\n implementation with the same name.\n\n See utils/names.h for the list of standard names.\n\n Examples include:\n\n api.alsa.pcm.sink: an object to write PCM samples to an alsa PLAYBACK\n\t\t\tdevice\n api.v4l2.source: an object to read from a v4l2 source."]
8412 pub name: *const ::std::os::raw::c_char,
8413 #[doc = " Extra information about the handles of this factory."]
8414 pub info: *const spa_dict,
8415 #[doc = " Get the size of handles from this factory.\n\n \\param factory a spa_handle_factory\n \\param params extra parameters that determine the size of the\n handle."]
8416 pub get_size: ::std::option::Option<
8417 unsafe extern "C" fn(factory: *const spa_handle_factory, params: *const spa_dict) -> usize,
8418 >,
8419 #[doc = " Initialize an instance of this factory. The caller should allocate\n memory at least size bytes and pass this as \\a handle.\n\n \\a support can optionally contain extra interfaces or data items that the\n plugin can use such as a logger.\n\n \\param factory a spa_handle_factory\n \\param handle a pointer to memory\n \\param info extra handle specific information, usually obtained\n from a spa_device. This can be used to configure the handle.\n \\param support support items\n \\param n_support number of elements in \\a support\n \\return 0 on success\n\t < 0 errno type error"]
8420 pub init: ::std::option::Option<
8421 unsafe extern "C" fn(
8422 factory: *const spa_handle_factory,
8423 handle: *mut spa_handle,
8424 info: *const spa_dict,
8425 support: *const spa_support,
8426 n_support: u32,
8427 ) -> ::std::os::raw::c_int,
8428 >,
8429 #[doc = " spa_handle_factory::enum_interface_info:\n \\param factory: a #spa_handle_factory\n \\param info: result to hold spa_interface_info.\n \\param index: index to keep track of the enumeration, 0 for first item\n\n Enumerate the interface information for \\a factory.\n\n \\return 1 when an item is available\n\t 0 when no more items are available\n\t < 0 errno type error"]
8430 pub enum_interface_info: ::std::option::Option<
8431 unsafe extern "C" fn(
8432 factory: *const spa_handle_factory,
8433 info: *mut *const spa_interface_info,
8434 index: *mut u32,
8435 ) -> ::std::os::raw::c_int,
8436 >,
8437}
8438#[allow(clippy::unnecessary_operation, clippy::identity_op)]
8439const _: () = {
8440 ["Size of spa_handle_factory"][::std::mem::size_of::<spa_handle_factory>() - 48usize];
8441 ["Alignment of spa_handle_factory"][::std::mem::align_of::<spa_handle_factory>() - 8usize];
8442 ["Offset of field: spa_handle_factory::version"]
8443 [::std::mem::offset_of!(spa_handle_factory, version) - 0usize];
8444 ["Offset of field: spa_handle_factory::name"]
8445 [::std::mem::offset_of!(spa_handle_factory, name) - 8usize];
8446 ["Offset of field: spa_handle_factory::info"]
8447 [::std::mem::offset_of!(spa_handle_factory, info) - 16usize];
8448 ["Offset of field: spa_handle_factory::get_size"]
8449 [::std::mem::offset_of!(spa_handle_factory, get_size) - 24usize];
8450 ["Offset of field: spa_handle_factory::init"]
8451 [::std::mem::offset_of!(spa_handle_factory, init) - 32usize];
8452 ["Offset of field: spa_handle_factory::enum_interface_info"]
8453 [::std::mem::offset_of!(spa_handle_factory, enum_interface_info) - 40usize];
8454};
8455unsafe extern "C" {
8456 #[link_name = "spa_handle_factory_get_size_libspa_rs"]
8457 pub fn spa_handle_factory_get_size(
8458 object: *const spa_handle_factory,
8459 params: *const spa_dict,
8460 ) -> usize;
8461}
8462unsafe extern "C" {
8463 #[link_name = "spa_handle_factory_init_libspa_rs"]
8464 pub fn spa_handle_factory_init(
8465 object: *const spa_handle_factory,
8466 handle: *mut spa_handle,
8467 info: *const spa_dict,
8468 support: *const spa_support,
8469 n_support: u32,
8470 ) -> ::std::os::raw::c_int;
8471}
8472unsafe extern "C" {
8473 #[link_name = "spa_handle_factory_enum_interface_info_libspa_rs"]
8474 pub fn spa_handle_factory_enum_interface_info(
8475 object: *const spa_handle_factory,
8476 info: *mut *const spa_interface_info,
8477 index: *mut u32,
8478 ) -> ::std::os::raw::c_int;
8479}
8480#[doc = " The function signature of the entry point in a plugin.\n\n \\param factory a location to hold the factory result\n \\param index index to keep track of the enumeration\n \\return 1 on success\n 0 when there are no more factories\n -EINVAL when factory is NULL"]
8481pub type spa_handle_factory_enum_func_t = ::std::option::Option<
8482 unsafe extern "C" fn(
8483 factory: *mut *const spa_handle_factory,
8484 index: *mut u32,
8485 ) -> ::std::os::raw::c_int,
8486>;
8487unsafe extern "C" {
8488 #[doc = " The entry point in a plugin.\n\n \\param factory a location to hold the factory result\n \\param index index to keep track of the enumeration\n \\return 1 on success\n\t 0 when no more items are available\n\t < 0 errno type error"]
8489 pub fn spa_handle_factory_enum(
8490 factory: *mut *const spa_handle_factory,
8491 index: *mut u32,
8492 ) -> ::std::os::raw::c_int;
8493}
8494#[repr(C)]
8495#[derive(Debug, Copy, Clone)]
8496pub struct spa_thread {
8497 _unused: [u8; 0],
8498}
8499#[repr(C)]
8500#[derive(Debug, Copy, Clone, PartialEq, Eq)]
8501pub struct spa_thread_utils {
8502 pub iface: spa_interface,
8503}
8504#[allow(clippy::unnecessary_operation, clippy::identity_op)]
8505const _: () = {
8506 ["Size of spa_thread_utils"][::std::mem::size_of::<spa_thread_utils>() - 32usize];
8507 ["Alignment of spa_thread_utils"][::std::mem::align_of::<spa_thread_utils>() - 8usize];
8508 ["Offset of field: spa_thread_utils::iface"]
8509 [::std::mem::offset_of!(spa_thread_utils, iface) - 0usize];
8510};
8511#[doc = " thread utils"]
8512#[repr(C)]
8513#[derive(Debug, Copy, Clone, PartialEq, Eq)]
8514pub struct spa_thread_utils_methods {
8515 pub version: u32,
8516 #[doc = " create a new thread that runs \\a start with \\a arg"]
8517 pub create: ::std::option::Option<
8518 unsafe extern "C" fn(
8519 object: *mut ::std::os::raw::c_void,
8520 props: *const spa_dict,
8521 start: ::std::option::Option<
8522 unsafe extern "C" fn(
8523 arg1: *mut ::std::os::raw::c_void,
8524 ) -> *mut ::std::os::raw::c_void,
8525 >,
8526 arg: *mut ::std::os::raw::c_void,
8527 ) -> *mut spa_thread,
8528 >,
8529 #[doc = " stop and join a thread"]
8530 pub join: ::std::option::Option<
8531 unsafe extern "C" fn(
8532 object: *mut ::std::os::raw::c_void,
8533 thread: *mut spa_thread,
8534 retval: *mut *mut ::std::os::raw::c_void,
8535 ) -> ::std::os::raw::c_int,
8536 >,
8537 #[doc = " get realtime priority range for threads created with \\a props"]
8538 pub get_rt_range: ::std::option::Option<
8539 unsafe extern "C" fn(
8540 object: *mut ::std::os::raw::c_void,
8541 props: *const spa_dict,
8542 min: *mut ::std::os::raw::c_int,
8543 max: *mut ::std::os::raw::c_int,
8544 ) -> ::std::os::raw::c_int,
8545 >,
8546 #[doc = " acquire realtime priority, a priority of -1 refers to the priority\n configured in the realtime module"]
8547 pub acquire_rt: ::std::option::Option<
8548 unsafe extern "C" fn(
8549 object: *mut ::std::os::raw::c_void,
8550 thread: *mut spa_thread,
8551 priority: ::std::os::raw::c_int,
8552 ) -> ::std::os::raw::c_int,
8553 >,
8554 #[doc = " drop realtime priority"]
8555 pub drop_rt: ::std::option::Option<
8556 unsafe extern "C" fn(
8557 object: *mut ::std::os::raw::c_void,
8558 thread: *mut spa_thread,
8559 ) -> ::std::os::raw::c_int,
8560 >,
8561}
8562#[allow(clippy::unnecessary_operation, clippy::identity_op)]
8563const _: () = {
8564 ["Size of spa_thread_utils_methods"]
8565 [::std::mem::size_of::<spa_thread_utils_methods>() - 48usize];
8566 ["Alignment of spa_thread_utils_methods"]
8567 [::std::mem::align_of::<spa_thread_utils_methods>() - 8usize];
8568 ["Offset of field: spa_thread_utils_methods::version"]
8569 [::std::mem::offset_of!(spa_thread_utils_methods, version) - 0usize];
8570 ["Offset of field: spa_thread_utils_methods::create"]
8571 [::std::mem::offset_of!(spa_thread_utils_methods, create) - 8usize];
8572 ["Offset of field: spa_thread_utils_methods::join"]
8573 [::std::mem::offset_of!(spa_thread_utils_methods, join) - 16usize];
8574 ["Offset of field: spa_thread_utils_methods::get_rt_range"]
8575 [::std::mem::offset_of!(spa_thread_utils_methods, get_rt_range) - 24usize];
8576 ["Offset of field: spa_thread_utils_methods::acquire_rt"]
8577 [::std::mem::offset_of!(spa_thread_utils_methods, acquire_rt) - 32usize];
8578 ["Offset of field: spa_thread_utils_methods::drop_rt"]
8579 [::std::mem::offset_of!(spa_thread_utils_methods, drop_rt) - 40usize];
8580};
8581unsafe extern "C" {
8582 #[doc = " \\copydoc spa_thread_utils_methods.create\n \\sa spa_thread_utils_methods.create"]
8583 #[link_name = "spa_thread_utils_create_libspa_rs"]
8584 pub fn spa_thread_utils_create(
8585 o: *mut spa_thread_utils,
8586 props: *const spa_dict,
8587 start_routine: ::std::option::Option<
8588 unsafe extern "C" fn(arg1: *mut ::std::os::raw::c_void) -> *mut ::std::os::raw::c_void,
8589 >,
8590 arg: *mut ::std::os::raw::c_void,
8591 ) -> *mut spa_thread;
8592}
8593unsafe extern "C" {
8594 #[doc = " \\copydoc spa_thread_utils_methods.join\n \\sa spa_thread_utils_methods.join"]
8595 #[link_name = "spa_thread_utils_join_libspa_rs"]
8596 pub fn spa_thread_utils_join(
8597 o: *mut spa_thread_utils,
8598 thread: *mut spa_thread,
8599 retval: *mut *mut ::std::os::raw::c_void,
8600 ) -> ::std::os::raw::c_int;
8601}
8602unsafe extern "C" {
8603 #[doc = " \\copydoc spa_thread_utils_methods.get_rt_range\n \\sa spa_thread_utils_methods.get_rt_range"]
8604 #[link_name = "spa_thread_utils_get_rt_range_libspa_rs"]
8605 pub fn spa_thread_utils_get_rt_range(
8606 o: *mut spa_thread_utils,
8607 props: *const spa_dict,
8608 min: *mut ::std::os::raw::c_int,
8609 max: *mut ::std::os::raw::c_int,
8610 ) -> ::std::os::raw::c_int;
8611}
8612unsafe extern "C" {
8613 #[doc = " \\copydoc spa_thread_utils_methods.acquire_rt\n \\sa spa_thread_utils_methods.acquire_rt"]
8614 #[link_name = "spa_thread_utils_acquire_rt_libspa_rs"]
8615 pub fn spa_thread_utils_acquire_rt(
8616 o: *mut spa_thread_utils,
8617 thread: *mut spa_thread,
8618 priority: ::std::os::raw::c_int,
8619 ) -> ::std::os::raw::c_int;
8620}
8621unsafe extern "C" {
8622 #[doc = " \\copydoc spa_thread_utils_methods.drop_rt\n \\sa spa_thread_utils_methods.drop_rt"]
8623 #[link_name = "spa_thread_utils_drop_rt_libspa_rs"]
8624 pub fn spa_thread_utils_drop_rt(
8625 o: *mut spa_thread_utils,
8626 thread: *mut spa_thread,
8627 ) -> ::std::os::raw::c_int;
8628}
8629#[doc = " \\addtogroup spa_json\n \\{"]
8630#[repr(C)]
8631#[derive(Debug, Copy, Clone, PartialEq, Eq)]
8632pub struct spa_json {
8633 pub cur: *const ::std::os::raw::c_char,
8634 pub end: *const ::std::os::raw::c_char,
8635 pub parent: *mut spa_json,
8636 pub state: u32,
8637 pub depth: u32,
8638}
8639#[allow(clippy::unnecessary_operation, clippy::identity_op)]
8640const _: () = {
8641 ["Size of spa_json"][::std::mem::size_of::<spa_json>() - 32usize];
8642 ["Alignment of spa_json"][::std::mem::align_of::<spa_json>() - 8usize];
8643 ["Offset of field: spa_json::cur"][::std::mem::offset_of!(spa_json, cur) - 0usize];
8644 ["Offset of field: spa_json::end"][::std::mem::offset_of!(spa_json, end) - 8usize];
8645 ["Offset of field: spa_json::parent"][::std::mem::offset_of!(spa_json, parent) - 16usize];
8646 ["Offset of field: spa_json::state"][::std::mem::offset_of!(spa_json, state) - 24usize];
8647 ["Offset of field: spa_json::depth"][::std::mem::offset_of!(spa_json, depth) - 28usize];
8648};
8649unsafe extern "C" {
8650 #[link_name = "spa_json_init_libspa_rs"]
8651 pub fn spa_json_init(iter: *mut spa_json, data: *const ::std::os::raw::c_char, size: usize);
8652}
8653unsafe extern "C" {
8654 #[link_name = "spa_json_enter_libspa_rs"]
8655 pub fn spa_json_enter(iter: *mut spa_json, sub: *mut spa_json);
8656}
8657unsafe extern "C" {
8658 #[link_name = "spa_json_save_libspa_rs"]
8659 pub fn spa_json_save(iter: *mut spa_json, save: *mut spa_json);
8660}
8661unsafe extern "C" {
8662 #[link_name = "spa_json_start_libspa_rs"]
8663 pub fn spa_json_start(
8664 iter: *mut spa_json,
8665 sub: *mut spa_json,
8666 pos: *const ::std::os::raw::c_char,
8667 );
8668}
8669unsafe extern "C" {
8670 #[doc = " Get the next token. \\a value points to the token and the return value\n is the length. Returns -1 on parse error, 0 on end of input."]
8671 #[link_name = "spa_json_next_libspa_rs"]
8672 pub fn spa_json_next(
8673 iter: *mut spa_json,
8674 value: *mut *const ::std::os::raw::c_char,
8675 ) -> ::std::os::raw::c_int;
8676}
8677unsafe extern "C" {
8678 #[doc = " Return if there was a parse error, and its possible location.\n\n \\since 1.1.0"]
8679 #[link_name = "spa_json_get_error_libspa_rs"]
8680 pub fn spa_json_get_error(
8681 iter: *mut spa_json,
8682 start: *const ::std::os::raw::c_char,
8683 loc: *mut spa_error_location,
8684 ) -> bool;
8685}
8686unsafe extern "C" {
8687 #[link_name = "spa_json_is_container_libspa_rs"]
8688 pub fn spa_json_is_container(
8689 val: *const ::std::os::raw::c_char,
8690 len: ::std::os::raw::c_int,
8691 ) -> ::std::os::raw::c_int;
8692}
8693unsafe extern "C" {
8694 #[link_name = "spa_json_is_object_libspa_rs"]
8695 pub fn spa_json_is_object(
8696 val: *const ::std::os::raw::c_char,
8697 len: ::std::os::raw::c_int,
8698 ) -> ::std::os::raw::c_int;
8699}
8700unsafe extern "C" {
8701 #[link_name = "spa_json_is_array_libspa_rs"]
8702 pub fn spa_json_is_array(
8703 val: *const ::std::os::raw::c_char,
8704 len: ::std::os::raw::c_int,
8705 ) -> bool;
8706}
8707unsafe extern "C" {
8708 #[link_name = "spa_json_is_null_libspa_rs"]
8709 pub fn spa_json_is_null(val: *const ::std::os::raw::c_char, len: ::std::os::raw::c_int)
8710 -> bool;
8711}
8712unsafe extern "C" {
8713 #[link_name = "spa_json_parse_float_libspa_rs"]
8714 pub fn spa_json_parse_float(
8715 val: *const ::std::os::raw::c_char,
8716 len: ::std::os::raw::c_int,
8717 result: *mut f32,
8718 ) -> ::std::os::raw::c_int;
8719}
8720unsafe extern "C" {
8721 #[link_name = "spa_json_is_float_libspa_rs"]
8722 pub fn spa_json_is_float(
8723 val: *const ::std::os::raw::c_char,
8724 len: ::std::os::raw::c_int,
8725 ) -> bool;
8726}
8727unsafe extern "C" {
8728 #[link_name = "spa_json_format_float_libspa_rs"]
8729 pub fn spa_json_format_float(
8730 str_: *mut ::std::os::raw::c_char,
8731 size: ::std::os::raw::c_int,
8732 val: f32,
8733 ) -> *mut ::std::os::raw::c_char;
8734}
8735unsafe extern "C" {
8736 #[link_name = "spa_json_parse_int_libspa_rs"]
8737 pub fn spa_json_parse_int(
8738 val: *const ::std::os::raw::c_char,
8739 len: ::std::os::raw::c_int,
8740 result: *mut ::std::os::raw::c_int,
8741 ) -> ::std::os::raw::c_int;
8742}
8743unsafe extern "C" {
8744 #[link_name = "spa_json_is_int_libspa_rs"]
8745 pub fn spa_json_is_int(val: *const ::std::os::raw::c_char, len: ::std::os::raw::c_int) -> bool;
8746}
8747unsafe extern "C" {
8748 #[link_name = "spa_json_is_true_libspa_rs"]
8749 pub fn spa_json_is_true(val: *const ::std::os::raw::c_char, len: ::std::os::raw::c_int)
8750 -> bool;
8751}
8752unsafe extern "C" {
8753 #[link_name = "spa_json_is_false_libspa_rs"]
8754 pub fn spa_json_is_false(
8755 val: *const ::std::os::raw::c_char,
8756 len: ::std::os::raw::c_int,
8757 ) -> bool;
8758}
8759unsafe extern "C" {
8760 #[link_name = "spa_json_is_bool_libspa_rs"]
8761 pub fn spa_json_is_bool(val: *const ::std::os::raw::c_char, len: ::std::os::raw::c_int)
8762 -> bool;
8763}
8764unsafe extern "C" {
8765 #[link_name = "spa_json_parse_bool_libspa_rs"]
8766 pub fn spa_json_parse_bool(
8767 val: *const ::std::os::raw::c_char,
8768 len: ::std::os::raw::c_int,
8769 result: *mut bool,
8770 ) -> ::std::os::raw::c_int;
8771}
8772unsafe extern "C" {
8773 #[link_name = "spa_json_is_string_libspa_rs"]
8774 pub fn spa_json_is_string(
8775 val: *const ::std::os::raw::c_char,
8776 len: ::std::os::raw::c_int,
8777 ) -> bool;
8778}
8779unsafe extern "C" {
8780 #[link_name = "spa_json_parse_hex_libspa_rs"]
8781 pub fn spa_json_parse_hex(
8782 p: *const ::std::os::raw::c_char,
8783 num: ::std::os::raw::c_int,
8784 res: *mut u32,
8785 ) -> ::std::os::raw::c_int;
8786}
8787unsafe extern "C" {
8788 #[link_name = "spa_json_parse_stringn_libspa_rs"]
8789 pub fn spa_json_parse_stringn(
8790 val: *const ::std::os::raw::c_char,
8791 len: ::std::os::raw::c_int,
8792 result: *mut ::std::os::raw::c_char,
8793 maxlen: ::std::os::raw::c_int,
8794 ) -> ::std::os::raw::c_int;
8795}
8796unsafe extern "C" {
8797 #[link_name = "spa_json_parse_string_libspa_rs"]
8798 pub fn spa_json_parse_string(
8799 val: *const ::std::os::raw::c_char,
8800 len: ::std::os::raw::c_int,
8801 result: *mut ::std::os::raw::c_char,
8802 ) -> ::std::os::raw::c_int;
8803}
8804unsafe extern "C" {
8805 #[link_name = "spa_json_encode_string_libspa_rs"]
8806 pub fn spa_json_encode_string(
8807 str_: *mut ::std::os::raw::c_char,
8808 size: ::std::os::raw::c_int,
8809 val: *const ::std::os::raw::c_char,
8810 ) -> ::std::os::raw::c_int;
8811}
8812unsafe extern "C" {
8813 #[doc = " \\addtogroup spa_json\n \\{"]
8814 #[link_name = "spa_json_begin_libspa_rs"]
8815 pub fn spa_json_begin(
8816 iter: *mut spa_json,
8817 data: *const ::std::os::raw::c_char,
8818 size: usize,
8819 val: *mut *const ::std::os::raw::c_char,
8820 ) -> ::std::os::raw::c_int;
8821}
8822unsafe extern "C" {
8823 #[link_name = "spa_json_get_float_libspa_rs"]
8824 pub fn spa_json_get_float(iter: *mut spa_json, res: *mut f32) -> ::std::os::raw::c_int;
8825}
8826unsafe extern "C" {
8827 #[link_name = "spa_json_get_int_libspa_rs"]
8828 pub fn spa_json_get_int(
8829 iter: *mut spa_json,
8830 res: *mut ::std::os::raw::c_int,
8831 ) -> ::std::os::raw::c_int;
8832}
8833unsafe extern "C" {
8834 #[link_name = "spa_json_get_bool_libspa_rs"]
8835 pub fn spa_json_get_bool(iter: *mut spa_json, res: *mut bool) -> ::std::os::raw::c_int;
8836}
8837unsafe extern "C" {
8838 #[link_name = "spa_json_get_string_libspa_rs"]
8839 pub fn spa_json_get_string(
8840 iter: *mut spa_json,
8841 res: *mut ::std::os::raw::c_char,
8842 maxlen: ::std::os::raw::c_int,
8843 ) -> ::std::os::raw::c_int;
8844}
8845unsafe extern "C" {
8846 #[link_name = "spa_json_enter_container_libspa_rs"]
8847 pub fn spa_json_enter_container(
8848 iter: *mut spa_json,
8849 sub: *mut spa_json,
8850 type_: ::std::os::raw::c_char,
8851 ) -> ::std::os::raw::c_int;
8852}
8853unsafe extern "C" {
8854 #[link_name = "spa_json_begin_container_libspa_rs"]
8855 pub fn spa_json_begin_container(
8856 iter: *mut spa_json,
8857 data: *const ::std::os::raw::c_char,
8858 size: usize,
8859 type_: ::std::os::raw::c_char,
8860 relax: bool,
8861 ) -> ::std::os::raw::c_int;
8862}
8863unsafe extern "C" {
8864 #[doc = " Return length of container at current position, starting at \\a value.\n\n \\return Length of container including {} or [], or 0 on error."]
8865 #[link_name = "spa_json_container_len_libspa_rs"]
8866 pub fn spa_json_container_len(
8867 iter: *mut spa_json,
8868 value: *const ::std::os::raw::c_char,
8869 len: ::std::os::raw::c_int,
8870 ) -> ::std::os::raw::c_int;
8871}
8872unsafe extern "C" {
8873 #[link_name = "spa_json_enter_object_libspa_rs"]
8874 pub fn spa_json_enter_object(iter: *mut spa_json, sub: *mut spa_json) -> ::std::os::raw::c_int;
8875}
8876unsafe extern "C" {
8877 #[link_name = "spa_json_begin_object_relax_libspa_rs"]
8878 pub fn spa_json_begin_object_relax(
8879 iter: *mut spa_json,
8880 data: *const ::std::os::raw::c_char,
8881 size: usize,
8882 ) -> ::std::os::raw::c_int;
8883}
8884unsafe extern "C" {
8885 #[link_name = "spa_json_begin_object_libspa_rs"]
8886 pub fn spa_json_begin_object(
8887 iter: *mut spa_json,
8888 data: *const ::std::os::raw::c_char,
8889 size: usize,
8890 ) -> ::std::os::raw::c_int;
8891}
8892unsafe extern "C" {
8893 #[link_name = "spa_json_object_next_libspa_rs"]
8894 pub fn spa_json_object_next(
8895 iter: *mut spa_json,
8896 key: *mut ::std::os::raw::c_char,
8897 maxkeylen: ::std::os::raw::c_int,
8898 value: *mut *const ::std::os::raw::c_char,
8899 ) -> ::std::os::raw::c_int;
8900}
8901unsafe extern "C" {
8902 #[link_name = "spa_json_object_find_libspa_rs"]
8903 pub fn spa_json_object_find(
8904 iter: *mut spa_json,
8905 key: *const ::std::os::raw::c_char,
8906 value: *mut *const ::std::os::raw::c_char,
8907 ) -> ::std::os::raw::c_int;
8908}
8909unsafe extern "C" {
8910 #[link_name = "spa_json_str_object_find_libspa_rs"]
8911 pub fn spa_json_str_object_find(
8912 obj: *const ::std::os::raw::c_char,
8913 obj_len: usize,
8914 key: *const ::std::os::raw::c_char,
8915 value: *mut ::std::os::raw::c_char,
8916 maxlen: usize,
8917 ) -> ::std::os::raw::c_int;
8918}
8919unsafe extern "C" {
8920 #[link_name = "spa_json_enter_array_libspa_rs"]
8921 pub fn spa_json_enter_array(iter: *mut spa_json, sub: *mut spa_json) -> ::std::os::raw::c_int;
8922}
8923unsafe extern "C" {
8924 #[link_name = "spa_json_begin_array_relax_libspa_rs"]
8925 pub fn spa_json_begin_array_relax(
8926 iter: *mut spa_json,
8927 data: *const ::std::os::raw::c_char,
8928 size: usize,
8929 ) -> ::std::os::raw::c_int;
8930}
8931unsafe extern "C" {
8932 #[link_name = "spa_json_begin_array_libspa_rs"]
8933 pub fn spa_json_begin_array(
8934 iter: *mut spa_json,
8935 data: *const ::std::os::raw::c_char,
8936 size: usize,
8937 ) -> ::std::os::raw::c_int;
8938}
8939unsafe extern "C" {
8940 #[link_name = "spa_json_str_array_uint32_libspa_rs"]
8941 pub fn spa_json_str_array_uint32(
8942 arr: *const ::std::os::raw::c_char,
8943 arr_len: usize,
8944 values: *mut u32,
8945 max: usize,
8946 ) -> ::std::os::raw::c_int;
8947}
8948unsafe extern "C" {
8949 #[link_name = "spa_strerror_libspa_rs"]
8950 pub fn spa_strerror(err: ::std::os::raw::c_int) -> *const ::std::os::raw::c_char;
8951}
8952#[doc = " \\addtogroup spa_ringbuffer\n \\{"]
8953#[repr(C)]
8954#[derive(Debug, Copy, Clone, PartialEq, Eq)]
8955pub struct spa_ringbuffer {
8956 pub readindex: u32,
8957 pub writeindex: u32,
8958}
8959#[allow(clippy::unnecessary_operation, clippy::identity_op)]
8960const _: () = {
8961 ["Size of spa_ringbuffer"][::std::mem::size_of::<spa_ringbuffer>() - 8usize];
8962 ["Alignment of spa_ringbuffer"][::std::mem::align_of::<spa_ringbuffer>() - 4usize];
8963 ["Offset of field: spa_ringbuffer::readindex"]
8964 [::std::mem::offset_of!(spa_ringbuffer, readindex) - 0usize];
8965 ["Offset of field: spa_ringbuffer::writeindex"]
8966 [::std::mem::offset_of!(spa_ringbuffer, writeindex) - 4usize];
8967};
8968unsafe extern "C" {
8969 #[doc = " Initialize a spa_ringbuffer with \\a size.\n\n \\param rbuf a spa_ringbuffer"]
8970 #[link_name = "spa_ringbuffer_init_libspa_rs"]
8971 pub fn spa_ringbuffer_init(rbuf: *mut spa_ringbuffer);
8972}
8973unsafe extern "C" {
8974 #[doc = " Sets the pointers so that the ringbuffer contains \\a size bytes.\n\n \\param rbuf a spa_ringbuffer\n \\param size the target size of \\a rbuf"]
8975 #[link_name = "spa_ringbuffer_set_avail_libspa_rs"]
8976 pub fn spa_ringbuffer_set_avail(rbuf: *mut spa_ringbuffer, size: u32);
8977}
8978unsafe extern "C" {
8979 #[doc = " Get the read index and available bytes for reading.\n\n \\param rbuf a spa_ringbuffer\n \\param index the value of readindex, should be taken modulo the size of the\n ringbuffer memory to get the offset in the ringbuffer memory\n \\return number of available bytes to read. values < 0 mean\n there was an underrun. values > rbuf->size means there\n was an overrun."]
8980 #[link_name = "spa_ringbuffer_get_read_index_libspa_rs"]
8981 pub fn spa_ringbuffer_get_read_index(rbuf: *mut spa_ringbuffer, index: *mut u32) -> i32;
8982}
8983unsafe extern "C" {
8984 #[doc = " Read \\a len bytes from \\a rbuf starting \\a offset. \\a offset must be taken\n modulo \\a size and len should be smaller than \\a size.\n\n \\param rbuf a struct \\ref spa_ringbuffer\n \\param buffer memory to read from\n \\param size the size of \\a buffer\n \\param offset offset in \\a buffer to read from\n \\param data destination memory\n \\param len number of bytes to read"]
8985 #[link_name = "spa_ringbuffer_read_data_libspa_rs"]
8986 pub fn spa_ringbuffer_read_data(
8987 rbuf: *mut spa_ringbuffer,
8988 buffer: *const ::std::os::raw::c_void,
8989 size: u32,
8990 offset: u32,
8991 data: *mut ::std::os::raw::c_void,
8992 len: u32,
8993 );
8994}
8995unsafe extern "C" {
8996 #[doc = " Update the read pointer to \\a index.\n\n \\param rbuf a spa_ringbuffer\n \\param index new index"]
8997 #[link_name = "spa_ringbuffer_read_update_libspa_rs"]
8998 pub fn spa_ringbuffer_read_update(rbuf: *mut spa_ringbuffer, index: i32);
8999}
9000unsafe extern "C" {
9001 #[doc = " Get the write index and the number of bytes inside the ringbuffer.\n\n \\param rbuf a spa_ringbuffer\n \\param index the value of writeindex, should be taken modulo the size of the\n ringbuffer memory to get the offset in the ringbuffer memory\n \\return the fill level of \\a rbuf. values < 0 mean\n there was an underrun. values > rbuf->size means there\n was an overrun. Subtract from the buffer size to get\n the number of bytes available for writing."]
9002 #[link_name = "spa_ringbuffer_get_write_index_libspa_rs"]
9003 pub fn spa_ringbuffer_get_write_index(rbuf: *mut spa_ringbuffer, index: *mut u32) -> i32;
9004}
9005unsafe extern "C" {
9006 #[doc = " Write \\a len bytes to \\a buffer starting \\a offset. \\a offset must be taken\n modulo \\a size and len should be smaller than \\a size.\n\n \\param rbuf a spa_ringbuffer\n \\param buffer memory to write to\n \\param size the size of \\a buffer\n \\param offset offset in \\a buffer to write to\n \\param data source memory\n \\param len number of bytes to write"]
9007 #[link_name = "spa_ringbuffer_write_data_libspa_rs"]
9008 pub fn spa_ringbuffer_write_data(
9009 rbuf: *mut spa_ringbuffer,
9010 buffer: *mut ::std::os::raw::c_void,
9011 size: u32,
9012 offset: u32,
9013 data: *const ::std::os::raw::c_void,
9014 len: u32,
9015 );
9016}
9017unsafe extern "C" {
9018 #[doc = " Update the write pointer to \\a index\n\n \\param rbuf a spa_ringbuffer\n \\param index new index"]
9019 #[link_name = "spa_ringbuffer_write_update_libspa_rs"]
9020 pub fn spa_ringbuffer_write_update(rbuf: *mut spa_ringbuffer, index: i32);
9021}
9022pub type __builtin_va_list = [__va_list_tag; 1usize];
9023#[repr(C)]
9024#[derive(Debug, Copy, Clone, PartialEq, Eq)]
9025pub struct __va_list_tag {
9026 pub gp_offset: ::std::os::raw::c_uint,
9027 pub fp_offset: ::std::os::raw::c_uint,
9028 pub overflow_arg_area: *mut ::std::os::raw::c_void,
9029 pub reg_save_area: *mut ::std::os::raw::c_void,
9030}
9031#[allow(clippy::unnecessary_operation, clippy::identity_op)]
9032const _: () = {
9033 ["Size of __va_list_tag"][::std::mem::size_of::<__va_list_tag>() - 24usize];
9034 ["Alignment of __va_list_tag"][::std::mem::align_of::<__va_list_tag>() - 8usize];
9035 ["Offset of field: __va_list_tag::gp_offset"]
9036 [::std::mem::offset_of!(__va_list_tag, gp_offset) - 0usize];
9037 ["Offset of field: __va_list_tag::fp_offset"]
9038 [::std::mem::offset_of!(__va_list_tag, fp_offset) - 4usize];
9039 ["Offset of field: __va_list_tag::overflow_arg_area"]
9040 [::std::mem::offset_of!(__va_list_tag, overflow_arg_area) - 8usize];
9041 ["Offset of field: __va_list_tag::reg_save_area"]
9042 [::std::mem::offset_of!(__va_list_tag, reg_save_area) - 16usize];
9043};