mig/squeezers
1
0
Fork 0
Code Issues Pull Requests Releases Wiki Activity

transpiled by C2Rust 0.14

Browse Source
This commit is contained in:
Micha Glave 2020-04-17 13:12:00 +02:00
parent 33155c6ce2
commit 9896c4cd01
25 changed files with 13476 additions and 15400 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

27
Cargo.toml
View File

@ -3,7 +3,7 @@ members = [
]
[package]
name = "squeezers"
name = "sqeezers"
authors = ["C2Rust"]
version = "0.0.0"
publish = false
@ -11,19 +11,34 @@ edition = "2018"
autobins = false
[lib]
name = "squeezers"
name = "sqeezers"
path = "lib.rs"
crate-type = ["staticlib", "rlib"]
[[bin]]
path = "src/main.rs"
name = "main"
[dependencies]
c2rust-bitfields = "0.3"
c2rust-asm-casts = "0.1"
libc = "0.2"
[dependencies.c2rust-xcheck-plugin]
path = "../c2rust/cross-checks/rust-checks/rustc-plugin"
version = "*"
[dependencies.c2rust-xcheck-derive]
path = "../c2rust/cross-checks/rust-checks/derive-macros"
version = "*"
[dependencies.c2rust-xcheck-runtime]
path = "../c2rust/cross-checks/rust-checks/runtime"
version = "*"
features = ["libc-hash", "fixed-length-array-hash"]
[dependencies.c2rust-xcheck-backend-zstd-logging]
path = "../c2rust/cross-checks/rust-checks/backends/zstd-logging"
version = "*"
[dependencies.c2rust-ast-printer]
path = "../c2rust/cross-checks/rust-checks/"
version = "*"

60
lib.rs
View File

@ -5,47 +5,49 @@
#![allow(non_upper_case_globals)]
#![allow(unused_assignments)]
#![allow(unused_mut)]
#![cross_check(yes)]
#![feature(asm)]
#![feature(c_variadic)]
#![feature(const_raw_ptr_to_usize_cast)]
#![feature(extern_types)]
#![feature(main)]
#![feature(plugin)]
#![feature(ptr_wrapping_offset_from)]
#![feature(register_tool)]
#![register_tool(c2rust)]
#[path = "src/internal.rs"]
pub mod internal;
#[path = "src/squeezelite_h.rs"]
pub mod squeezelite_h;
#[path = "src/stdarg_h.rs"]
pub mod stdarg_h;
#[path = "src/stddef_h.rs"]
pub mod stddef_h;
#[path = "src/stdlib.rs"]
pub mod stdlib;
#[macro_use]
extern crate c2rust_bitfields;
#[macro_use]
extern crate c2rust_bitfields;#[macro_use]
extern crate c2rust_asm_casts;
extern crate libc;
#![plugin(c2rust_xcheck_plugin())]
#[macro_use] extern crate c2rust_xcheck_derive;
#[macro_use] extern crate c2rust_xcheck_runtime;
extern crate c2rust_xcheck_backend_zstd_logging;
#[global_allocator]
static C2RUST_ALLOC: ::std::alloc::System = ::std::alloc::System;
pub mod src {
pub mod buffer;
pub mod decode;
pub mod faad;
pub mod flac;
pub mod mad;
pub mod mpg;
pub mod output;
pub mod output_alsa;
pub mod output_pa;
pub mod output_pack;
pub mod output_pulse;
pub mod output_stdout;
pub mod pcm;
pub mod slimproto;
pub mod stream;
pub mod utils;
pub mod vorbis;
pub mod buffer;
pub mod decode;
pub mod faad;
pub mod flac;
pub mod mad;
pub mod main;
pub mod mpg;
pub mod output;
pub mod output_alsa;
pub mod output_pa;
pub mod output_pack;
pub mod output_pulse;
pub mod output_stdout;
pub mod pcm;
pub mod slimproto;
pub mod stream;
pub mod utils;
pub mod vorbis;
} // mod src

258
src/buffer.rs
View File

