pocketsphinx_sys/
pocketsphinx.rs

1use libc::{c_int, c_char, c_long, c_double};
2
3use super::glist::anytype_t;
4
5// Dummy structures for typed pointers.
6// Only use them as part of pointer type, never dereference.
7#[allow(non_camel_case_types)] pub enum cmd_ln_t {}
8#[allow(non_camel_case_types)] pub enum ps_decoder_t {}
9#[allow(non_camel_case_types)] pub enum ps_nbest_t {}
10#[allow(non_camel_case_types)] pub enum ps_seg_t {}
11
12#[repr(C)]
13pub struct arg_t {
14    name: *const c_char,
15    _type: c_int,
16    deflt: *const c_char,
17    doc: *const c_char,
18}
19
20pub const ARG_REQUIRED: c_int = 1 << 0;
21pub const ARG_INTEGER: c_int = 1 << 1;
22pub const ARG_FLOATING: c_int = 1 << 2;
23pub const ARG_STRING: c_int = 1 << 3;
24pub const ARG_BOOLEAN: c_int = 1 << 4;
25pub const ARG_STRING_LIST: c_int = 1 << 5;
26
27#[link(name="pocketsphinx")]
28extern {
29
30    pub fn cmd_ln_parse_r(inout_cmdln: *mut cmd_ln_t,
31                          defn: *const arg_t,
32                          argc: i32,
33                          argv: *const *const c_char,
34                          strict: i32, ...)
35                          -> *mut cmd_ln_t;
36    pub fn cmd_ln_free_r(cmdln: *mut cmd_ln_t) -> i32;
37    pub fn cmd_ln_access_r(cmdln: *const cmd_ln_t, name: *const c_char) -> *const anytype_t;
38    pub fn cmd_ln_str_r(cmdln: *const cmd_ln_t, name: *const c_char) -> *const c_char;
39    pub fn cmd_ln_int_r(cmdln: *const cmd_ln_t, name: *const c_char) -> c_long;
40    pub fn cmd_ln_float_r(cmdln: *const cmd_ln_t, name: *const c_char) -> c_double;
41    pub fn cmd_ln_exists_r(cmdln: *const cmd_ln_t, name: *const c_char) -> c_int;
42
43
44    pub fn ps_args() -> *const arg_t;
45    pub fn ps_init(config: *mut cmd_ln_t) -> *mut ps_decoder_t;
46    pub fn ps_free(ps: *mut ps_decoder_t) -> c_int;
47
48    pub fn ps_get_config(ps: *const ps_decoder_t) -> *const cmd_ln_t;
49
50    pub fn ps_start_utt(ps: *mut ps_decoder_t, uttid: *const c_char) -> c_int;
51    pub fn ps_process_raw(ps: *mut ps_decoder_t,
52                          data: *const i16,
53                          n_samples: usize,
54                          no_search: c_int,
55                          full_utt: c_int)
56                          -> c_int;
57    pub fn ps_get_in_speech(ps: *const ps_decoder_t) -> u8;
58    pub fn ps_end_utt(ps: *mut ps_decoder_t) -> c_int;
59
60    pub fn ps_get_hyp(ps: *mut ps_decoder_t,
61                      out_best_score: *mut i32,
62                      out_uttid: *mut *const c_char)
63                      -> *const c_char;
64    pub fn ps_get_prob(ps: *const ps_decoder_t) -> i32;
65    pub fn ps_get_n_frames(ps: *const ps_decoder_t) -> i32;
66
67    pub fn ps_nbest(ps: *const ps_decoder_t, start_frame: c_int, end_frame: c_int,
68                    ctx1: *const c_char, ctx2: *const c_char) -> *mut ps_nbest_t;
69    pub fn ps_nbest_free(nbest: *mut ps_nbest_t);
70    pub fn ps_nbest_hyp(nbest: *const ps_nbest_t, out_score: *mut i32) -> *const c_char;
71    pub fn ps_nbest_next(nbest: *mut ps_nbest_t) -> *mut ps_nbest_t;
72    pub fn ps_nbest_seg(nbest: *const ps_nbest_t, out_score: *mut i32) -> *mut ps_seg_t;
73
74    pub fn ps_seg_frames(seg: *const ps_seg_t, out_sf: *mut c_int, out_ef: *mut c_int);
75    pub fn ps_seg_free(seg: *mut ps_seg_t);
76    pub fn ps_seg_iter(ps: *const ps_decoder_t, out_best_score: *mut i32) -> *mut ps_seg_t;
77    pub fn ps_seg_next(seg: *mut ps_seg_t) -> *mut ps_seg_t;
78    pub fn ps_seg_prob(seg: *const ps_seg_t,
79                       out_ascr: *mut i32, out_lscr: *mut i32, out_lback: *mut i32) -> i32;
80    pub fn ps_seg_word(seg: *const ps_seg_t) -> *const c_char;
81
82}
83
84// Macros
85pub unsafe fn cmd_ln_boolean_r(cmdln: *const cmd_ln_t, name: *const c_char) -> bool {
86    cmd_ln_int_r(cmdln, name) != 0
87}
88pub unsafe fn cmd_ln_int32_r(cmdln: *const cmd_ln_t, name: *const c_char) -> i32 {
89    cmd_ln_int_r(cmdln, name) as i32
90}
91pub unsafe fn cmd_ln_float32_r(cmdln: *const cmd_ln_t, name: *const c_char) -> f32 {
92    cmd_ln_float_r(cmdln, name) as f32
93}
94pub unsafe fn cmd_ln_float64_r(cmdln: *const cmd_ln_t, name: *const c_char) -> f64 {
95    cmd_ln_float_r(cmdln, name) as f64
96}