1#![allow(non_camel_case_types)]
2#![allow(non_snake_case)]
3#![allow(non_upper_case_globals)]
4
5use std::ffi::c_void;
6
7pub type INT = i32;
8pub type UINT = u32;
9pub type UCHAR = u8;
10pub type SCHAR = i8;
11pub type INT64 = i64;
12pub type INT_PCM = i16;
13
14unsafe extern "C" {
15 pub fn fdk_ld_block_switch_test(
16 input: *const i16,
17 frames: i32,
18 frame_length: i32,
19 low_overlap: *mut u8,
20 ) -> i32;
21 pub fn fdk_sbr_fast_transient_test(
22 slot_band_energy: *const i32,
23 frames: i32,
24 time_slots: i32,
25 qmf_bands: i32,
26 bandwidth_qmf_slot: i32,
27 first_sbr_band: i32,
28 transient_info: *mut u8,
29 ) -> i32;
30 pub fn fdk_sbr_code_envelope_test(
31 absolute_values: *const i8,
32 frames: i32,
33 bands: i32,
34 coded_values: *mut i8,
35 directions: *mut i32,
36 ) -> i32;
37 pub fn fdk_sbr_coupled_delta_bits_test(
38 current: *const i8,
39 previous: *const i8,
40 bands: i32,
41 channel: i32,
42 amp_res_1_5: i32,
43 frequency_bits: *mut i32,
44 time_bits: *mut i32,
45 ) -> i32;
46 pub fn fdk_sbr_first_env_threshold_test(time_bits: i32, streak: i32) -> i32;
47 pub fn fdk_sbr_code_envelope_coupled_test(
48 absolute_values: *const i8,
49 frames: i32,
50 bands: i32,
51 channel: i32,
52 amp_res_1_5: i32,
53 coded_values: *mut i8,
54 directions: *mut i32,
55 ) -> i32;
56 pub fn fdk_sbr_invf_regions_test(
57 original_q16: *const i32,
58 sbr_q16: *const i32,
59 energy_q16: *const i32,
60 transient: *const u8,
61 frames: i32,
62 modes: *mut u8,
63 ) -> i32;
64 pub fn fdk_sbr_invf_capture_enable(enable: i32);
65 pub fn fdk_sbr_invf_capture_get(
66 channel: i32,
67 modes: *mut u8,
68 original_regions: *mut i32,
69 sbr_regions: *mut i32,
70 capacity: i32,
71 ) -> i32;
72 pub fn fdk_sbr_invf_quota_capture_get(channel: i32, quotas: *mut i32, capacity: i32) -> i32;
73 pub fn fdk_sbr_invf_detector_test(
74 quotas: *const i32,
75 energies: *const i32,
76 index_vector: *const i8,
77 band_table: *const i32,
78 transient_flags: *const u8,
79 frames: i32,
80 estimates: i32,
81 channels: i32,
82 bands: i32,
83 modes: *mut u8,
84 original_regions: *mut i32,
85 sbr_regions: *mut i32,
86 ) -> i32;
87 pub fn fdk_sbr_patch_map_test(
88 master: *const u8,
89 master_count: i32,
90 high_start: i32,
91 sample_rate: i32,
92 qmf_channels: i32,
93 index_vector: *mut i8,
94 ) -> i32;
95 pub fn fdk_sbr_tonality_quota_test(
96 real: *const i32,
97 imaginary: *const i32,
98 samples: i32,
99 quota: *mut i32,
100 energy: *mut i32,
101 ) -> i32;
102 pub fn fdk_sbr_global_tonality_test(
103 quotas: *const i32,
104 energies: *const i32,
105 estimates: i32,
106 slots: i32,
107 bands: i32,
108 start_band: i32,
109 previous_tonality: i32,
110 current_tonality: *mut i32,
111 global_tonality: *mut i32,
112 amp_res_3db: *mut i32,
113 ) -> i32;
114 pub fn fdk_sbr_complex_energy_test(
115 real: *const i32,
116 imaginary: *const i32,
117 slots: i32,
118 bands: i32,
119 qmf_scale: i32,
120 energies: *mut i32,
121 energy_scale: *mut i32,
122 ) -> i32;
123 pub fn fdk_sbr_envelope_capture_enable(enable: i32);
124 pub fn fdk_sbr_qmf_input_capture_enable(enable: i32);
125 pub fn fdk_sbr_qmf_input_capture_get(channel: i32, output: *mut i16, capacity: i32) -> i32;
126 pub fn fdk_sbr_qmf_output_capture_get(
127 channel: i32,
128 real: *mut i32,
129 imaginary: *mut i32,
130 capacity: i32,
131 ) -> i32;
132 pub fn fdk_sbr_envelope_capture_get(
133 channel: i32,
134 values: *mut i8,
135 capacity: i32,
136 scale0: *mut i32,
137 scale1: *mut i32,
138 qmf_scale: *mut i32,
139 ) -> i32;
140 pub fn fdk_sbr_prequant_capture_get(
141 channel: i32,
142 energies: *mut i32,
143 sample_counts: *mut i32,
144 capacity: i32,
145 common_scale: *mut i32,
146 ) -> i32;
147 pub fn fdk_sbr_transient_capture_get(channel: i32, position: *mut i32, flag: *mut i32) -> i32;
148 pub fn fdk_sbr_sfb_energy_test(
149 energies: *const i32,
150 slots: i32,
151 bands: i32,
152 lower_band: i32,
153 upper_band: i32,
154 start_slot: i32,
155 stop_slot: i32,
156 scale0: i32,
157 scale1: i32,
158 ) -> i32;
159 pub fn fdk_sbr_sfb_energy_split_test(
160 energies: *const i32,
161 slots: i32,
162 bands: i32,
163 lower_band: i32,
164 upper_band: i32,
165 start_slot: i32,
166 stop_slot: i32,
167 border_slot: i32,
168 scale0: i32,
169 scale1: i32,
170 ) -> i32;
171 pub fn fdk_sbr_log2_ld64_test(values: *const i32, count: i32, output: *mut i32) -> i32;
172 pub fn fdk_log2_coefficients_test(
173 coefficients: *mut i32,
174 count: i32,
175 conversion: *mut i32,
176 ) -> i32;
177 pub fn fdk_sbr_quantize_energy_test(
178 energy: i32,
179 sample_count: i32,
180 common_scale: i32,
181 amp_res_3db: i32,
182 ) -> i32;
183 pub fn fdk_imlt_long_test(
184 input: *const i32,
185 shape: *const u8,
186 frames: i32,
187 frame_length: i32,
188 output: *mut i32,
189 ) -> i32;
190 pub fn fdk_psy_configuration_test(
191 bitrate: i32,
192 sample_rate: i32,
193 bandwidth: i32,
194 frame_length: i32,
195 filterbank: i32,
196 sfb_count: *mut i32,
197 sfb_active: *mut i32,
198 offsets: *mut i32,
199 min_snr_q31: *mut i32,
200 mask_low_q31: *mut i32,
201 mask_high_q31: *mut i32,
202 ) -> i32;
203 pub fn fdk_adjust_pe_min_max_test(
204 current_pe: *const i32,
205 frames: i32,
206 initial_mean_pe: i32,
207 minimum_pe: *mut i32,
208 maximum_pe: *mut i32,
209 ) -> i32;
210 pub fn fdk_reduce_thresholds_cbr_test(
211 energy_ld64: *const i32,
212 threshold_ld64: *const i32,
213 minimum_snr_ld64: *const i32,
214 avoid_hole: *const u8,
215 sfb_count: i32,
216 reduction_mantissa_q31: i32,
217 reduction_exponent: i32,
218 reduced_threshold_ld64: *mut i32,
219 reduced_avoid_hole: *mut u8,
220 ) -> i32;
221 pub fn fdk_reduce_thresholds_vbr_test(
222 energy_q31: *const i32,
223 energy_ld64: *const i32,
224 threshold_ld64: *const i32,
225 minimum_snr_ld64: *const i32,
226 form_factor_ld64: *const i32,
227 sfb_offsets: *const i32,
228 avoid_hole: *const u8,
229 sfb_count: i32,
230 quality_factor_q31: i32,
231 chaos_measure_q31: *mut i32,
232 instant_chaos_measure_q31: *mut i32,
233 reduced_threshold_ld64: *mut i32,
234 reduced_avoid_hole: *mut u8,
235 ) -> i32;
236 pub fn fdk_bitres_factor_test(
237 current_pe: *const i32,
238 reservoir_bits: *const i32,
239 frames: i32,
240 average_dynamic_bits: i32,
241 maximum_reservoir_bits: i32,
242 factor_q16: *mut i32,
243 ) -> i32;
244 pub fn fdk_aacenc_metadata_size_test() -> i32;
245 pub fn fdk_metadata_compressor_test(
246 input: *const i16,
247 frames: i32,
248 frame_length: i32,
249 sample_rate: u32,
250 channels: i32,
251 channel_mode: i32,
252 drc_profile: i32,
253 compression_profile: i32,
254 dialnorm_q16: i32,
255 drc_target_q16: i32,
256 compression_target_q16: i32,
257 dynamic_range_q16: *mut i32,
258 compression_q16: *mut i32,
259 ) -> i32;
260 pub fn fdk_pcm_downmix_7_1_test(
261 input: *const i32,
262 target_channels: i32,
263 metadata: *const u8,
264 metadata_bytes: i32,
265 output: *mut i32,
266 output_channels: *mut i32,
267 ) -> i32;
268 pub fn fdk_dct_iv_test(
269 input: *const i32,
270 length: i32,
271 output: *mut i32,
272 scale: *mut i32,
273 ) -> i32;
274 pub fn fdk_dst_iv_test(
275 input: *const i32,
276 length: i32,
277 output: *mut i32,
278 scale: *mut i32,
279 ) -> i32;
280 pub fn fdk_fft32_test(input: *const i32, output: *mut i32, scale: *mut i32) -> i32;
281 pub fn fdk_fft32_capture_enable(enabled: i32);
282 pub fn fdk_fft32_capture_get(stage: i32, output: *mut i32) -> i32;
283 pub fn fdk_eld_filterbank_test(
284 spectrum: *const i32,
285 length: i32,
286 spectrum_exp: i32,
287 output: *mut i32,
288 ) -> i32;
289 pub fn fdk_sbr_inverse_filtered_patch_test(
290 real: *const i32,
291 imag: *const i32,
292 total_samples: i32,
293 mode: u8,
294 previous_mode: u8,
295 previous_bandwidth: i32,
296 real_output: *mut i32,
297 imag_output: *mut i32,
298 high_band_scale: *mut i32,
299 ) -> i32;
300 pub fn fdk_sbr_autocorrelation2_test(
301 real: *const i32,
302 imag: *const i32,
303 total_samples: i32,
304 coefficients: *mut i32,
305 det_scale: *mut i32,
306 ) -> i32;
307 pub fn fdk_fixed_mul_div2_test(
308 left: *const i32,
309 right: *const i32,
310 count: i32,
311 output: *mut i32,
312 ) -> i32;
313 pub fn fdk_sbr_inverse_filter_levels_test(
314 modes: *const u8,
315 previous_modes: *const u8,
316 previous_bandwidths: *const i32,
317 count: i32,
318 bandwidths: *mut i32,
319 ) -> i32;
320 pub fn fdk_sbr_component_energies_test(
321 reference_m: i32,
322 reference_e: i8,
323 estimated_m: i32,
324 estimated_e: i8,
325 noise_m: i32,
326 noise_e: i8,
327 sine_present: u8,
328 sine_mapped: u8,
329 no_noise: i32,
330 gain_m: *mut i32,
331 gain_e: *mut i8,
332 noise_level_m: *mut i32,
333 noise_level_e: *mut i8,
334 sine_m: *mut i32,
335 sine_e: *mut i8,
336 ) -> i32;
337 pub fn fdk_sbr_limited_components_test(
338 reference_m: *const i32,
339 reference_e: *const i8,
340 estimated_m: *const i32,
341 estimated_e: *const i8,
342 noise_m: *const i32,
343 noise_e: *const i8,
344 sine_present: *const u8,
345 sine_mapped: *const u8,
346 count: i32,
347 limiter_gains: u8,
348 no_noise: i32,
349 gain_m: *mut i32,
350 gain_e: *mut i8,
351 noise_level_m: *mut i32,
352 noise_level_e: *mut i8,
353 sine_m: *mut i32,
354 sine_e: *mut i8,
355 ) -> i32;
356 pub fn fdk_sbr_limiter_bands_test(
357 low_table: *const u8,
358 low_bands: u8,
359 source_starts: *const u8,
360 target_starts: *const u8,
361 band_counts: *const u8,
362 patch_count: u8,
363 limiter_bands: u8,
364 result_count: *mut u8,
365 result_table: *mut u8,
366 ) -> i32;
367 pub fn fdk_qmf_analysis32_test(
368 input: *const i32,
369 samples: i32,
370 real_out: *mut i32,
371 imag_out: *mut i32,
372 lb_scale: *mut i32,
373 ) -> i32;
374 pub fn fdk_qmf_analysis_usac_test(
375 input: *const i32,
376 samples: i32,
377 channels: i32,
378 real_out: *mut i32,
379 imag_out: *mut i32,
380 lb_scale: *mut i32,
381 ) -> i32;
382 pub fn fdk_qmf_analysis64_test(
383 input: *const i32,
384 samples: i32,
385 real_out: *mut i32,
386 imag_out: *mut i32,
387 lb_scale: *mut i32,
388 ) -> i32;
389 pub fn fdk_qmf_analysis64_cldfb_test(
390 input: *const i32,
391 samples: i32,
392 real_out: *mut i32,
393 imag_out: *mut i32,
394 lb_scale: *mut i32,
395 ) -> i32;
396 pub fn fdk_qmf_analysis64_cldfb_pcm_test(
397 input: *const i16,
398 samples: i32,
399 real_out: *mut i32,
400 imag_out: *mut i32,
401 lb_scale: *mut i32,
402 ) -> i32;
403 pub fn fdk_qmf_analysis32_lp_test(
404 input: *const i32,
405 samples: i32,
406 real_out: *mut i32,
407 lb_scale: *mut i32,
408 ) -> i32;
409 pub fn fdk_qmf_analysis32_cldfb_test(
410 input: *const i32,
411 samples: i32,
412 real_out: *mut i32,
413 imag_out: *mut i32,
414 lb_scale: *mut i32,
415 ) -> i32;
416 pub fn fdk_qmf_analysis32_cldfb_lp_test(
417 input: *const i32,
418 samples: i32,
419 real_out: *mut i32,
420 lb_scale: *mut i32,
421 ) -> i32;
422 pub fn fdk_qmf_synthesis64_test(
423 real_in: *const i32,
424 imag_in: *const i32,
425 slots: i32,
426 output: *mut i32,
427 ) -> i32;
428 pub fn fdk_qmf_synthesis64_lp_test(real_in: *const i32, slots: i32, output: *mut i32) -> i32;
429 pub fn fdk_qmf_synthesis32_cldfb_test(
430 real_in: *const i32,
431 imag_in: *const i32,
432 slots: i32,
433 output: *mut i32,
434 ) -> i32;
435 pub fn fdk_qmf_synthesis32_cldfb_lp_test(
436 real_in: *const i32,
437 slots: i32,
438 output: *mut i32,
439 ) -> i32;
440 pub fn fdk_qmf_synthesis64_cldfb_test(
441 real_in: *const i32,
442 imag_in: *const i32,
443 slots: i32,
444 output: *mut i32,
445 ) -> i32;
446 pub fn fdk_qmf_roundtrip32_64_test(input: *const i32, samples: i32, output: *mut i32) -> i32;
447 pub fn fdk_qmf_roundtrip32_cldfb_test(input: *const i32, samples: i32, output: *mut i32)
448 -> i32;
449}
450
451pub type HANDLE_AACENCODER = *mut AACENCODER;
452pub type HANDLE_AACDECODER = *mut AAC_DECODER_INSTANCE;
453
454#[repr(C)]
455pub struct AACENCODER {
456 _private: [u8; 0],
457}
458
459#[repr(C)]
460pub struct AAC_DECODER_INSTANCE {
461 _private: [u8; 0],
462}
463
464pub type AACENC_ERROR = i32;
465pub const AACENC_OK: AACENC_ERROR = 0x0000;
466pub const AACENC_INVALID_HANDLE: AACENC_ERROR = 0x0020;
467pub const AACENC_MEMORY_ERROR: AACENC_ERROR = 0x0021;
468pub const AACENC_UNSUPPORTED_PARAMETER: AACENC_ERROR = 0x0022;
469pub const AACENC_INVALID_CONFIG: AACENC_ERROR = 0x0023;
470pub const AACENC_INIT_ERROR: AACENC_ERROR = 0x0040;
471pub const AACENC_INIT_AAC_ERROR: AACENC_ERROR = 0x0041;
472pub const AACENC_INIT_SBR_ERROR: AACENC_ERROR = 0x0042;
473pub const AACENC_INIT_TP_ERROR: AACENC_ERROR = 0x0043;
474pub const AACENC_INIT_META_ERROR: AACENC_ERROR = 0x0044;
475pub const AACENC_INIT_MPS_ERROR: AACENC_ERROR = 0x0045;
476pub const AACENC_ENCODE_ERROR: AACENC_ERROR = 0x0060;
477pub const AACENC_ENCODE_EOF: AACENC_ERROR = 0x0080;
478
479pub type AAC_DECODER_ERROR = i32;
480pub const AAC_DEC_OK: AAC_DECODER_ERROR = 0x0000;
481pub const AAC_DEC_OUT_OF_MEMORY: AAC_DECODER_ERROR = 0x0002;
482pub const AAC_DEC_UNKNOWN: AAC_DECODER_ERROR = 0x0005;
483pub const AAC_DEC_INVALID_HANDLE: AAC_DECODER_ERROR = 0x2001;
484pub const AAC_DEC_UNSUPPORTED_FORMAT: AAC_DECODER_ERROR = 0x2003;
485pub const AAC_DEC_OUTPUT_BUFFER_TOO_SMALL: AAC_DECODER_ERROR = 0x200C;
486pub const AAC_DEC_NOT_ENOUGH_BITS: AAC_DECODER_ERROR = 0x1002;
487
488pub type TRANSPORT_TYPE = i32;
489pub const TT_UNKNOWN: TRANSPORT_TYPE = -1;
490pub const TT_MP4_RAW: TRANSPORT_TYPE = 0;
491pub const TT_MP4_ADIF: TRANSPORT_TYPE = 1;
492pub const TT_MP4_ADTS: TRANSPORT_TYPE = 2;
493pub const TT_MP4_LATM_MCP1: TRANSPORT_TYPE = 6;
494pub const TT_MP4_LATM_MCP0: TRANSPORT_TYPE = 7;
495pub const TT_MP4_LOAS: TRANSPORT_TYPE = 10;
496pub const TT_DRM: TRANSPORT_TYPE = 12;
497
498pub type AUDIO_OBJECT_TYPE = i32;
499pub const AOT_AAC_LC: AUDIO_OBJECT_TYPE = 2;
500pub const AOT_SBR: AUDIO_OBJECT_TYPE = 5;
501pub const AOT_PS: AUDIO_OBJECT_TYPE = 29;
502pub const AOT_ER_AAC_ELD: AUDIO_OBJECT_TYPE = 39;
503
504pub type CHANNEL_MODE = i32;
505pub const MODE_1: CHANNEL_MODE = 1;
506pub const MODE_2: CHANNEL_MODE = 2;
507pub const MODE_1_2: CHANNEL_MODE = 3;
508pub const MODE_1_2_1: CHANNEL_MODE = 4;
509pub const MODE_1_2_2: CHANNEL_MODE = 5;
510pub const MODE_1_2_2_1: CHANNEL_MODE = 6;
511
512pub type AACENC_PARAM = i32;
513pub const AACENC_AOT: AACENC_PARAM = 0x0100;
514pub const AACENC_BITRATE: AACENC_PARAM = 0x0101;
515pub const AACENC_BITRATEMODE: AACENC_PARAM = 0x0102;
516pub const AACENC_SAMPLERATE: AACENC_PARAM = 0x0103;
517pub const AACENC_SBR_MODE: AACENC_PARAM = 0x0104;
518pub const AACENC_GRANULE_LENGTH: AACENC_PARAM = 0x0105;
519pub const AACENC_CHANNELMODE: AACENC_PARAM = 0x0106;
520pub const AACENC_CHANNELORDER: AACENC_PARAM = 0x0107;
521pub const AACENC_SBR_RATIO: AACENC_PARAM = 0x0108;
522pub const AACENC_AFTERBURNER: AACENC_PARAM = 0x0200;
523pub const AACENC_BANDWIDTH: AACENC_PARAM = 0x0203;
524pub const AACENC_PEAK_BITRATE: AACENC_PARAM = 0x0207;
525pub const AACENC_TRANSMUX: AACENC_PARAM = 0x0300;
526pub const AACENC_HEADER_PERIOD: AACENC_PARAM = 0x0301;
527pub const AACENC_SIGNALING_MODE: AACENC_PARAM = 0x0302;
528pub const AACENC_TPSUBFRAMES: AACENC_PARAM = 0x0303;
529pub const AACENC_AUDIOMUXVER: AACENC_PARAM = 0x0304;
530pub const AACENC_PROTECTION: AACENC_PARAM = 0x0306;
531pub const AACENC_ANCILLARY_BITRATE: AACENC_PARAM = 0x0500;
532pub const AACENC_METADATA_MODE: AACENC_PARAM = 0x0600;
533pub const AACENC_CONTROL_STATE: AACENC_PARAM = 0xff00;
534
535pub const IN_AUDIO_DATA: i32 = 0;
536pub const IN_ANCILLRY_DATA: i32 = 1;
537pub const IN_METADATA_SETUP: i32 = 2;
538pub const OUT_BITSTREAM_DATA: i32 = 3;
539
540pub type AACENC_METADATA_DRC_PROFILE = i32;
541pub const AACENC_METADATA_DRC_NONE: AACENC_METADATA_DRC_PROFILE = 0;
542pub const AACENC_METADATA_DRC_FILMSTANDARD: AACENC_METADATA_DRC_PROFILE = 1;
543pub const AACENC_METADATA_DRC_FILMLIGHT: AACENC_METADATA_DRC_PROFILE = 2;
544pub const AACENC_METADATA_DRC_MUSICSTANDARD: AACENC_METADATA_DRC_PROFILE = 3;
545pub const AACENC_METADATA_DRC_MUSICLIGHT: AACENC_METADATA_DRC_PROFILE = 4;
546pub const AACENC_METADATA_DRC_SPEECH: AACENC_METADATA_DRC_PROFILE = 5;
547pub const AACENC_METADATA_DRC_NOT_PRESENT: AACENC_METADATA_DRC_PROFILE = 256;
548
549#[repr(C)]
550#[derive(Clone, Copy, Debug, Default)]
551pub struct AACENC_ExtMetaData {
552 pub extAncDataEnable: UCHAR,
553 pub extDownmixLevelEnable: UCHAR,
554 pub extDownmixLevel_A: UCHAR,
555 pub extDownmixLevel_B: UCHAR,
556 pub dmxGainEnable: UCHAR,
557 pub dmxGain5: INT,
558 pub dmxGain2: INT,
559 pub lfeDmxEnable: UCHAR,
560 pub lfeDmxLevel: UCHAR,
561}
562
563#[repr(C)]
564#[derive(Clone, Copy, Debug)]
565pub struct AACENC_MetaData {
566 pub drc_profile: AACENC_METADATA_DRC_PROFILE,
567 pub comp_profile: AACENC_METADATA_DRC_PROFILE,
568 pub drc_TargetRefLevel: INT,
569 pub comp_TargetRefLevel: INT,
570 pub prog_ref_level_present: INT,
571 pub prog_ref_level: INT,
572 pub PCE_mixdown_idx_present: UCHAR,
573 pub ETSI_DmxLvl_present: UCHAR,
574 pub centerMixLevel: SCHAR,
575 pub surroundMixLevel: SCHAR,
576 pub dolbySurroundMode: UCHAR,
577 pub drcPresentationMode: UCHAR,
578 pub ExtMetaData: AACENC_ExtMetaData,
579}
580
581impl Default for AACENC_MetaData {
582 fn default() -> Self {
583 Self {
584 drc_profile: AACENC_METADATA_DRC_NONE,
585 comp_profile: AACENC_METADATA_DRC_NOT_PRESENT,
586 drc_TargetRefLevel: -(31 << 16),
587 comp_TargetRefLevel: -(23 << 16),
588 prog_ref_level_present: 0,
589 prog_ref_level: -(23 << 16),
590 PCE_mixdown_idx_present: 0,
591 ETSI_DmxLvl_present: 0,
592 centerMixLevel: 0,
593 surroundMixLevel: 0,
594 dolbySurroundMode: 0,
595 drcPresentationMode: 0,
596 ExtMetaData: AACENC_ExtMetaData::default(),
597 }
598 }
599}
600
601pub const AACDEC_CONCEAL: UINT = 1;
602pub const AACDEC_FLUSH: UINT = 2;
603pub const AACDEC_INTR: UINT = 4;
604pub const AACDEC_CLRHIST: UINT = 8;
605
606pub type AACDEC_PARAM = i32;
607pub const AAC_PCM_DUAL_CHANNEL_OUTPUT_MODE: AACDEC_PARAM = 0x0002;
608pub const AAC_PCM_OUTPUT_CHANNEL_MAPPING: AACDEC_PARAM = 0x0003;
609pub const AAC_PCM_LIMITER_ENABLE: AACDEC_PARAM = 0x0004;
610pub const AAC_PCM_LIMITER_ATTACK_TIME: AACDEC_PARAM = 0x0005;
611pub const AAC_PCM_LIMITER_RELEAS_TIME: AACDEC_PARAM = 0x0006;
612pub const AAC_PCM_MIN_OUTPUT_CHANNELS: AACDEC_PARAM = 0x0011;
613pub const AAC_PCM_MAX_OUTPUT_CHANNELS: AACDEC_PARAM = 0x0012;
614pub const AAC_METADATA_PROFILE: AACDEC_PARAM = 0x0020;
615pub const AAC_METADATA_EXPIRY_TIME: AACDEC_PARAM = 0x0021;
616pub const AAC_CONCEAL_METHOD: AACDEC_PARAM = 0x0100;
617pub const AAC_DRC_BOOST_FACTOR: AACDEC_PARAM = 0x0200;
618pub const AAC_DRC_ATTENUATION_FACTOR: AACDEC_PARAM = 0x0201;
619pub const AAC_DRC_REFERENCE_LEVEL: AACDEC_PARAM = 0x0202;
620pub const AAC_DRC_HEAVY_COMPRESSION: AACDEC_PARAM = 0x0203;
621pub const AAC_DRC_DEFAULT_PRESENTATION_MODE: AACDEC_PARAM = 0x0204;
622pub const AAC_DRC_ENC_TARGET_LEVEL: AACDEC_PARAM = 0x0205;
623pub const AAC_UNIDRC_SET_EFFECT: AACDEC_PARAM = 0x0206;
624pub const AAC_UNIDRC_ALBUM_MODE: AACDEC_PARAM = 0x0207;
625pub const AAC_QMF_LOWPOWER: AACDEC_PARAM = 0x0300;
626pub const AAC_TPDEC_CLEAR_BUFFER: AACDEC_PARAM = 0x0603;
627
628#[repr(C)]
629#[derive(Clone, Copy, Debug)]
630pub struct AACENC_InfoStruct {
631 pub maxOutBufBytes: UINT,
632 pub maxAncBytes: UINT,
633 pub inBufFillLevel: UINT,
634 pub inputChannels: UINT,
635 pub frameLength: UINT,
636 pub nDelay: UINT,
637 pub nDelayCore: UINT,
638 pub confBuf: [UCHAR; 64],
639 pub confSize: UINT,
640}
641
642impl Default for AACENC_InfoStruct {
643 fn default() -> Self {
644 Self {
645 maxOutBufBytes: 0,
646 maxAncBytes: 0,
647 inBufFillLevel: 0,
648 inputChannels: 0,
649 frameLength: 0,
650 nDelay: 0,
651 nDelayCore: 0,
652 confBuf: [0; 64],
653 confSize: 0,
654 }
655 }
656}
657
658#[repr(C)]
659#[derive(Clone, Copy, Debug)]
660pub struct AACENC_BufDesc {
661 pub numBufs: INT,
662 pub bufs: *mut *mut c_void,
663 pub bufferIdentifiers: *mut INT,
664 pub bufSizes: *mut INT,
665 pub bufElSizes: *mut INT,
666}
667
668#[repr(C)]
669#[derive(Clone, Copy, Debug, Default)]
670pub struct AACENC_InArgs {
671 pub numInSamples: INT,
672 pub numAncBytes: INT,
673}
674
675#[repr(C)]
676#[derive(Clone, Copy, Debug, Default)]
677pub struct AACENC_OutArgs {
678 pub numOutBytes: INT,
679 pub numInSamples: INT,
680 pub numAncBytes: INT,
681 pub bitResState: INT,
682}
683
684pub type AUDIO_CHANNEL_TYPE = i32;
685
686#[repr(C)]
687#[derive(Debug)]
688pub struct CStreamInfo {
689 pub sampleRate: INT,
690 pub frameSize: INT,
691 pub numChannels: INT,
692 pub pChannelType: *mut AUDIO_CHANNEL_TYPE,
693 pub pChannelIndices: *mut UCHAR,
694 pub aacSampleRate: INT,
695 pub profile: INT,
696 pub aot: AUDIO_OBJECT_TYPE,
697 pub channelConfig: INT,
698 pub bitRate: INT,
699 pub aacSamplesPerFrame: INT,
700 pub aacNumChannels: INT,
701 pub extAot: AUDIO_OBJECT_TYPE,
702 pub extSamplingRate: INT,
703 pub outputDelay: UINT,
704 pub flags: UINT,
705 pub epConfig: SCHAR,
706 pub numLostAccessUnits: INT,
707 pub numTotalBytes: INT64,
708 pub numBadBytes: INT64,
709 pub numTotalAccessUnits: INT64,
710 pub numBadAccessUnits: INT64,
711 pub drcProgRefLev: SCHAR,
712 pub drcPresMode: SCHAR,
713 pub outputLoudness: INT,
714}
715
716extern "C" {
717 pub fn fdk_mps_encode_frame_test(
718 sampling_rate: UINT,
719 frame_length: UINT,
720 left: *const INT_PCM,
721 right: *const INT_PCM,
722 payload: *mut UCHAR,
723 payload_capacity: UINT,
724 payload_bits: *mut UINT,
725 downmix: *mut INT_PCM,
726 ) -> INT;
727 pub fn fdk_mps_encode_two_frames_test(
728 sampling_rate: UINT,
729 frame_length: UINT,
730 left: *const INT_PCM,
731 right: *const INT_PCM,
732 payload: *mut UCHAR,
733 payload_stride: UINT,
734 payload_bits: *mut UINT,
735 ) -> INT;
736 pub fn fdk_mps_last_parameters_test(cld: *mut SCHAR, icc: *mut SCHAR, capacity: UINT) -> INT;
737 pub fn fdk_sbr_frequency_tables_test(
738 sampling_rate: UINT,
739 start_frequency: UCHAR,
740 stop_frequency: UCHAR,
741 crossover_band: UCHAR,
742 frequency_scale: UCHAR,
743 alter_scale: UCHAR,
744 noise_bands: UCHAR,
745 low_bands: *mut UCHAR,
746 high_bands: *mut UCHAR,
747 noise_band_count: *mut UCHAR,
748 low_table: *mut UCHAR,
749 high_table: *mut UCHAR,
750 ) -> INT;
751 pub fn aacEncOpen(
752 phAacEncoder: *mut HANDLE_AACENCODER,
753 encModules: UINT,
754 maxChannels: UINT,
755 ) -> AACENC_ERROR;
756 pub fn aacEncClose(phAacEncoder: *mut HANDLE_AACENCODER) -> AACENC_ERROR;
757 pub fn aacEncoder_SetParam(
758 hAacEncoder: HANDLE_AACENCODER,
759 param: AACENC_PARAM,
760 value: UINT,
761 ) -> AACENC_ERROR;
762 pub fn aacEncoder_GetParam(hAacEncoder: HANDLE_AACENCODER, param: AACENC_PARAM) -> UINT;
763 pub fn aacEncEncode(
764 hAacEncoder: HANDLE_AACENCODER,
765 inBufDesc: *const AACENC_BufDesc,
766 outBufDesc: *const AACENC_BufDesc,
767 inargs: *const AACENC_InArgs,
768 outargs: *mut AACENC_OutArgs,
769 ) -> AACENC_ERROR;
770 pub fn aacEncInfo(
771 hAacEncoder: HANDLE_AACENCODER,
772 pInfo: *mut AACENC_InfoStruct,
773 ) -> AACENC_ERROR;
774
775 pub fn aacDecoder_Open(transportFmt: TRANSPORT_TYPE, nrOfLayers: UINT) -> HANDLE_AACDECODER;
776 pub fn aacDecoder_ConfigRaw(
777 self_: HANDLE_AACDECODER,
778 conf: *mut *mut UCHAR,
779 length: *const UINT,
780 ) -> AAC_DECODER_ERROR;
781 pub fn aacDecoder_Fill(
782 self_: HANDLE_AACDECODER,
783 pBuffer: *mut *mut UCHAR,
784 bufferSize: *const UINT,
785 bytesValid: *mut UINT,
786 ) -> AAC_DECODER_ERROR;
787 pub fn aacDecoder_DecodeFrame(
788 self_: HANDLE_AACDECODER,
789 pTimeData: *mut INT_PCM,
790 timeDataSize: INT,
791 flags: UINT,
792 ) -> AAC_DECODER_ERROR;
793 pub fn aacDecoder_SetParam(
794 self_: HANDLE_AACDECODER,
795 param: AACDEC_PARAM,
796 value: INT,
797 ) -> AAC_DECODER_ERROR;
798 pub fn aacDecoder_Close(self_: HANDLE_AACDECODER);
799 pub fn aacDecoder_GetStreamInfo(self_: HANDLE_AACDECODER) -> *mut CStreamInfo;
800}
801
802#[cfg(test)]
803mod tests {
804 use super::*;
805
806 #[test]
807 fn opens_and_closes_encoder() {
808 let mut handle: HANDLE_AACENCODER = std::ptr::null_mut();
809 let err = unsafe { aacEncOpen(&mut handle, 0, 2) };
810 assert_eq!(err, AACENC_OK);
811 assert!(!handle.is_null());
812 let err = unsafe { aacEncClose(&mut handle) };
813 assert_eq!(err, AACENC_OK);
814 assert!(handle.is_null());
815 }
816
817 #[test]
818 fn opens_and_closes_decoder() {
819 let handle = unsafe { aacDecoder_Open(TT_MP4_ADTS, 1) };
820 assert!(!handle.is_null());
821 unsafe { aacDecoder_Close(handle) };
822 }
823}