@ -1,30 +1,81 @@
use ::libc;
pub use crate::stddef_h::size_t;
pub use crate::stdlib::__uint8_t;
pub use crate::stdlib::u_int8_t;
pub use crate::squeezelite_h::buffer;
pub use crate::squeezelite_h::u8_t;
pub use crate::stdlib::__pthread_internal_list;
pub use crate::stdlib::__pthread_list_t;
pub use crate::stdlib::__pthread_mutex_s;
use crate::stdlib::free;
use crate::stdlib::malloc;
pub use crate::stdlib::pthread_mutex_destroy;
pub use crate::stdlib::pthread_mutex_init;
pub use crate::stdlib::pthread_mutex_lock;
pub use crate::stdlib::pthread_mutex_t;
pub use crate::stdlib::pthread_mutex_unlock;
pub use crate::stdlib::pthread_mutexattr_destroy;
pub use crate::stdlib::pthread_mutexattr_init;
pub use crate::stdlib::pthread_mutexattr_setprotocol;
pub use crate::stdlib::pthread_mutexattr_t;
pub use crate::stdlib::C2RustUnnamed_0;
pub use crate::stdlib::PTHREAD_PRIO_INHERIT;
pub use crate::stdlib::PTHREAD_PRIO_NONE;
pub use crate::stdlib::PTHREAD_PRIO_PROTECT;
/*
extern "C" {
#[no_mangle]
fn malloc(_: libc::c_ulong) -> *mut libc::c_void;
#[no_mangle]
fn free(__ptr: *mut libc::c_void);
#[no_mangle]
fn pthread_mutex_init(__mutex: *mut pthread_mutex_t,
__mutexattr: *const pthread_mutexattr_t)
-> libc::c_int;
#[no_mangle]
fn pthread_mutex_destroy(__mutex: *mut pthread_mutex_t) -> libc::c_int;
#[no_mangle]
fn pthread_mutex_lock(__mutex: *mut pthread_mutex_t) -> libc::c_int;
#[no_mangle]
fn pthread_mutex_unlock(__mutex: *mut pthread_mutex_t) -> libc::c_int;
#[no_mangle]
fn pthread_mutexattr_init(__attr: *mut pthread_mutexattr_t)
-> libc::c_int;
#[no_mangle]
fn pthread_mutexattr_destroy(__attr: *mut pthread_mutexattr_t)
-> libc::c_int;
#[no_mangle]
fn pthread_mutexattr_setprotocol(__attr: *mut pthread_mutexattr_t,
__protocol: libc::c_int) -> libc::c_int;
}
pub type size_t = libc::c_ulong;
pub type __uint8_t = libc::c_uchar;
pub type u_int8_t = __uint8_t;
#[derive(Copy, Clone)]
#[repr(C)]
pub struct __pthread_internal_list {
pub __prev: *mut __pthread_internal_list,
pub __next: *mut __pthread_internal_list,
}
pub type __pthread_list_t = __pthread_internal_list;
#[derive(Copy, Clone)]
#[repr(C)]
pub struct __pthread_mutex_s {
pub __lock: libc::c_int,
pub __count: libc::c_uint,
pub __owner: libc::c_int,
pub __nusers: libc::c_uint,
pub __kind: libc::c_int,
pub __spins: libc::c_short,
pub __elision: libc::c_short,
pub __list: __pthread_list_t,
}
#[derive(Copy, Clone)]
#[repr(C)]
pub union pthread_mutexattr_t {
pub __size: [libc::c_char; 4],
pub __align: libc::c_int,
}
#[derive(Copy, Clone)]
#[repr(C)]
pub union pthread_mutex_t {
pub __data: __pthread_mutex_s,
pub __size: [libc::c_char; 40],
pub __align: libc::c_long,
}
pub type C2RustUnnamed = libc::c_uint;
pub const PTHREAD_PRIO_PROTECT: C2RustUnnamed = 2;
pub const PTHREAD_PRIO_INHERIT: C2RustUnnamed = 1;
pub const PTHREAD_PRIO_NONE: C2RustUnnamed = 0;
pub type u8_t = u_int8_t;
#[derive(Copy, Clone)]
#[repr(C)]
pub struct buffer {
pub buf: *mut u8_t,
pub readp: *mut u8_t,
pub writep: *mut u8_t,
pub wrap: *mut u8_t,
pub size: size_t,
pub base_size: size_t,
pub mutex: pthread_mutex_t,
}
/*
* Squeezelite - lightweight headless squeezebox emulator
*
* (c) Adrian Smith 2012-2015, triode1@btinternet.com
@ -34,7 +85,7 @@ pub use crate::stdlib::PTHREAD_PRIO_PROTECT;
* it under the terms of the GNU General Public License as published by
* the Free Software Foundation, either version 3 of the License, or
* (at your option) any later version.
*
*
* This program is distributed in the hope that it will be useful,
* but WITHOUT ANY WARRANTY; without even the implied warranty of
* MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
@ -44,112 +95,94 @@ pub use crate::stdlib::PTHREAD_PRIO_PROTECT;
* along with this program. If not, see <http://www.gnu.org/licenses/>.
*
*/
// fifo bufffers
// fifo bufffers
// _* called with muxtex locked
#[inline]
unsafe extern "C" fn _buf_used(mut buf: *mut crate::squeezelite_h::buffer) -> libc::c_uint {
unsafe extern "C" fn _buf_used(mut buf: *mut buffer) -> libc::c_uint {
return if (*buf).writep >= (*buf).readp {
(*buf).writep.wrapping_offset_from((*buf).readp) as libc::c_long as libc::c_ulong
} else {
(*buf).size.wrapping_sub(
(*buf).readp.wrapping_offset_from((*buf).writep) as libc::c_long as libc::c_ulong,
)
} as libc::c_uint;
(*buf).writep.wrapping_offset_from((*buf).readp) as
libc::c_long as libc::c_ulong
} else {
(*buf).size.wrapping_sub((*buf).readp.wrapping_offset_from((*buf).writep)
as libc::c_long as libc::c_ulong)
} as libc::c_uint;
}
#[no_mangle]
pub unsafe extern "C" fn _buf_space(mut buf: *mut crate::squeezelite_h::buffer) -> libc::c_uint {
return (*buf)
.size
.wrapping_sub(_buf_used(buf) as libc::c_ulong)
.wrapping_sub(1 as libc::c_int as libc::c_ulong) as libc::c_uint;
pub unsafe extern "C" fn _buf_space(mut buf: *mut buffer) -> libc::c_uint {
return (*buf).size.wrapping_sub(_buf_used(buf) as
libc::c_ulong).wrapping_sub(1 as
libc::c_int
as
libc::c_ulong)
as libc::c_uint;
// reduce by one as full same as empty otherwise
}
#[no_mangle]
pub unsafe extern "C" fn _buf_cont_read(
mut buf: *mut crate::squeezelite_h::buffer,
) -> libc::c_uint {
pub unsafe extern "C" fn _buf_cont_read(mut buf: *mut buffer)
-> libc::c_uint {
return if (*buf).writep >= (*buf).readp {
(*buf).writep.wrapping_offset_from((*buf).readp) as libc::c_long
} else {
(*buf).wrap.wrapping_offset_from((*buf).readp) as libc::c_long
} as libc::c_uint;
(*buf).writep.wrapping_offset_from((*buf).readp) as
libc::c_long
} else {
(*buf).wrap.wrapping_offset_from((*buf).readp) as libc::c_long
} as libc::c_uint;
}
#[no_mangle]
pub unsafe extern "C" fn _buf_cont_write(
mut buf: *mut crate::squeezelite_h::buffer,
) -> libc::c_uint {
pub unsafe extern "C" fn _buf_cont_write(mut buf: *mut buffer)
-> libc::c_uint {
return if (*buf).writep >= (*buf).readp {
(*buf).wrap.wrapping_offset_from((*buf).writep) as libc::c_long
} else {
(*buf).readp.wrapping_offset_from((*buf).writep) as libc::c_long
} as libc::c_uint;
(*buf).wrap.wrapping_offset_from((*buf).writep) as libc::c_long
} else {
(*buf).readp.wrapping_offset_from((*buf).writep) as
libc::c_long
} as libc::c_uint;
}
#[no_mangle]
pub unsafe extern "C" fn _buf_inc_readp(
mut buf: *mut crate::squeezelite_h::buffer,
mut by: libc::c_uint,
) {
pub unsafe extern "C" fn _buf_inc_readp(mut buf: *mut buffer,
mut by: libc::c_uint) {
(*buf).readp = (*buf).readp.offset(by as isize);
if (*buf).readp >= (*buf).wrap {
(*buf).readp = (*buf).readp.offset(-((*buf).size as isize))
};
}
#[no_mangle]
pub unsafe extern "C" fn _buf_inc_writep(
mut buf: *mut crate::squeezelite_h::buffer,
mut by: libc::c_uint,
) {
pub unsafe extern "C" fn _buf_inc_writep(mut buf: *mut buffer,
mut by: libc::c_uint) {
(*buf).writep = (*buf).writep.offset(by as isize);
if (*buf).writep >= (*buf).wrap {
(*buf).writep = (*buf).writep.offset(-((*buf).size as isize))
};
}
#[no_mangle]
pub unsafe extern "C" fn buf_flush(mut buf: *mut crate::squeezelite_h::buffer) {
crate::stdlib::pthread_mutex_lock(&mut (*buf).mutex);
pub unsafe extern "C" fn buf_flush(mut buf: *mut buffer) {
pthread_mutex_lock(&mut (*buf).mutex);
(*buf).readp = (*buf).buf;
(*buf).writep = (*buf).buf;
crate::stdlib::pthread_mutex_unlock(&mut (*buf).mutex);
pthread_mutex_unlock(&mut (*buf).mutex);
}
// adjust buffer to multiple of mod bytes so reading in multiple always wraps on frame boundary
#[no_mangle]
pub unsafe extern "C" fn buf_adjust(
mut buf: *mut crate::squeezelite_h::buffer,
mut mod_0: crate::stddef_h::size_t,
) {
let mut size: crate::stddef_h::size_t = 0;
crate::stdlib::pthread_mutex_lock(&mut (*buf).mutex);
pub unsafe extern "C" fn buf_adjust(mut buf: *mut buffer, mut mod_0: size_t) {
let mut size: size_t = 0;
pthread_mutex_lock(&mut (*buf).mutex);
size =
((*buf).base_size.wrapping_div(mod_0) as libc::c_uint as libc::c_ulong).wrapping_mul(mod_0);
((*buf).base_size.wrapping_div(mod_0) as libc::c_uint as
libc::c_ulong).wrapping_mul(mod_0);
(*buf).readp = (*buf).buf;
(*buf).writep = (*buf).buf;
(*buf).wrap = (*buf).buf.offset(size as isize);
(*buf).size = size;
crate::stdlib::pthread_mutex_unlock(&mut (*buf).mutex);
pthread_mutex_unlock(&mut (*buf).mutex);
}
// called with mutex locked to resize, does not retain contents, reverts to original size if fails
#[no_mangle]
pub unsafe extern "C" fn _buf_resize(
mut buf: *mut crate::squeezelite_h::buffer,
mut size: crate::stddef_h::size_t,
) {
crate::stdlib::free((*buf).buf as *mut libc::c_void);
(*buf).buf = crate::stdlib::malloc(size) as *mut crate::squeezelite_h::u8_t;
pub unsafe extern "C" fn _buf_resize(mut buf: *mut buffer, mut size: size_t) {
free((*buf).buf as *mut libc::c_void);
(*buf).buf = malloc(size) as *mut u8_t;
if (*buf).buf.is_null() {
size = (*buf).size;
(*buf).buf = crate::stdlib::malloc(size) as *mut crate::squeezelite_h::u8_t;
if (*buf).buf.is_null() {
size = 0 as libc::c_int as crate::stddef_h::size_t
}
(*buf).buf = malloc(size) as *mut u8_t;
if (*buf).buf.is_null() { size = 0 as libc::c_int as size_t }
}
(*buf).readp = (*buf).buf;
(*buf).writep = (*buf).buf;
@ -158,37 +191,31 @@ pub unsafe extern "C" fn _buf_resize(
(*buf).base_size = size;
}
#[no_mangle]
pub unsafe extern "C" fn buf_init(
mut buf: *mut crate::squeezelite_h::buffer,
mut size: crate::stddef_h::size_t,
) {
(*buf).buf = crate::stdlib::malloc(size) as *mut crate::squeezelite_h::u8_t;
pub unsafe extern "C" fn buf_init(mut buf: *mut buffer, mut size: size_t) {
(*buf).buf = malloc(size) as *mut u8_t;
(*buf).readp = (*buf).buf;
(*buf).writep = (*buf).buf;
(*buf).wrap = (*buf).buf.offset(size as isize);
(*buf).size = size;
(*buf).base_size = size;
let mut attr = crate::stdlib::pthread_mutexattr_t { __size: [0; 4] };
crate::stdlib::pthread_mutexattr_init(&mut attr);
crate::stdlib::pthread_mutexattr_setprotocol(
&mut attr,
crate::stdlib::PTHREAD_PRIO_INHERIT as libc::c_int,
);
crate::stdlib::pthread_mutex_init(&mut (*buf).mutex, &mut attr);
crate::stdlib::pthread_mutexattr_destroy(&mut attr);
let mut attr: pthread_mutexattr_t = pthread_mutexattr_t{__size: [0; 4],};
pthread_mutexattr_init(&mut attr);
pthread_mutexattr_setprotocol(&mut attr,
PTHREAD_PRIO_INHERIT as libc::c_int);
pthread_mutex_init(&mut (*buf).mutex, &mut attr);
pthread_mutexattr_destroy(&mut attr);
}
/*
/*
* Squeezelite - lightweight headless squeezebox emulator
*
* (c) Adrian Smith 2012-2015, triode1@btinternet.com
* Ralph Irving 2015-2017, ralph_irving@hotmail.com
*
*
* This program is free software: you can redistribute it and/or modify
* it under the terms of the GNU General Public License as published by
* the Free Software Foundation, either version 3 of the License, or
* (at your option) any later version.
*
*
* This program is distributed in the hope that it will be useful,
* but WITHOUT ANY WARRANTY; without even the implied warranty of
* MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
@ -215,13 +242,12 @@ pub unsafe extern "C" fn buf_init(
// buffer.c
// _* called with mutex locked
#[no_mangle]
pub unsafe extern "C" fn buf_destroy(mut buf: *mut crate::squeezelite_h::buffer) {
pub unsafe extern "C" fn buf_destroy(mut buf: *mut buffer) {
if !(*buf).buf.is_null() {
crate::stdlib::free((*buf).buf as *mut libc::c_void);
(*buf).buf = 0 as *mut crate::squeezelite_h::u8_t;
(*buf).size = 0 as libc::c_int as crate::stddef_h::size_t;
(*buf).base_size = 0 as libc::c_int as crate::stddef_h::size_t;
crate::stdlib::pthread_mutex_destroy(&mut (*buf).mutex);
free((*buf).buf as *mut libc::c_void);
(*buf).buf = 0 as *mut u8_t;
(*buf).size = 0 as libc::c_int as size_t;
(*buf).base_size = 0 as libc::c_int as size_t;
pthread_mutex_destroy(&mut (*buf).mutex);
};
}

1096
src/decode.rs
View File

File diff suppressed because it is too large Load Diff

2312
src/faad.rs
View File

File diff suppressed because it is too large Load Diff

1902
src/flac.rs
View File

File diff suppressed because it is too large Load Diff

9
src/internal.rs
View File

@ -1,9 +0,0 @@
pub type __builtin_va_list = [crate::internal::__va_list_tag; 1];
#[repr(C)]
#[derive(Copy, Clone)]
pub struct __va_list_tag {
pub gp_offset: libc::c_uint,
pub fp_offset: libc::c_uint,
pub overflow_arg_area: *mut libc::c_void,
pub reg_save_area: *mut libc::c_void,
}

1688
src/mad.rs
View File

File diff suppressed because it is too large Load Diff

1285
src/main.rs
View File

File diff suppressed because it is too large Load Diff

1303
src/mpg.rs
View File

File diff suppressed because it is too large Load Diff

1730
src/output.rs
View File

File diff suppressed because it is too large Load Diff

3795
src/output_alsa.rs
View File

File diff suppressed because it is too large Load Diff

4
src/output_pa.rs
View File

@ -1,7 +1,7 @@
use ::libc;
// PORTAUDIO
// Portaudio output
/*
/*
* Squeezelite - lightweight headless squeezebox emulator
*
* (c) Adrian Smith 2012-2015, triode1@btinternet.com
@ -11,7 +11,7 @@ use ::libc;
* it under the terms of the GNU General Public License as published by
* the Free Software Foundation, either version 3 of the License, or
* (at your option) any later version.
*
*
* This program is distributed in the hope that it will be useful,
* but WITHOUT ANY WARRANTY; without even the implied warranty of
* MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the

372
src/output_pack.rs
View File

@ -1,324 +1,350 @@
use ::libc;
pub use crate::squeezelite_h::frames_t;
pub use crate::squeezelite_h::output_format;
pub use crate::squeezelite_h::s32_t;
pub use crate::squeezelite_h::s64_t;
pub use crate::squeezelite_h::u32_t;
pub use crate::squeezelite_h::u8_t;
pub use crate::squeezelite_h::S16_LE;
pub use crate::squeezelite_h::S24_3LE;
pub use crate::squeezelite_h::S24_LE;
pub use crate::squeezelite_h::S32_LE;
pub use crate::stdlib::__int32_t;
pub use crate::stdlib::__int64_t;
pub use crate::stdlib::__uint32_t;
pub use crate::stdlib::__uint8_t;
pub use crate::stdlib::int32_t;
pub use crate::stdlib::int64_t;
use crate::stdlib::memcpy;
pub use crate::stdlib::u_int32_t;
pub use crate::stdlib::u_int8_t;
pub use crate::stdlib::uintptr_t;
extern "C" {
#[no_mangle]
fn memcpy(_: *mut libc::c_void, _: *const libc::c_void, _: libc::c_ulong)
-> *mut libc::c_void;
}
pub type __uint8_t = libc::c_uchar;
pub type __int32_t = libc::c_int;
pub type __uint32_t = libc::c_uint;
pub type __int64_t = libc::c_long;
pub type int32_t = __int32_t;
pub type int64_t = __int64_t;
pub type u_int8_t = __uint8_t;
pub type u_int32_t = __uint32_t;
pub type u8_t = u_int8_t;
pub type u32_t = u_int32_t;
pub type s32_t = int32_t;
pub type s64_t = int64_t;
pub type frames_t = u32_t;
pub type uintptr_t = libc::c_ulong;
pub type output_format = libc::c_uint;
pub const S16_LE: output_format = 3;
pub const S24_3LE: output_format = 2;
pub const S24_LE: output_format = 1;
pub const S32_LE: output_format = 0;
// inlining these on windows prevents them being linkable...
#[inline]
unsafe extern "C" fn gain(
mut gain_0: crate::squeezelite_h::s32_t,
mut sample: crate::squeezelite_h::s32_t,
) -> crate::squeezelite_h::s32_t {
let mut res = gain_0 as crate::squeezelite_h::s64_t * sample as crate::squeezelite_h::s64_t;
unsafe extern "C" fn gain(mut gain_0: s32_t, mut sample: s32_t) -> s32_t {
let mut res: s64_t = gain_0 as s64_t * sample as s64_t;
if res as libc::c_longlong > 0x7fffffffffff as libc::c_longlong {
res = 0x7fffffffffff as libc::c_longlong as crate::squeezelite_h::s64_t
res = 0x7fffffffffff as libc::c_longlong as s64_t
}
if (res as libc::c_longlong) < -(0x7fffffffffff as libc::c_longlong) {
res = -(0x7fffffffffff as libc::c_longlong) as crate::squeezelite_h::s64_t
res = -(0x7fffffffffff as libc::c_longlong) as s64_t
}
return (res >> 16 as libc::c_int) as crate::squeezelite_h::s32_t;
return (res >> 16 as libc::c_int) as s32_t;
}
#[no_mangle]
pub unsafe extern "C" fn _scale_and_pack_frames(
mut outputptr: *mut libc::c_void,
mut inputptr: *mut crate::squeezelite_h::s32_t,
mut cnt: crate::squeezelite_h::frames_t,
mut gainL: crate::squeezelite_h::s32_t,
mut gainR: crate::squeezelite_h::s32_t,
mut format: crate::squeezelite_h::output_format,
) {
pub unsafe extern "C" fn _scale_and_pack_frames(mut outputptr:
*mut libc::c_void,
mut inputptr: *mut s32_t,
mut cnt: frames_t,
mut gainL: s32_t,
mut gainR: s32_t,
mut format: output_format) {
match format as libc::c_uint {
3 => {
let mut optr = outputptr as *mut crate::squeezelite_h::u32_t;
if gainL == 0x10000 as libc::c_int && gainR == 0x10000 as libc::c_int {
loop {
let mut optr: *mut u32_t = outputptr as *mut u32_t;
if gainL == 0x10000 as libc::c_int &&
gainR == 0x10000 as libc::c_int {
loop {
let fresh0 = cnt;
cnt = cnt.wrapping_sub(1);
if !(fresh0 != 0) {
break;
}
if !(fresh0 != 0) { break ; }
let fresh1 = optr;
optr = optr.offset(1);
*fresh1 = (*inputptr >> 16 as libc::c_int & 0xffff as libc::c_int)
as libc::c_uint
| *inputptr.offset(1 as libc::c_int as isize) as libc::c_uint
& 0xffff0000 as libc::c_uint;
*fresh1 =
(*inputptr >> 16 as libc::c_int &
0xffff as libc::c_int) as libc::c_uint |
*inputptr.offset(1 as libc::c_int as isize) as
libc::c_uint & 0xffff0000 as libc::c_uint;
inputptr = inputptr.offset(2 as libc::c_int as isize)
}
} else {
loop {
loop {
let fresh2 = cnt;
cnt = cnt.wrapping_sub(1);
if !(fresh2 != 0) {
break;
}
if !(fresh2 != 0) { break ; }
let fresh3 = optr;
optr = optr.offset(1);
*fresh3 = (gain(gainL, *inputptr) >> 16 as libc::c_int & 0xffff as libc::c_int)
as libc::c_uint
| gain(gainR, *inputptr.offset(1 as libc::c_int as isize)) as libc::c_uint
& 0xffff0000 as libc::c_uint;
*fresh3 =
(gain(gainL, *inputptr) >> 16 as libc::c_int &
0xffff as libc::c_int) as libc::c_uint |
gain(gainR,
*inputptr.offset(1 as libc::c_int as isize))
as libc::c_uint & 0xffff0000 as libc::c_uint;
inputptr = inputptr.offset(2 as libc::c_int as isize)
}
}
}
1 => {
let mut optr_0 = outputptr as *mut crate::squeezelite_h::u32_t;
if gainL == 0x10000 as libc::c_int && gainR == 0x10000 as libc::c_int {
loop {
let mut optr_0: *mut u32_t = outputptr as *mut u32_t;
if gainL == 0x10000 as libc::c_int &&
gainR == 0x10000 as libc::c_int {
loop {
let fresh4 = cnt;
cnt = cnt.wrapping_sub(1);
if !(fresh4 != 0) {
break;
}
if !(fresh4 != 0) { break ; }
let fresh5 = inputptr;
inputptr = inputptr.offset(1);
let fresh6 = optr_0;
optr_0 = optr_0.offset(1);
*fresh6 = (*fresh5 >> 8 as libc::c_int) as crate::squeezelite_h::u32_t;
*fresh6 = (*fresh5 >> 8 as libc::c_int) as u32_t;
let fresh7 = inputptr;
inputptr = inputptr.offset(1);
let fresh8 = optr_0;
optr_0 = optr_0.offset(1);
*fresh8 = (*fresh7 >> 8 as libc::c_int) as crate::squeezelite_h::u32_t
*fresh8 = (*fresh7 >> 8 as libc::c_int) as u32_t
}
} else {
loop {
loop {
let fresh9 = cnt;
cnt = cnt.wrapping_sub(1);
if !(fresh9 != 0) {
break;
}
if !(fresh9 != 0) { break ; }
let fresh10 = inputptr;
inputptr = inputptr.offset(1);
let fresh11 = optr_0;
optr_0 = optr_0.offset(1);
*fresh11 =
(gain(gainL, *fresh10) >> 8 as libc::c_int) as crate::squeezelite_h::u32_t;
(gain(gainL, *fresh10) >> 8 as libc::c_int) as u32_t;
let fresh12 = inputptr;
inputptr = inputptr.offset(1);
let fresh13 = optr_0;
optr_0 = optr_0.offset(1);
*fresh13 =
(gain(gainR, *fresh12) >> 8 as libc::c_int) as crate::squeezelite_h::u32_t
(gain(gainR, *fresh12) >> 8 as libc::c_int) as u32_t
}
}
}
2 => {
let mut optr_1 = outputptr as *mut crate::squeezelite_h::u8_t;
if gainL == 0x10000 as libc::c_int && gainR == 0x10000 as libc::c_int {
let mut optr_1: *mut u8_t = outputptr as *mut u8_t;
if gainL == 0x10000 as libc::c_int &&
gainR == 0x10000 as libc::c_int {
while cnt != 0 {
// attempt to do 32 bit memory accesses - move 2 frames at once: 16 bytes -> 12 bytes
// falls through to exception case when not aligned or if less than 2 frames to move
if optr_1 as crate::stdlib::uintptr_t & 0x3 as libc::c_int as libc::c_ulong
== 0 as libc::c_int as libc::c_ulong
&& cnt >= 2 as libc::c_int as libc::c_uint
{
let mut o_ptr =
optr_1 as *mut libc::c_void as *mut crate::squeezelite_h::u32_t;
// falls through to exception case when not aligned or if less than 2 frames to move
if optr_1 as uintptr_t &
0x3 as libc::c_int as libc::c_ulong ==
0 as libc::c_int as libc::c_ulong &&
cnt >= 2 as libc::c_int as libc::c_uint {
let mut o_ptr: *mut u32_t =
optr_1 as *mut libc::c_void as *mut u32_t;
while cnt >= 2 as libc::c_int as libc::c_uint {
let fresh14 = inputptr;
inputptr = inputptr.offset(1);
let mut l1 = *fresh14;
let mut l1: s32_t = *fresh14;
let fresh15 = inputptr;
inputptr = inputptr.offset(1);
let mut r1 = *fresh15;
let mut r1: s32_t = *fresh15;
let fresh16 = inputptr;
inputptr = inputptr.offset(1);
let mut l2 = *fresh16;
let mut l2: s32_t = *fresh16;
let fresh17 = inputptr;
inputptr = inputptr.offset(1);
let mut r2 = *fresh17;
let mut r2: s32_t = *fresh17;
let fresh18 = o_ptr;
o_ptr = o_ptr.offset(1);
*fresh18 = (l1 as libc::c_uint & 0xffffff00 as libc::c_uint)
>> 8 as libc::c_int
| ((r1 & 0xff00 as libc::c_int) << 16 as libc::c_int)
as libc::c_uint;
*fresh18 =
(l1 as libc::c_uint &
0xffffff00 as libc::c_uint) >>
8 as libc::c_int |
((r1 & 0xff00 as libc::c_int) <<
16 as libc::c_int) as libc::c_uint;
let fresh19 = o_ptr;
o_ptr = o_ptr.offset(1);
*fresh19 = (r1 as libc::c_uint & 0xffff0000 as libc::c_uint)
>> 16 as libc::c_int
| ((l2 & 0xffff00 as libc::c_int) << 8 as libc::c_int)
as libc::c_uint;
*fresh19 =
(r1 as libc::c_uint &
0xffff0000 as libc::c_uint) >>
16 as libc::c_int |
((l2 & 0xffff00 as libc::c_int) <<
8 as libc::c_int) as libc::c_uint;
let fresh20 = o_ptr;
o_ptr = o_ptr.offset(1);
*fresh20 = (l2 as libc::c_uint & 0xff000000 as libc::c_uint)
>> 24 as libc::c_int
| r2 as libc::c_uint & 0xffffff00 as libc::c_uint;
optr_1 = optr_1.offset(12 as libc::c_int as isize);
cnt = (cnt as libc::c_uint)
.wrapping_sub(2 as libc::c_int as libc::c_uint)
as crate::squeezelite_h::frames_t
as crate::squeezelite_h::frames_t
*fresh20 =
(l2 as libc::c_uint &
0xff000000 as libc::c_uint) >>
24 as libc::c_int |
r2 as libc::c_uint &
0xffffff00 as libc::c_uint;
optr_1 =
optr_1.offset(12 as libc::c_int as isize);
cnt =
(cnt as
libc::c_uint).wrapping_sub(2 as
libc::c_int
as
libc::c_uint)
as frames_t as frames_t
}
} else {
let fresh21 = inputptr;
inputptr = inputptr.offset(1);
let mut lsample = *fresh21;
let mut lsample: s32_t = *fresh21;
let fresh22 = inputptr;
inputptr = inputptr.offset(1);
let mut rsample = *fresh22;
let mut rsample: s32_t = *fresh22;
let fresh23 = optr_1;
optr_1 = optr_1.offset(1);
*fresh23 = ((lsample & 0xff00 as libc::c_int) >> 8 as libc::c_int)
as crate::squeezelite_h::u8_t;
*fresh23 =
((lsample & 0xff00 as libc::c_int) >>
8 as libc::c_int) as u8_t;
let fresh24 = optr_1;
optr_1 = optr_1.offset(1);
*fresh24 = ((lsample & 0xff0000 as libc::c_int) >> 16 as libc::c_int)
as crate::squeezelite_h::u8_t;
*fresh24 =
((lsample & 0xff0000 as libc::c_int) >>
16 as libc::c_int) as u8_t;
let fresh25 = optr_1;
optr_1 = optr_1.offset(1);
*fresh25 = ((lsample as libc::c_uint & 0xff000000 as libc::c_uint)
>> 24 as libc::c_int)
as crate::squeezelite_h::u8_t;
*fresh25 =
((lsample as libc::c_uint &
0xff000000 as libc::c_uint) >>
24 as libc::c_int) as u8_t;
let fresh26 = optr_1;
optr_1 = optr_1.offset(1);
*fresh26 = ((rsample & 0xff00 as libc::c_int) >> 8 as libc::c_int)
as crate::squeezelite_h::u8_t;
*fresh26 =
((rsample & 0xff00 as libc::c_int) >>
8 as libc::c_int) as u8_t;
let fresh27 = optr_1;
optr_1 = optr_1.offset(1);
*fresh27 = ((rsample & 0xff0000 as libc::c_int) >> 16 as libc::c_int)
as crate::squeezelite_h::u8_t;
*fresh27 =
((rsample & 0xff0000 as libc::c_int) >>
16 as libc::c_int) as u8_t;
let fresh28 = optr_1;
optr_1 = optr_1.offset(1);
*fresh28 = ((rsample as libc::c_uint & 0xff000000 as libc::c_uint)
>> 24 as libc::c_int)
as crate::squeezelite_h::u8_t;
*fresh28 =
((rsample as libc::c_uint &
0xff000000 as libc::c_uint) >>
24 as libc::c_int) as u8_t;
cnt = cnt.wrapping_sub(1)
}
}
} else {
while cnt != 0 {
// attempt to do 32 bit memory accesses - move 2 frames at once: 16 bytes -> 12 bytes
// falls through to exception case when not aligned or if less than 2 frames to move
if optr_1 as crate::stdlib::uintptr_t & 0x3 as libc::c_int as libc::c_ulong
== 0 as libc::c_int as libc::c_ulong
&& cnt >= 2 as libc::c_int as libc::c_uint
{
let mut o_ptr_0 =
optr_1 as *mut libc::c_void as *mut crate::squeezelite_h::u32_t;
// falls through to exception case when not aligned or if less than 2 frames to move
if optr_1 as uintptr_t &
0x3 as libc::c_int as libc::c_ulong ==
0 as libc::c_int as libc::c_ulong &&
cnt >= 2 as libc::c_int as libc::c_uint {
let mut o_ptr_0: *mut u32_t =
optr_1 as *mut libc::c_void as *mut u32_t;
while cnt >= 2 as libc::c_int as libc::c_uint {
let fresh29 = inputptr;
inputptr = inputptr.offset(1);
let mut l1_0 = gain(gainL, *fresh29);
let mut l1_0: s32_t = gain(gainL, *fresh29);
let fresh30 = inputptr;
inputptr = inputptr.offset(1);
let mut r1_0 = gain(gainR, *fresh30);
let mut r1_0: s32_t = gain(gainR, *fresh30);
let fresh31 = inputptr;
inputptr = inputptr.offset(1);
let mut l2_0 = gain(gainL, *fresh31);
let mut l2_0: s32_t = gain(gainL, *fresh31);
let fresh32 = inputptr;
inputptr = inputptr.offset(1);
let mut r2_0 = gain(gainR, *fresh32);
let mut r2_0: s32_t = gain(gainR, *fresh32);
let fresh33 = o_ptr_0;
o_ptr_0 = o_ptr_0.offset(1);
*fresh33 = (l1_0 as libc::c_uint & 0xffffff00 as libc::c_uint)
>> 8 as libc::c_int
| ((r1_0 & 0xff00 as libc::c_int) << 16 as libc::c_int)
as libc::c_uint;
*fresh33 =
(l1_0 as libc::c_uint &
0xffffff00 as libc::c_uint) >>
8 as libc::c_int |
((r1_0 & 0xff00 as libc::c_int) <<
16 as libc::c_int) as libc::c_uint;
let fresh34 = o_ptr_0;
o_ptr_0 = o_ptr_0.offset(1);
*fresh34 = (r1_0 as libc::c_uint & 0xffff0000 as libc::c_uint)
>> 16 as libc::c_int
| ((l2_0 & 0xffff00 as libc::c_int) << 8 as libc::c_int)
as libc::c_uint;
*fresh34 =
(r1_0 as libc::c_uint &
0xffff0000 as libc::c_uint) >>
16 as libc::c_int |
((l2_0 & 0xffff00 as libc::c_int) <<
8 as libc::c_int) as libc::c_uint;
let fresh35 = o_ptr_0;
o_ptr_0 = o_ptr_0.offset(1);
*fresh35 = (l2_0 as libc::c_uint & 0xff000000 as libc::c_uint)
>> 24 as libc::c_int
| r2_0 as libc::c_uint & 0xffffff00 as libc::c_uint;
optr_1 = optr_1.offset(12 as libc::c_int as isize);
cnt = (cnt as libc::c_uint)
.wrapping_sub(2 as libc::c_int as libc::c_uint)
as crate::squeezelite_h::frames_t
as crate::squeezelite_h::frames_t
*fresh35 =
(l2_0 as libc::c_uint &
0xff000000 as libc::c_uint) >>
24 as libc::c_int |
r2_0 as libc::c_uint &
0xffffff00 as libc::c_uint;
optr_1 =
optr_1.offset(12 as libc::c_int as isize);
cnt =
(cnt as
libc::c_uint).wrapping_sub(2 as
libc::c_int
as
libc::c_uint)
as frames_t as frames_t
}
} else {
let fresh36 = inputptr;
inputptr = inputptr.offset(1);
let mut lsample_0 = gain(gainL, *fresh36);
let mut lsample_0: s32_t = gain(gainL, *fresh36);
let fresh37 = inputptr;
inputptr = inputptr.offset(1);
let mut rsample_0 = gain(gainR, *fresh37);
let mut rsample_0: s32_t = gain(gainR, *fresh37);
let fresh38 = optr_1;
optr_1 = optr_1.offset(1);
*fresh38 = ((lsample_0 & 0xff00 as libc::c_int) >> 8 as libc::c_int)
as crate::squeezelite_h::u8_t;
*fresh38 =
((lsample_0 & 0xff00 as libc::c_int) >>
8 as libc::c_int) as u8_t;
let fresh39 = optr_1;
optr_1 = optr_1.offset(1);
*fresh39 = ((lsample_0 & 0xff0000 as libc::c_int) >> 16 as libc::c_int)
as crate::squeezelite_h::u8_t;
*fresh39 =
((lsample_0 & 0xff0000 as libc::c_int) >>
16 as libc::c_int) as u8_t;
let fresh40 = optr_1;
optr_1 = optr_1.offset(1);
*fresh40 = ((lsample_0 as libc::c_uint & 0xff000000 as libc::c_uint)
>> 24 as libc::c_int)
as crate::squeezelite_h::u8_t;
*fresh40 =
((lsample_0 as libc::c_uint &
0xff000000 as libc::c_uint) >>
24 as libc::c_int) as u8_t;
let fresh41 = optr_1;
optr_1 = optr_1.offset(1);
*fresh41 = ((rsample_0 & 0xff00 as libc::c_int) >> 8 as libc::c_int)
as crate::squeezelite_h::u8_t;
*fresh41 =
((rsample_0 & 0xff00 as libc::c_int) >>
8 as libc::c_int) as u8_t;
let fresh42 = optr_1;
optr_1 = optr_1.offset(1);
*fresh42 = ((rsample_0 & 0xff0000 as libc::c_int) >> 16 as libc::c_int)
as crate::squeezelite_h::u8_t;
*fresh42 =
((rsample_0 & 0xff0000 as libc::c_int) >>
16 as libc::c_int) as u8_t;
let fresh43 = optr_1;
optr_1 = optr_1.offset(1);
*fresh43 = ((rsample_0 as libc::c_uint & 0xff000000 as libc::c_uint)
>> 24 as libc::c_int)
as crate::squeezelite_h::u8_t;
*fresh43 =
((rsample_0 as libc::c_uint &
0xff000000 as libc::c_uint) >>
24 as libc::c_int) as u8_t;
cnt = cnt.wrapping_sub(1)
}
}
}
}
0 => {
let mut optr_2 = outputptr as *mut crate::squeezelite_h::u32_t;
if gainL == 0x10000 as libc::c_int && gainR == 0x10000 as libc::c_int {
crate::stdlib::memcpy(
outputptr,
inputptr as *const libc::c_void,
cnt.wrapping_mul(8 as libc::c_int as libc::c_uint) as libc::c_ulong,
);
let mut optr_2: *mut u32_t = outputptr as *mut u32_t;
if gainL == 0x10000 as libc::c_int &&
gainR == 0x10000 as libc::c_int {
memcpy(outputptr, inputptr as *const libc::c_void,
cnt.wrapping_mul(8 as libc::c_int as libc::c_uint) as
libc::c_ulong);
} else {
loop {
loop {
let fresh44 = cnt;
cnt = cnt.wrapping_sub(1);
if !(fresh44 != 0) {
break;
}
if !(fresh44 != 0) { break ; }
let fresh45 = inputptr;
inputptr = inputptr.offset(1);
let fresh46 = optr_2;
optr_2 = optr_2.offset(1);
*fresh46 = gain(gainL, *fresh45) as crate::squeezelite_h::u32_t;
*fresh46 = gain(gainL, *fresh45) as u32_t;
let fresh47 = inputptr;
inputptr = inputptr.offset(1);
let fresh48 = optr_2;
optr_2 = optr_2.offset(1);
*fresh48 = gain(gainR, *fresh47) as crate::squeezelite_h::u32_t
*fresh48 = gain(gainR, *fresh47) as u32_t
}
}
}
_ => {}
_ => { }
};
}

4
src/output_pulse.rs
View File

@ -1,6 +1,6 @@
use ::libc;
// Output using PulseAudio
/*
/*
* Squeezelite - lightweight headless squeezebox emulator
*
* (c) Adrian Smith 2012-2015, triode1@btinternet.com
@ -10,7 +10,7 @@ use ::libc;
* it under the terms of the GNU General Public License as published by
* the Free Software Foundation, either version 3 of the License, or
* (at your option) any later version.
*
*
* This program is distributed in the hope that it will be useful,
* but WITHOUT ANY WARRANTY; without even the implied warranty of
* MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the

595
src/output_stdout.rs
View File

@ -1,286 +1,396 @@
use ::libc;
pub use crate::stddef_h::size_t;
pub use crate::stdlib::_IO_codecvt;
pub use crate::stdlib::_IO_lock_t;
pub use crate::stdlib::_IO_marker;
pub use crate::stdlib::_IO_wide_data;
pub use crate::stdlib::__int32_t;
pub use crate::stdlib::__off64_t;
pub use crate::stdlib::__off_t;
pub use crate::stdlib::__uint32_t;
pub use crate::stdlib::__uint8_t;
pub use crate::stdlib::int32_t;
pub use crate::stdlib::FILE;
pub use crate::stdlib::_IO_FILE;
pub use crate::squeezelite_h::_apply_cross;
pub use crate::squeezelite_h::buffer;
pub use crate::squeezelite_h::fade_dir;
pub use crate::squeezelite_h::fade_mode;
pub use crate::squeezelite_h::fade_state;
pub use crate::squeezelite_h::frames_t;
pub use crate::squeezelite_h::lDEBUG;
pub use crate::squeezelite_h::lERROR;
pub use crate::squeezelite_h::lINFO;
pub use crate::squeezelite_h::lSDEBUG;
pub use crate::squeezelite_h::lWARN;
pub use crate::squeezelite_h::log_level;
pub use crate::squeezelite_h::output_format;
pub use crate::squeezelite_h::output_state;
pub use crate::squeezelite_h::outputstate;
pub use crate::squeezelite_h::s32_t;
pub use crate::squeezelite_h::u32_t;
pub use crate::squeezelite_h::u8_t;
pub use crate::squeezelite_h::C2RustUnnamed_1;
pub use crate::squeezelite_h::FADE_ACTIVE;
pub use crate::squeezelite_h::FADE_CROSS;
pub use crate::squeezelite_h::FADE_CROSSFADE;
pub use crate::squeezelite_h::FADE_DOWN;
pub use crate::squeezelite_h::FADE_DUE;
pub use crate::squeezelite_h::FADE_IN;
pub use crate::squeezelite_h::FADE_INACTIVE;
pub use crate::squeezelite_h::FADE_INOUT;
pub use crate::squeezelite_h::FADE_NONE;
pub use crate::squeezelite_h::FADE_OUT;
pub use crate::squeezelite_h::FADE_UP;
pub use crate::squeezelite_h::OUTPUT_BUFFER;
pub use crate::squeezelite_h::OUTPUT_OFF;
pub use crate::squeezelite_h::OUTPUT_PAUSE_FRAMES;
pub use crate::squeezelite_h::OUTPUT_RUNNING;
pub use crate::squeezelite_h::OUTPUT_SKIP_FRAMES;
pub use crate::squeezelite_h::OUTPUT_START_AT;
pub use crate::squeezelite_h::OUTPUT_STOPPED;
pub use crate::squeezelite_h::S16_LE;
pub use crate::squeezelite_h::S24_3LE;
pub use crate::squeezelite_h::S24_LE;
pub use crate::squeezelite_h::S32_LE;
pub use crate::src::output::_output_frames;
pub use crate::src::output::output_close_common;
pub use crate::src::output::output_init_common;
pub use crate::src::output_pack::_scale_and_pack_frames;
pub use crate::src::utils::gettime_ms;
pub use crate::src::utils::logprint;
pub use crate::src::utils::logtime;
pub use crate::stdlib::__pthread_internal_list;
pub use crate::stdlib::__pthread_list_t;
pub use crate::stdlib::__pthread_mutex_s;
use crate::stdlib::free;
use crate::stdlib::fwrite;
use crate::stdlib::malloc;
use crate::stdlib::memset;
use crate::stdlib::pthread_attr_destroy;
use crate::stdlib::pthread_attr_init;
use crate::stdlib::pthread_attr_setstacksize;
pub use crate::stdlib::pthread_attr_t;
use crate::stdlib::pthread_create;
use crate::stdlib::pthread_mutex_lock;
pub use crate::stdlib::pthread_mutex_t;
use crate::stdlib::pthread_mutex_unlock;
pub use crate::stdlib::pthread_t;
use crate::stdlib::stdout;
use crate::stdlib::strcmp;
pub use crate::stdlib::u_int32_t;
pub use crate::stdlib::u_int8_t;
extern "C" {
pub type _IO_wide_data;
pub type _IO_codecvt;
pub type _IO_marker;
#[no_mangle]
pub static mut output: crate::squeezelite_h::outputstate;
static mut stdout: *mut FILE;
#[no_mangle]
pub static mut outputbuf: *mut crate::squeezelite_h::buffer;
fn fwrite(_: *const libc::c_void, _: libc::c_ulong, _: libc::c_ulong,
_: *mut FILE) -> libc::c_ulong;
#[no_mangle]
pub static mut silencebuf: *mut crate::squeezelite_h::u8_t;
fn malloc(_: libc::c_ulong) -> *mut libc::c_void;
#[no_mangle]
fn free(__ptr: *mut libc::c_void);
#[no_mangle]
fn memset(_: *mut libc::c_void, _: libc::c_int, _: libc::c_ulong)
-> *mut libc::c_void;
#[no_mangle]
fn strcmp(_: *const libc::c_char, _: *const libc::c_char) -> libc::c_int;
#[no_mangle]
fn _apply_cross(outputbuf_0: *mut buffer, out_frames: frames_t,
cross_gain_in: s32_t, cross_gain_out: s32_t,
cross_ptr: *mut *mut s32_t);
#[no_mangle]
fn _scale_and_pack_frames(outputptr: *mut libc::c_void,
inputptr: *mut s32_t, cnt: frames_t,
gainL: s32_t, gainR: s32_t,
format: output_format);
#[no_mangle]
fn _output_frames(avail: frames_t) -> frames_t;
#[no_mangle]
fn output_close_common();
#[no_mangle]
fn output_init_common(level: log_level, device: *const libc::c_char,
output_buf_size: libc::c_uint,
rates: *mut libc::c_uint, idle: libc::c_uint);
#[no_mangle]
fn pthread_create(__newthread: *mut pthread_t,
__attr: *const pthread_attr_t,
__start_routine:
Option<unsafe extern "C" fn(_: *mut libc::c_void)
-> *mut libc::c_void>,
__arg: *mut libc::c_void) -> libc::c_int;
#[no_mangle]
fn pthread_attr_init(__attr: *mut pthread_attr_t) -> libc::c_int;
#[no_mangle]
fn pthread_attr_destroy(__attr: *mut pthread_attr_t) -> libc::c_int;
#[no_mangle]
fn pthread_attr_setstacksize(__attr: *mut pthread_attr_t,
__stacksize: size_t) -> libc::c_int;
#[no_mangle]
fn pthread_mutex_lock(__mutex: *mut pthread_mutex_t) -> libc::c_int;
#[no_mangle]
fn pthread_mutex_unlock(__mutex: *mut pthread_mutex_t) -> libc::c_int;
#[no_mangle]
fn logtime() -> *const libc::c_char;
#[no_mangle]
fn logprint(fmt: *const libc::c_char, _: ...);
#[no_mangle]
fn gettime_ms() -> u32_t;
#[no_mangle]
static mut output: outputstate;
#[no_mangle]
static mut outputbuf: *mut buffer;
#[no_mangle]
static mut silencebuf: *mut u8_t;
}
static mut loglevel: crate::squeezelite_h::log_level = crate::squeezelite_h::lERROR;
pub type size_t = libc::c_ulong;
pub type __uint8_t = libc::c_uchar;
pub type __int32_t = libc::c_int;
pub type __uint32_t = libc::c_uint;
pub type __off_t = libc::c_long;
pub type __off64_t = libc::c_long;
#[derive(Copy, Clone)]
#[repr(C)]
pub struct _IO_FILE {
pub _flags: libc::c_int,
pub _IO_read_ptr: *mut libc::c_char,
pub _IO_read_end: *mut libc::c_char,
pub _IO_read_base: *mut libc::c_char,
pub _IO_write_base: *mut libc::c_char,
pub _IO_write_ptr: *mut libc::c_char,
pub _IO_write_end: *mut libc::c_char,
pub _IO_buf_base: *mut libc::c_char,
pub _IO_buf_end: *mut libc::c_char,
pub _IO_save_base: *mut libc::c_char,
pub _IO_backup_base: *mut libc::c_char,
pub _IO_save_end: *mut libc::c_char,
pub _markers: *mut _IO_marker,
pub _chain: *mut _IO_FILE,
pub _fileno: libc::c_int,
pub _flags2: libc::c_int,
pub _old_offset: __off_t,
pub _cur_column: libc::c_ushort,
pub _vtable_offset: libc::c_schar,
pub _shortbuf: [libc::c_char; 1],
pub _lock: *mut libc::c_void,
pub _offset: __off64_t,
pub _codecvt: *mut _IO_codecvt,
pub _wide_data: *mut _IO_wide_data,
pub _freeres_list: *mut _IO_FILE,
pub _freeres_buf: *mut libc::c_void,
pub __pad5: size_t,
pub _mode: libc::c_int,
pub _unused2: [libc::c_char; 20],
}
pub type _IO_lock_t = ();
pub type FILE = _IO_FILE;
pub type int32_t = __int32_t;
pub type u_int8_t = __uint8_t;
pub type u_int32_t = __uint32_t;
#[derive(Copy, Clone)]
#[repr(C)]
pub struct __pthread_internal_list {
pub __prev: *mut __pthread_internal_list,
pub __next: *mut __pthread_internal_list,
}
pub type __pthread_list_t = __pthread_internal_list;
#[derive(Copy, Clone)]
#[repr(C)]
pub struct __pthread_mutex_s {
pub __lock: libc::c_int,
pub __count: libc::c_uint,
pub __owner: libc::c_int,
pub __nusers: libc::c_uint,
pub __kind: libc::c_int,
pub __spins: libc::c_short,
pub __elision: libc::c_short,
pub __list: __pthread_list_t,
}
pub type pthread_t = libc::c_ulong;
#[derive(Copy, Clone)]
#[repr(C)]
pub union pthread_attr_t {
pub __size: [libc::c_char; 56],
pub __align: libc::c_long,
}
#[derive(Copy, Clone)]
#[repr(C)]
pub union pthread_mutex_t {
pub __data: __pthread_mutex_s,
pub __size: [libc::c_char; 40],
pub __align: libc::c_long,
}
pub type u8_t = u_int8_t;
pub type u32_t = u_int32_t;
pub type s32_t = int32_t;
pub type frames_t = u32_t;
pub type log_level = libc::c_uint;
pub const lSDEBUG: log_level = 4;
pub const lDEBUG: log_level = 3;
pub const lINFO: log_level = 2;
pub const lWARN: log_level = 1;
pub const lERROR: log_level = 0;
#[derive(Copy, Clone)]
#[repr(C)]
pub struct buffer {
pub buf: *mut u8_t,
pub readp: *mut u8_t,
pub writep: *mut u8_t,
pub wrap: *mut u8_t,
pub size: size_t,
pub base_size: size_t,
pub mutex: pthread_mutex_t,
}
pub type output_state = libc::c_int;
pub const OUTPUT_START_AT: output_state = 5;
pub const OUTPUT_SKIP_FRAMES: output_state = 4;
pub const OUTPUT_PAUSE_FRAMES: output_state = 3;
pub const OUTPUT_RUNNING: output_state = 2;
pub const OUTPUT_BUFFER: output_state = 1;
pub const OUTPUT_STOPPED: output_state = 0;
pub const OUTPUT_OFF: output_state = -1;
pub type output_format = libc::c_uint;
pub const S16_LE: output_format = 3;
pub const S24_3LE: output_format = 2;
pub const S24_LE: output_format = 1;
pub const S32_LE: output_format = 0;
pub type fade_state = libc::c_uint;
pub const FADE_ACTIVE: fade_state = 2;
pub const FADE_DUE: fade_state = 1;
pub const FADE_INACTIVE: fade_state = 0;
pub type fade_dir = libc::c_uint;
pub const FADE_CROSS: fade_dir = 3;
pub const FADE_DOWN: fade_dir = 2;
pub const FADE_UP: fade_dir = 1;
pub type fade_mode = libc::c_uint;
pub const FADE_INOUT: fade_mode = 4;
pub const FADE_OUT: fade_mode = 3;
pub const FADE_IN: fade_mode = 2;
pub const FADE_CROSSFADE: fade_mode = 1;
pub const FADE_NONE: fade_mode = 0;
#[derive(Copy, Clone)]
#[repr(C)]
pub struct outputstate {
pub state: output_state,
pub format: output_format,
pub device: *const libc::c_char,
pub buffer: libc::c_uint,
pub period: libc::c_uint,
pub track_started: bool,
pub write_cb: Option<unsafe extern "C" fn(_: frames_t, _: bool, _: s32_t,
_: s32_t, _: s32_t, _: s32_t,
_: *mut *mut s32_t)
-> libc::c_int>,
pub start_frames: libc::c_uint,
pub frames_played: libc::c_uint,
pub frames_played_dmp: libc::c_uint,
pub current_sample_rate: libc::c_uint,
pub supported_rates: [libc::c_uint; 18],
pub default_sample_rate: libc::c_uint,
pub error_opening: bool,
pub device_frames: libc::c_uint,
pub updated: u32_t,
pub track_start_time: u32_t,
pub current_replay_gain: u32_t,
pub c2rust_unnamed: C2RustUnnamed,
pub next_sample_rate: libc::c_uint,
pub track_start: *mut u8_t,
pub gainL: u32_t,
pub gainR: u32_t,
pub invert: bool,
pub next_replay_gain: u32_t,
pub threshold: libc::c_uint,
pub fade: fade_state,
pub fade_start: *mut u8_t,
pub fade_end: *mut u8_t,
pub fade_dir: fade_dir,
pub fade_mode: fade_mode,
pub fade_secs: libc::c_uint,
pub rate_delay: libc::c_uint,
pub delay_active: bool,
pub stop_time: u32_t,
pub idle_to: u32_t,
}
#[derive(Copy, Clone)]
#[repr(C)]
pub union C2RustUnnamed {
pub pause_frames: u32_t,
pub skip_frames: u32_t,
pub start_at: u32_t,
}
static mut loglevel: log_level = lERROR;
static mut running: bool = 1 as libc::c_int != 0;
// buffer to hold output data so we can block on writing outside of output lock, allocated on init
static mut buf: *mut crate::squeezelite_h::u8_t =
0 as *const crate::squeezelite_h::u8_t as *mut crate::squeezelite_h::u8_t;
static mut buf: *mut u8_t = 0 as *const u8_t as *mut u8_t;
static mut buffill: libc::c_uint = 0;
static mut bytes_per_frame: libc::c_int = 0;
unsafe extern "C" fn _stdout_write_frames(
mut out_frames: crate::squeezelite_h::frames_t,
mut silence: bool,
mut gainL: crate::squeezelite_h::s32_t,
mut gainR: crate::squeezelite_h::s32_t,
mut cross_gain_in: crate::squeezelite_h::s32_t,
mut cross_gain_out: crate::squeezelite_h::s32_t,
mut cross_ptr: *mut *mut crate::squeezelite_h::s32_t,
) -> libc::c_int {
let mut obuf = 0 as *mut crate::squeezelite_h::u8_t;
unsafe extern "C" fn _stdout_write_frames(mut out_frames: frames_t,
mut silence: bool, mut gainL: s32_t,
mut gainR: s32_t,
mut cross_gain_in: s32_t,
mut cross_gain_out: s32_t,
mut cross_ptr: *mut *mut s32_t)
-> libc::c_int {
let mut obuf: *mut u8_t = 0 as *mut u8_t;
if !silence {
if output.fade as libc::c_uint
== crate::squeezelite_h::FADE_ACTIVE as libc::c_int as libc::c_uint
&& output.fade_dir as libc::c_uint
== crate::squeezelite_h::FADE_CROSS as libc::c_int as libc::c_uint
&& !(*cross_ptr).is_null()
{
crate::squeezelite_h::_apply_cross(
outputbuf,
out_frames,
cross_gain_in,
cross_gain_out,
cross_ptr,
);
if output.fade as libc::c_uint ==
FADE_ACTIVE as libc::c_int as libc::c_uint &&
output.fade_dir as libc::c_uint ==
FADE_CROSS as libc::c_int as libc::c_uint &&
!(*cross_ptr).is_null() {
_apply_cross(outputbuf, out_frames, cross_gain_in, cross_gain_out,
cross_ptr);
}
obuf = (*outputbuf).readp
} else {
obuf = silencebuf
}
crate::src::output_pack::_scale_and_pack_frames(
buf.offset(buffill.wrapping_mul(bytes_per_frame as libc::c_uint) as isize)
as *mut libc::c_void,
obuf as *mut libc::c_void as *mut crate::squeezelite_h::s32_t,
out_frames,
gainL,
gainR,
output.format,
);
} else { obuf = silencebuf }
_scale_and_pack_frames(buf.offset(buffill.wrapping_mul(bytes_per_frame as
libc::c_uint)
as isize) as *mut libc::c_void,
obuf as *mut libc::c_void as *mut s32_t,
out_frames, gainL, gainR, output.format);
buffill = buffill.wrapping_add(out_frames);
return out_frames as libc::c_int;
}
unsafe extern "C" fn output_thread() -> *mut libc::c_void {
crate::stdlib::pthread_mutex_lock(&mut (*outputbuf).mutex);
pthread_mutex_lock(&mut (*outputbuf).mutex);
match output.format as libc::c_uint {
0 => bytes_per_frame = 4 as libc::c_int * 2 as libc::c_int,
2 => bytes_per_frame = 3 as libc::c_int * 2 as libc::c_int,
3 => bytes_per_frame = 2 as libc::c_int * 2 as libc::c_int,
_ => bytes_per_frame = 4 as libc::c_int * 2 as libc::c_int,
0 => { bytes_per_frame = 4 as libc::c_int * 2 as libc::c_int }
2 => { bytes_per_frame = 3 as libc::c_int * 2 as libc::c_int }
3 => { bytes_per_frame = 2 as libc::c_int * 2 as libc::c_int }
_ => { bytes_per_frame = 4 as libc::c_int * 2 as libc::c_int }
}
crate::stdlib::pthread_mutex_unlock(&mut (*outputbuf).mutex);
pthread_mutex_unlock(&mut (*outputbuf).mutex);
while running {
crate::stdlib::pthread_mutex_lock(&mut (*outputbuf).mutex);
pthread_mutex_lock(&mut (*outputbuf).mutex);
output.device_frames = 0 as libc::c_int as libc::c_uint;
output.updated = crate::src::utils::gettime_ms();
output.updated = gettime_ms();
output.frames_played_dmp = output.frames_played;
crate::src::output::_output_frames(2048 as libc::c_int as crate::squeezelite_h::frames_t);
crate::stdlib::pthread_mutex_unlock(&mut (*outputbuf).mutex);
_output_frames(2048 as libc::c_int as frames_t);
pthread_mutex_unlock(&mut (*outputbuf).mutex);
if buffill != 0 {
crate::stdlib::fwrite(
buf as *const libc::c_void,
bytes_per_frame as libc::c_ulong,
buffill as libc::c_ulong,
crate::stdlib::stdout,
);
fwrite(buf as *const libc::c_void,
bytes_per_frame as libc::c_ulong, buffill as libc::c_ulong,
stdout);
buffill = 0 as libc::c_int as libc::c_uint
}
}
return 0 as *mut libc::c_void;
}
static mut thread: crate::stdlib::pthread_t = 0;
static mut thread: pthread_t = 0;
#[no_mangle]
pub unsafe extern "C" fn output_init_stdout(
mut level: crate::squeezelite_h::log_level,
mut output_buf_size: libc::c_uint,
mut params: *mut libc::c_char,
mut rates: *mut libc::c_uint,
mut rate_delay: libc::c_uint,
) {
pub unsafe extern "C" fn output_init_stdout(mut level: log_level,
mut output_buf_size: libc::c_uint,
mut params: *mut libc::c_char,
mut rates: *mut libc::c_uint,
mut rate_delay: libc::c_uint) {
loglevel = level;
if loglevel as libc::c_uint >= crate::squeezelite_h::lINFO as libc::c_int as libc::c_uint {
crate::src::utils::logprint(
b"%s %s:%d init output stdout\n\x00" as *const u8 as *const libc::c_char,
crate::src::utils::logtime(),
(*::std::mem::transmute::<&[u8; 19], &[libc::c_char; 19]>(b"output_init_stdout\x00"))
.as_ptr(),
130 as libc::c_int,
);
if loglevel as libc::c_uint >= lINFO as libc::c_int as libc::c_uint {
logprint(b"%s %s:%d init output stdout\n\x00" as *const u8 as
*const libc::c_char, logtime(),
(*::std::mem::transmute::<&[u8; 19],
&[libc::c_char; 19]>(b"output_init_stdout\x00")).as_ptr(),
130 as libc::c_int);
}
buf = crate::stdlib::malloc((2048 as libc::c_int * 8 as libc::c_int) as libc::c_ulong)
as *mut crate::squeezelite_h::u8_t;
buf =
malloc((2048 as libc::c_int * 8 as libc::c_int) as libc::c_ulong) as
*mut u8_t;
if buf.is_null() {
crate::src::utils::logprint(
b"%s %s:%d unable to malloc buf\n\x00" as *const u8 as *const libc::c_char,
crate::src::utils::logtime(),
(*::std::mem::transmute::<&[u8; 19], &[libc::c_char; 19]>(b"output_init_stdout\x00"))
.as_ptr(),
134 as libc::c_int,
);
return;
logprint(b"%s %s:%d unable to malloc buf\n\x00" as *const u8 as
*const libc::c_char, logtime(),
(*::std::mem::transmute::<&[u8; 19],
&[libc::c_char; 19]>(b"output_init_stdout\x00")).as_ptr(),
134 as libc::c_int);
return
}
buffill = 0 as libc::c_int as libc::c_uint;
crate::stdlib::memset(
&mut output as *mut crate::squeezelite_h::outputstate as *mut libc::c_void,
0 as libc::c_int,
::std::mem::size_of::<crate::squeezelite_h::outputstate>() as libc::c_ulong,
);
output.format = crate::squeezelite_h::S32_LE;
output.start_frames = (2048 as libc::c_int * 2 as libc::c_int) as libc::c_uint;
output.write_cb = Some(
_stdout_write_frames
as unsafe extern "C" fn(
_: crate::squeezelite_h::frames_t,
_: bool,
_: crate::squeezelite_h::s32_t,
_: crate::squeezelite_h::s32_t,
_: crate::squeezelite_h::s32_t,
_: crate::squeezelite_h::s32_t,
_: *mut *mut crate::squeezelite_h::s32_t,
) -> libc::c_int,
);
memset(&mut output as *mut outputstate as *mut libc::c_void,
0 as libc::c_int,
::std::mem::size_of::<outputstate>() as libc::c_ulong);
output.format = S32_LE;
output.start_frames =
(2048 as libc::c_int * 2 as libc::c_int) as libc::c_uint;
output.write_cb =
Some(_stdout_write_frames as
unsafe extern "C" fn(_: frames_t, _: bool, _: s32_t,
_: s32_t, _: s32_t, _: s32_t,
_: *mut *mut s32_t) -> libc::c_int);
output.rate_delay = rate_delay;
if !params.is_null() {
if crate::stdlib::strcmp(params, b"32\x00" as *const u8 as *const libc::c_char) == 0 {
output.format = crate::squeezelite_h::S32_LE
if strcmp(params, b"32\x00" as *const u8 as *const libc::c_char) == 0
{
output.format = S32_LE
}
if crate::stdlib::strcmp(params, b"24\x00" as *const u8 as *const libc::c_char) == 0 {
output.format = crate::squeezelite_h::S24_3LE
if strcmp(params, b"24\x00" as *const u8 as *const libc::c_char) == 0
{
output.format = S24_3LE
}
if crate::stdlib::strcmp(params, b"16\x00" as *const u8 as *const libc::c_char) == 0 {
output.format = crate::squeezelite_h::S16_LE
if strcmp(params, b"16\x00" as *const u8 as *const libc::c_char) == 0
{
output.format = S16_LE
}
}
// ensure output rate is specified to avoid test open
if *rates.offset(0 as libc::c_int as isize) == 0 {
*rates.offset(0 as libc::c_int as isize) = 44100 as libc::c_int as libc::c_uint
*rates.offset(0 as libc::c_int as isize) =
44100 as libc::c_int as libc::c_uint
}
crate::src::output::output_init_common(
level,
b"-\x00" as *const u8 as *const libc::c_char,
output_buf_size,
rates,
0 as libc::c_int as libc::c_uint,
);
let mut attr = crate::stdlib::pthread_attr_t { __size: [0; 56] };
crate::stdlib::pthread_attr_init(&mut attr);
crate::stdlib::pthread_attr_setstacksize(
&mut attr,
(16384 as libc::c_int + 64 as libc::c_int * 1024 as libc::c_int) as crate::stddef_h::size_t,
);
crate::stdlib::pthread_create(
&mut thread,
&mut attr,
::std::mem::transmute::<
Option<unsafe extern "C" fn() -> *mut libc::c_void>,
Option<unsafe extern "C" fn(_: *mut libc::c_void) -> *mut libc::c_void>,
>(Some(::std::mem::transmute::<
unsafe extern "C" fn() -> *mut libc::c_void,
unsafe extern "C" fn() -> *mut libc::c_void,
>(output_thread))),
0 as *mut libc::c_void,
);
crate::stdlib::pthread_attr_destroy(&mut attr);
output_init_common(level, b"-\x00" as *const u8 as *const libc::c_char,
output_buf_size, rates,
0 as libc::c_int as libc::c_uint);
let mut attr: pthread_attr_t = pthread_attr_t{__size: [0; 56],};
pthread_attr_init(&mut attr);
pthread_attr_setstacksize(&mut attr,
(16384 as libc::c_int +
64 as libc::c_int * 1024 as libc::c_int) as
size_t);
pthread_create(&mut thread, &mut attr,
::std::mem::transmute::<Option<unsafe extern "C" fn()
-> *mut libc::c_void>,
Option<unsafe extern "C" fn(_:
*mut libc::c_void)
->
*mut libc::c_void>>(Some(::std::mem::transmute::<unsafe extern "C" fn()
->
*mut libc::c_void,
unsafe extern "C" fn()
->
*mut libc::c_void>(output_thread))),
0 as *mut libc::c_void);
pthread_attr_destroy(&mut attr);
}
/*
/*
* Squeezelite - lightweight headless squeezebox emulator
*
* (c) Adrian Smith 2012-2015, triode1@btinternet.com
* Ralph Irving 2015-2017, ralph_irving@hotmail.com
*
*
* This program is free software: you can redistribute it and/or modify
* it under the terms of the GNU General Public License as published by
* the Free Software Foundation, either version 3 of the License, or
* (at your option) any later version.
*
*
* This program is distributed in the hope that it will be useful,
* but WITHOUT ANY WARRANTY; without even the implied warranty of
* MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
@ -327,20 +437,17 @@ pub unsafe extern "C" fn output_init_stdout(
// output_pulse.c
// output_stdout.c
#[no_mangle]
pub unsafe extern "C" fn output_close_stdout() {
if loglevel as libc::c_uint >= crate::squeezelite_h::lINFO as libc::c_int as libc::c_uint {
crate::src::utils::logprint(
b"%s %s:%d close output\n\x00" as *const u8 as *const libc::c_char,
crate::src::utils::logtime(),
(*::std::mem::transmute::<&[u8; 20], &[libc::c_char; 20]>(b"output_close_stdout\x00"))
.as_ptr(),
174 as libc::c_int,
);
if loglevel as libc::c_uint >= lINFO as libc::c_int as libc::c_uint {
logprint(b"%s %s:%d close output\n\x00" as *const u8 as
*const libc::c_char, logtime(),
(*::std::mem::transmute::<&[u8; 20],
&[libc::c_char; 20]>(b"output_close_stdout\x00")).as_ptr(),
174 as libc::c_int);
}
crate::stdlib::pthread_mutex_lock(&mut (*outputbuf).mutex);
pthread_mutex_lock(&mut (*outputbuf).mutex);
running = 0 as libc::c_int != 0;
crate::stdlib::pthread_mutex_unlock(&mut (*outputbuf).mutex);
crate::stdlib::free(buf as *mut libc::c_void);
crate::src::output::output_close_common();
pthread_mutex_unlock(&mut (*outputbuf).mutex);
free(buf as *mut libc::c_void);
output_close_common();
}

1592
src/pcm.rs
View File

File diff suppressed because it is too large Load Diff

3785
src/slimproto.rs
View File

File diff suppressed because it is too large Load Diff

207
src/squeezelite_h.rs
View File

@ -1,207 +0,0 @@
extern "C" {
#[no_mangle]
pub fn _buf_used(buf: *mut crate::squeezelite_h::buffer) -> libc::c_uint;
#[no_mangle]
pub fn to_gain(f: libc::c_float) -> crate::squeezelite_h::s32_t;
#[no_mangle]
pub fn gain(
gain_0: crate::squeezelite_h::s32_t,
sample: crate::squeezelite_h::s32_t,
) -> crate::squeezelite_h::s32_t;
#[no_mangle]
pub fn _apply_cross(
outputbuf_0: *mut crate::squeezelite_h::buffer,
out_frames: crate::squeezelite_h::frames_t,
cross_gain_in: crate::squeezelite_h::s32_t,
cross_gain_out: crate::squeezelite_h::s32_t,
cross_ptr: *mut *mut crate::squeezelite_h::s32_t,
);
#[no_mangle]
pub fn _apply_gain(
outputbuf_0: *mut crate::squeezelite_h::buffer,
count: crate::squeezelite_h::frames_t,
gainL: crate::squeezelite_h::s32_t,
gainR: crate::squeezelite_h::s32_t,
);
}
// =============== BEGIN squeezelite_h ================
pub type s16_t = crate::stdlib::int16_t;
#[repr(C)]
#[derive(Copy, Clone)]
pub union C2RustUnnamed_1 {
pub pause_frames: crate::squeezelite_h::u32_t,
pub skip_frames: crate::squeezelite_h::u32_t,
pub start_at: crate::squeezelite_h::u32_t,
}
pub type u32_t = crate::stdlib::u_int32_t;
pub type u64_t = crate::stdlib::u_int64_t;
pub type s32_t = crate::stdlib::int32_t;
pub type frames_t = crate::squeezelite_h::u32_t;
pub type log_level = libc::c_uint;
pub type stream_state = libc::c_uint;
pub type disconnect_code = libc::c_uint;
#[repr(C)]
#[derive(Copy, Clone)]
pub struct streamstate {
pub state: crate::squeezelite_h::stream_state,
pub disconnect: crate::squeezelite_h::disconnect_code,
pub header: *mut libc::c_char,
pub header_len: crate::stddef_h::size_t,
pub sent_headers: bool,
pub cont_wait: bool,
pub bytes: crate::squeezelite_h::u64_t,
pub threshold: libc::c_uint,
pub meta_interval: crate::squeezelite_h::u32_t,
pub meta_next: crate::squeezelite_h::u32_t,
pub meta_left: crate::squeezelite_h::u32_t,
pub meta_send: bool,
}
pub type decode_state = libc::c_uint;
#[repr(C)]
#[derive(Copy, Clone)]
pub struct decodestate {
pub state: crate::squeezelite_h::decode_state,
pub new_stream: bool,
pub mutex: crate::stdlib::pthread_mutex_t,
}
#[repr(C)]
#[derive(Copy, Clone)]
pub struct codec {
pub id: libc::c_char,
pub types: *mut libc::c_char,
pub min_read_bytes: libc::c_uint,
pub min_space: libc::c_uint,
pub open: Option<
unsafe extern "C" fn(
_: crate::squeezelite_h::u8_t,
_: crate::squeezelite_h::u8_t,
_: crate::squeezelite_h::u8_t,
_: crate::squeezelite_h::u8_t,
) -> (),
>,
pub close: Option<unsafe extern "C" fn() -> ()>,
pub decode: Option<unsafe extern "C" fn() -> crate::squeezelite_h::decode_state>,
}
pub type fade_mode = libc::c_uint;
#[repr(C)]
#[derive(Copy, Clone)]
pub struct outputstate {
pub state: crate::squeezelite_h::output_state,
pub format: crate::squeezelite_h::output_format,
pub device: *const libc::c_char,
pub buffer: libc::c_uint,
pub period: libc::c_uint,
pub track_started: bool,
pub write_cb: Option<
unsafe extern "C" fn(
_: crate::squeezelite_h::frames_t,
_: bool,
_: crate::squeezelite_h::s32_t,
_: crate::squeezelite_h::s32_t,
_: crate::squeezelite_h::s32_t,
_: crate::squeezelite_h::s32_t,
_: *mut *mut crate::squeezelite_h::s32_t,
) -> libc::c_int,
>,
pub start_frames: libc::c_uint,
pub frames_played: libc::c_uint,
pub frames_played_dmp: libc::c_uint,
pub current_sample_rate: libc::c_uint,
pub supported_rates: [libc::c_uint; 18],
pub default_sample_rate: libc::c_uint,
pub error_opening: bool,
pub device_frames: libc::c_uint,
pub updated: crate::squeezelite_h::u32_t,
pub track_start_time: crate::squeezelite_h::u32_t,
pub current_replay_gain: crate::squeezelite_h::u32_t,
pub c2rust_unnamed: crate::squeezelite_h::C2RustUnnamed_1,
pub next_sample_rate: libc::c_uint,
pub track_start: *mut crate::squeezelite_h::u8_t,
pub gainL: crate::squeezelite_h::u32_t,
pub gainR: crate::squeezelite_h::u32_t,
pub invert: bool,
pub next_replay_gain: crate::squeezelite_h::u32_t,
pub threshold: libc::c_uint,
pub fade: crate::squeezelite_h::fade_state,
pub fade_start: *mut crate::squeezelite_h::u8_t,
pub fade_end: *mut crate::squeezelite_h::u8_t,
pub fade_dir: crate::squeezelite_h::fade_dir,
pub fade_mode: crate::squeezelite_h::fade_mode,
pub fade_secs: libc::c_uint,
pub rate_delay: libc::c_uint,
pub delay_active: bool,
pub stop_time: crate::squeezelite_h::u32_t,
pub idle_to: crate::squeezelite_h::u32_t,
}
pub type fade_dir = libc::c_uint;
pub type fade_state = libc::c_uint;
pub type output_format = libc::c_uint;
pub type output_state = libc::c_int;
pub type s64_t = crate::stdlib::int64_t;
pub const lSDEBUG: crate::squeezelite_h::log_level = 4;
pub const lDEBUG: crate::squeezelite_h::log_level = 3;
pub const lINFO: crate::squeezelite_h::log_level = 2;
pub const lWARN: crate::squeezelite_h::log_level = 1;
pub const lERROR: crate::squeezelite_h::log_level = 0;
pub const RECV_HEADERS: crate::squeezelite_h::stream_state = 7;
pub const SEND_HEADERS: crate::squeezelite_h::stream_state = 6;
pub const STREAMING_HTTP: crate::squeezelite_h::stream_state = 5;
pub const STREAMING_FILE: crate::squeezelite_h::stream_state = 4;
pub const STREAMING_BUFFERING: crate::squeezelite_h::stream_state = 3;
pub const STREAMING_WAIT: crate::squeezelite_h::stream_state = 2;
pub const DISCONNECT: crate::squeezelite_h::stream_state = 1;
pub const STOPPED: crate::squeezelite_h::stream_state = 0;
pub const TIMEOUT: crate::squeezelite_h::disconnect_code = 4;
pub const UNREACHABLE: crate::squeezelite_h::disconnect_code = 3;
pub const REMOTE_DISCONNECT: crate::squeezelite_h::disconnect_code = 2;
pub const LOCAL_DISCONNECT: crate::squeezelite_h::disconnect_code = 1;
pub const DISCONNECT_OK: crate::squeezelite_h::disconnect_code = 0;
pub const DECODE_ERROR: crate::squeezelite_h::decode_state = 4;
pub const DECODE_COMPLETE: crate::squeezelite_h::decode_state = 3;
pub const DECODE_RUNNING: crate::squeezelite_h::decode_state = 2;
pub const DECODE_READY: crate::squeezelite_h::decode_state = 1;
pub const DECODE_STOPPED: crate::squeezelite_h::decode_state = 0;
pub const FADE_INOUT: crate::squeezelite_h::fade_mode = 4;
pub const FADE_OUT: crate::squeezelite_h::fade_mode = 3;
pub const FADE_IN: crate::squeezelite_h::fade_mode = 2;
pub const FADE_CROSSFADE: crate::squeezelite_h::fade_mode = 1;
pub const FADE_NONE: crate::squeezelite_h::fade_mode = 0;
pub const FADE_CROSS: crate::squeezelite_h::fade_dir = 3;
pub const FADE_DOWN: crate::squeezelite_h::fade_dir = 2;
pub const FADE_UP: crate::squeezelite_h::fade_dir = 1;
pub const FADE_ACTIVE: crate::squeezelite_h::fade_state = 2;
pub const FADE_DUE: crate::squeezelite_h::fade_state = 1;
pub const FADE_INACTIVE: crate::squeezelite_h::fade_state = 0;
pub const S16_LE: crate::squeezelite_h::output_format = 3;
pub const S24_3LE: crate::squeezelite_h::output_format = 2;
pub const S24_LE: crate::squeezelite_h::output_format = 1;
pub const S32_LE: crate::squeezelite_h::output_format = 0;
pub const OUTPUT_START_AT: crate::squeezelite_h::output_state = 5;
pub const OUTPUT_SKIP_FRAMES: crate::squeezelite_h::output_state = 4;
pub const OUTPUT_PAUSE_FRAMES: crate::squeezelite_h::output_state = 3;
pub const OUTPUT_RUNNING: crate::squeezelite_h::output_state = 2;
pub const OUTPUT_BUFFER: crate::squeezelite_h::output_state = 1;
pub const OUTPUT_STOPPED: crate::squeezelite_h::output_state = 0;
pub const OUTPUT_OFF: crate::squeezelite_h::output_state = -1;
pub type u16_t = crate::stdlib::u_int16_t;
pub type sockfd = libc::c_int;
pub type event_type = libc::c_uint;
pub const EVENT_WAKE: crate::squeezelite_h::event_type = 2;
pub const EVENT_READ: crate::squeezelite_h::event_type = 1;
pub const EVENT_TIMEOUT: crate::squeezelite_h::event_type = 0;
pub type u8_t = crate::stdlib::u_int8_t;
#[repr(C)]
#[derive(Copy, Clone)]
pub struct buffer {
pub buf: *mut crate::squeezelite_h::u8_t,
pub readp: *mut crate::squeezelite_h::u8_t,
pub writep: *mut crate::squeezelite_h::u8_t,
pub wrap: *mut crate::squeezelite_h::u8_t,
pub size: crate::stddef_h::size_t,
pub base_size: crate::stddef_h::size_t,
pub mutex: crate::stdlib::pthread_mutex_t,
}

1
src/stdarg_h.rs
View File

@ -1 +0,0 @@
pub type va_list = crate::internal::__builtin_va_list;

1
src/stddef_h.rs
View File

@ -1 +0,0 @@
pub type size_t = libc::c_ulong;

2259
src/stdlib.rs
View File

File diff suppressed because it is too large Load Diff

1765
src/stream.rs
View File

File diff suppressed because it is too large Load Diff

1440
src/utils.rs
View File

File diff suppressed because it is too large Load Diff

1386
src/vorbis.rs
View File

File diff suppressed because it is too large Load Diff