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
Download Patch File Download Diff File Expand all files Collapse all files
Cargo.toml
+21 -6
View File
@@ -3,7 +3,7 @@ members = [
] ]
[package] [package]
name = "squeezers" name = "sqeezers"
authors = ["C2Rust"] authors = ["C2Rust"]
version = "0.0.0" version = "0.0.0"
publish = false publish = false
@@ -11,19 +11,34 @@ edition = "2018"
autobins = false autobins = false
[lib] [lib]
name = "squeezers" name = "sqeezers"
path = "lib.rs" path = "lib.rs"
crate-type = ["staticlib", "rlib"] crate-type = ["staticlib", "rlib"]
[[bin]]
path = "src/main.rs"
name = "main"
[dependencies] [dependencies]
c2rust-bitfields = "0.3" c2rust-bitfields = "0.3"
c2rust-asm-casts = "0.1" c2rust-asm-casts = "0.1"
libc = "0.2" 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 = "*"
lib.rs
+31 -29
View File
@@ -5,47 +5,49 @@
#![allow(non_upper_case_globals)] #![allow(non_upper_case_globals)]
#![allow(unused_assignments)] #![allow(unused_assignments)]
#![allow(unused_mut)] #![allow(unused_mut)]
#![cross_check(yes)]
#![feature(asm)] #![feature(asm)]
#![feature(c_variadic)] #![feature(c_variadic)]
#![feature(const_raw_ptr_to_usize_cast)] #![feature(const_raw_ptr_to_usize_cast)]
#![feature(extern_types)] #![feature(extern_types)]
#![feature(main)] #![feature(main)]
#![feature(plugin)]
#![feature(ptr_wrapping_offset_from)] #![feature(ptr_wrapping_offset_from)]
#![feature(register_tool)] #![feature(register_tool)]
#![register_tool(c2rust)] #![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] #[macro_use]
extern crate c2rust_bitfields;#[macro_use]
extern crate c2rust_asm_casts; extern crate c2rust_asm_casts;
extern crate libc; 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 src {
pub mod buffer; pub mod buffer;
pub mod decode; pub mod decode;
pub mod faad; pub mod faad;
pub mod flac; pub mod flac;
pub mod mad; pub mod mad;
pub mod mpg; pub mod main;
pub mod output; pub mod mpg;
pub mod output_alsa; pub mod output;
pub mod output_pa; pub mod output_alsa;
pub mod output_pack; pub mod output_pa;
pub mod output_pulse; pub mod output_pack;
pub mod output_stdout; pub mod output_pulse;
pub mod pcm; pub mod output_stdout;
pub mod slimproto; pub mod pcm;
pub mod stream; pub mod slimproto;
pub mod utils; pub mod stream;
pub mod vorbis; pub mod utils;
pub mod vorbis;
} // mod src } // mod src
src/buffer.rs
+142 -116
View File
@@ -1,30 +1,81 @@
use ::libc; use ::libc;
extern "C" {
pub use crate::stddef_h::size_t; #[no_mangle]
pub use crate::stdlib::__uint8_t; fn malloc(_: libc::c_ulong) -> *mut libc::c_void;
pub use crate::stdlib::u_int8_t; #[no_mangle]
fn free(__ptr: *mut libc::c_void);
pub use crate::squeezelite_h::buffer; #[no_mangle]
pub use crate::squeezelite_h::u8_t; fn pthread_mutex_init(__mutex: *mut pthread_mutex_t,
pub use crate::stdlib::__pthread_internal_list; __mutexattr: *const pthread_mutexattr_t)
pub use crate::stdlib::__pthread_list_t; -> libc::c_int;
pub use crate::stdlib::__pthread_mutex_s; #[no_mangle]
use crate::stdlib::free; fn pthread_mutex_destroy(__mutex: *mut pthread_mutex_t) -> libc::c_int;
use crate::stdlib::malloc; #[no_mangle]
pub use crate::stdlib::pthread_mutex_destroy; fn pthread_mutex_lock(__mutex: *mut pthread_mutex_t) -> libc::c_int;
pub use crate::stdlib::pthread_mutex_init; #[no_mangle]
pub use crate::stdlib::pthread_mutex_lock; fn pthread_mutex_unlock(__mutex: *mut pthread_mutex_t) -> libc::c_int;
pub use crate::stdlib::pthread_mutex_t; #[no_mangle]
pub use crate::stdlib::pthread_mutex_unlock; fn pthread_mutexattr_init(__attr: *mut pthread_mutexattr_t)
pub use crate::stdlib::pthread_mutexattr_destroy; -> libc::c_int;
pub use crate::stdlib::pthread_mutexattr_init; #[no_mangle]
pub use crate::stdlib::pthread_mutexattr_setprotocol; fn pthread_mutexattr_destroy(__attr: *mut pthread_mutexattr_t)
pub use crate::stdlib::pthread_mutexattr_t; -> libc::c_int;
pub use crate::stdlib::C2RustUnnamed_0; #[no_mangle]
pub use crate::stdlib::PTHREAD_PRIO_INHERIT; fn pthread_mutexattr_setprotocol(__attr: *mut pthread_mutexattr_t,
pub use crate::stdlib::PTHREAD_PRIO_NONE; __protocol: libc::c_int) -> libc::c_int;
pub use crate::stdlib::PTHREAD_PRIO_PROTECT; }
/* 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 * Squeezelite - lightweight headless squeezebox emulator
* *
* (c) Adrian Smith 2012-2015, triode1@btinternet.com * (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 * it under the terms of the GNU General Public License as published by
* the Free Software Foundation, either version 3 of the License, or * the Free Software Foundation, either version 3 of the License, or
* (at your option) any later version. * (at your option) any later version.
* *
* This program is distributed in the hope that it will be useful, * This program is distributed in the hope that it will be useful,
* but WITHOUT ANY WARRANTY; without even the implied warranty of * but WITHOUT ANY WARRANTY; without even the implied warranty of
* MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the * 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/>. * along with this program. If not, see <http://www.gnu.org/licenses/>.
* *
*/ */
// fifo bufffers // fifo bufffers
// _* called with muxtex locked // _* called with muxtex locked
#[inline] #[inline]
unsafe extern "C" fn _buf_used(mut buf: *mut buffer) -> libc::c_uint {
unsafe extern "C" fn _buf_used(mut buf: *mut crate::squeezelite_h::buffer) -> libc::c_uint {
return if (*buf).writep >= (*buf).readp { return if (*buf).writep >= (*buf).readp {
(*buf).writep.wrapping_offset_from((*buf).readp) as libc::c_long as libc::c_ulong (*buf).writep.wrapping_offset_from((*buf).readp) as
} else { libc::c_long as libc::c_ulong
(*buf).size.wrapping_sub( } else {
(*buf).readp.wrapping_offset_from((*buf).writep) as libc::c_long as libc::c_ulong, (*buf).size.wrapping_sub((*buf).readp.wrapping_offset_from((*buf).writep)
) as libc::c_long as libc::c_ulong)
} as libc::c_uint; } as libc::c_uint;
} }
#[no_mangle] #[no_mangle]
pub unsafe extern "C" fn _buf_space(mut buf: *mut buffer) -> libc::c_uint {
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
return (*buf) libc::c_ulong).wrapping_sub(1 as
.size libc::c_int
.wrapping_sub(_buf_used(buf) as libc::c_ulong) as
.wrapping_sub(1 as libc::c_int as libc::c_ulong) as libc::c_uint; libc::c_ulong)
as libc::c_uint;
// reduce by one as full same as empty otherwise // reduce by one as full same as empty otherwise
} }
#[no_mangle] #[no_mangle]
pub unsafe extern "C" fn _buf_cont_read(mut buf: *mut buffer)
pub unsafe extern "C" fn _buf_cont_read( -> libc::c_uint {
mut buf: *mut crate::squeezelite_h::buffer,
) -> libc::c_uint {
return if (*buf).writep >= (*buf).readp { return if (*buf).writep >= (*buf).readp {
(*buf).writep.wrapping_offset_from((*buf).readp) as libc::c_long (*buf).writep.wrapping_offset_from((*buf).readp) as
} else { libc::c_long
(*buf).wrap.wrapping_offset_from((*buf).readp) as libc::c_long } else {
} as libc::c_uint; (*buf).wrap.wrapping_offset_from((*buf).readp) as libc::c_long
} as libc::c_uint;
} }
#[no_mangle] #[no_mangle]
pub unsafe extern "C" fn _buf_cont_write(mut buf: *mut buffer)
pub unsafe extern "C" fn _buf_cont_write( -> libc::c_uint {
mut buf: *mut crate::squeezelite_h::buffer,
) -> libc::c_uint {
return if (*buf).writep >= (*buf).readp { return if (*buf).writep >= (*buf).readp {
(*buf).wrap.wrapping_offset_from((*buf).writep) as libc::c_long (*buf).wrap.wrapping_offset_from((*buf).writep) as libc::c_long
} else { } else {
(*buf).readp.wrapping_offset_from((*buf).writep) as libc::c_long (*buf).readp.wrapping_offset_from((*buf).writep) as
} as libc::c_uint; libc::c_long
} as libc::c_uint;
} }
#[no_mangle] #[no_mangle]
pub unsafe extern "C" fn _buf_inc_readp(mut buf: *mut buffer,
pub unsafe extern "C" fn _buf_inc_readp( mut by: libc::c_uint) {
mut buf: *mut crate::squeezelite_h::buffer,
mut by: libc::c_uint,
) {
(*buf).readp = (*buf).readp.offset(by as isize); (*buf).readp = (*buf).readp.offset(by as isize);
if (*buf).readp >= (*buf).wrap { if (*buf).readp >= (*buf).wrap {
(*buf).readp = (*buf).readp.offset(-((*buf).size as isize)) (*buf).readp = (*buf).readp.offset(-((*buf).size as isize))
}; };
} }
#[no_mangle] #[no_mangle]
pub unsafe extern "C" fn _buf_inc_writep(mut buf: *mut buffer,
pub unsafe extern "C" fn _buf_inc_writep( mut by: libc::c_uint) {
mut buf: *mut crate::squeezelite_h::buffer,
mut by: libc::c_uint,
) {
(*buf).writep = (*buf).writep.offset(by as isize); (*buf).writep = (*buf).writep.offset(by as isize);
if (*buf).writep >= (*buf).wrap { if (*buf).writep >= (*buf).wrap {
(*buf).writep = (*buf).writep.offset(-((*buf).size as isize)) (*buf).writep = (*buf).writep.offset(-((*buf).size as isize))
}; };
} }
#[no_mangle] #[no_mangle]
pub unsafe extern "C" fn buf_flush(mut buf: *mut buffer) {
pub unsafe extern "C" fn buf_flush(mut buf: *mut crate::squeezelite_h::buffer) { pthread_mutex_lock(&mut (*buf).mutex);
crate::stdlib::pthread_mutex_lock(&mut (*buf).mutex);
(*buf).readp = (*buf).buf; (*buf).readp = (*buf).buf;
(*buf).writep = (*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 // adjust buffer to multiple of mod bytes so reading in multiple always wraps on frame boundary
#[no_mangle] #[no_mangle]
pub unsafe extern "C" fn buf_adjust(mut buf: *mut buffer, mut mod_0: size_t) {
pub unsafe extern "C" fn buf_adjust( let mut size: size_t = 0;
mut buf: *mut crate::squeezelite_h::buffer, pthread_mutex_lock(&mut (*buf).mutex);
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);
size = 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).readp = (*buf).buf;
(*buf).writep = (*buf).buf; (*buf).writep = (*buf).buf;
(*buf).wrap = (*buf).buf.offset(size as isize); (*buf).wrap = (*buf).buf.offset(size as isize);
(*buf).size = size; (*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 // called with mutex locked to resize, does not retain contents, reverts to original size if fails
#[no_mangle] #[no_mangle]
pub unsafe extern "C" fn _buf_resize(mut buf: *mut buffer, mut size: size_t) {
pub unsafe extern "C" fn _buf_resize( free((*buf).buf as *mut libc::c_void);
mut buf: *mut crate::squeezelite_h::buffer, (*buf).buf = malloc(size) as *mut u8_t;
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;
if (*buf).buf.is_null() { if (*buf).buf.is_null() {
size = (*buf).size; size = (*buf).size;
(*buf).buf = crate::stdlib::malloc(size) as *mut crate::squeezelite_h::u8_t; (*buf).buf = malloc(size) as *mut u8_t;
if (*buf).buf.is_null() { if (*buf).buf.is_null() { size = 0 as libc::c_int as size_t }
size = 0 as libc::c_int as crate::stddef_h::size_t
}
} }
(*buf).readp = (*buf).buf; (*buf).readp = (*buf).buf;
(*buf).writep = (*buf).buf; (*buf).writep = (*buf).buf;
@@ -158,37 +191,31 @@ pub unsafe extern "C" fn _buf_resize(
(*buf).base_size = size; (*buf).base_size = size;
} }
#[no_mangle] #[no_mangle]
pub unsafe extern "C" fn buf_init(mut buf: *mut buffer, mut size: size_t) {
pub unsafe extern "C" fn buf_init( (*buf).buf = malloc(size) as *mut u8_t;
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;
(*buf).readp = (*buf).buf; (*buf).readp = (*buf).buf;
(*buf).writep = (*buf).buf; (*buf).writep = (*buf).buf;
(*buf).wrap = (*buf).buf.offset(size as isize); (*buf).wrap = (*buf).buf.offset(size as isize);
(*buf).size = size; (*buf).size = size;
(*buf).base_size = size; (*buf).base_size = size;
let mut attr = crate::stdlib::pthread_mutexattr_t { __size: [0; 4] }; let mut attr: pthread_mutexattr_t = pthread_mutexattr_t{__size: [0; 4],};
crate::stdlib::pthread_mutexattr_init(&mut attr); pthread_mutexattr_init(&mut attr);
crate::stdlib::pthread_mutexattr_setprotocol( pthread_mutexattr_setprotocol(&mut attr,
&mut attr, PTHREAD_PRIO_INHERIT as libc::c_int);
crate::stdlib::PTHREAD_PRIO_INHERIT as libc::c_int, pthread_mutex_init(&mut (*buf).mutex, &mut attr);
); pthread_mutexattr_destroy(&mut attr);
crate::stdlib::pthread_mutex_init(&mut (*buf).mutex, &mut attr);
crate::stdlib::pthread_mutexattr_destroy(&mut attr);
} }
/* /*
* Squeezelite - lightweight headless squeezebox emulator * Squeezelite - lightweight headless squeezebox emulator
* *
* (c) Adrian Smith 2012-2015, triode1@btinternet.com * (c) Adrian Smith 2012-2015, triode1@btinternet.com
* Ralph Irving 2015-2017, ralph_irving@hotmail.com * Ralph Irving 2015-2017, ralph_irving@hotmail.com
* *
* This program is free software: you can redistribute it and/or modify * 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 * it under the terms of the GNU General Public License as published by
* the Free Software Foundation, either version 3 of the License, or * the Free Software Foundation, either version 3 of the License, or
* (at your option) any later version. * (at your option) any later version.
* *
* This program is distributed in the hope that it will be useful, * This program is distributed in the hope that it will be useful,
* but WITHOUT ANY WARRANTY; without even the implied warranty of * but WITHOUT ANY WARRANTY; without even the implied warranty of
* MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
@@ -215,13 +242,12 @@ pub unsafe extern "C" fn buf_init(
// buffer.c // buffer.c
// _* called with mutex locked // _* called with mutex locked
#[no_mangle] #[no_mangle]
pub unsafe extern "C" fn buf_destroy(mut buf: *mut buffer) {
pub unsafe extern "C" fn buf_destroy(mut buf: *mut crate::squeezelite_h::buffer) {
if !(*buf).buf.is_null() { if !(*buf).buf.is_null() {
crate::stdlib::free((*buf).buf as *mut libc::c_void); free((*buf).buf as *mut libc::c_void);
(*buf).buf = 0 as *mut crate::squeezelite_h::u8_t; (*buf).buf = 0 as *mut u8_t;
(*buf).size = 0 as libc::c_int as crate::stddef_h::size_t; (*buf).size = 0 as libc::c_int as size_t;
(*buf).base_size = 0 as libc::c_int as crate::stddef_h::size_t; (*buf).base_size = 0 as libc::c_int as size_t;
crate::stdlib::pthread_mutex_destroy(&mut (*buf).mutex); pthread_mutex_destroy(&mut (*buf).mutex);
}; };
} }
src/decode.rs
+578 -518
View File
File diff suppressed because it is too large Load Diff
src/faad.rs
+1121 -1191
View File
File diff suppressed because it is too large Load Diff
src/flac.rs
+1165 -737
View File
File diff suppressed because it is too large Load Diff
src/internal.rs
-9
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,
}
src/mad.rs
+902 -786
View File
File diff suppressed because it is too large Load Diff
src/main.rs
+531 -754
View File
File diff suppressed because it is too large Load Diff
src/mpg.rs
+702 -601
View File
File diff suppressed because it is too large Load Diff
src/output.rs
+854 -876
View File
File diff suppressed because it is too large Load Diff
src/output_alsa.rs
+1842 -1953
View File
File diff suppressed because it is too large Load Diff
src/output_pa.rs
+2 -2
View File
@@ -1,7 +1,7 @@
use ::libc; use ::libc;
// PORTAUDIO // PORTAUDIO
// Portaudio output // Portaudio output
/* /*
* Squeezelite - lightweight headless squeezebox emulator * Squeezelite - lightweight headless squeezebox emulator
* *
* (c) Adrian Smith 2012-2015, triode1@btinternet.com * (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 * it under the terms of the GNU General Public License as published by
* the Free Software Foundation, either version 3 of the License, or * the Free Software Foundation, either version 3 of the License, or
* (at your option) any later version. * (at your option) any later version.
* *
* This program is distributed in the hope that it will be useful, * This program is distributed in the hope that it will be useful,
* but WITHOUT ANY WARRANTY; without even the implied warranty of * but WITHOUT ANY WARRANTY; without even the implied warranty of
* MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
src/output_pack.rs
+199 -173
View File
@@ -1,324 +1,350 @@
use ::libc; use ::libc;
extern "C" {
pub use crate::squeezelite_h::frames_t; #[no_mangle]
pub use crate::squeezelite_h::output_format; fn memcpy(_: *mut libc::c_void, _: *const libc::c_void, _: libc::c_ulong)
pub use crate::squeezelite_h::s32_t; -> *mut libc::c_void;
pub use crate::squeezelite_h::s64_t; }
pub use crate::squeezelite_h::u32_t; pub type __uint8_t = libc::c_uchar;
pub use crate::squeezelite_h::u8_t; pub type __int32_t = libc::c_int;
pub use crate::squeezelite_h::S16_LE; pub type __uint32_t = libc::c_uint;
pub use crate::squeezelite_h::S24_3LE; pub type __int64_t = libc::c_long;
pub use crate::squeezelite_h::S24_LE; pub type int32_t = __int32_t;
pub use crate::squeezelite_h::S32_LE; pub type int64_t = __int64_t;
pub use crate::stdlib::__int32_t; pub type u_int8_t = __uint8_t;
pub use crate::stdlib::__int64_t; pub type u_int32_t = __uint32_t;
pub use crate::stdlib::__uint32_t; pub type u8_t = u_int8_t;
pub use crate::stdlib::__uint8_t; pub type u32_t = u_int32_t;
pub use crate::stdlib::int32_t; pub type s32_t = int32_t;
pub use crate::stdlib::int64_t; pub type s64_t = int64_t;
use crate::stdlib::memcpy; pub type frames_t = u32_t;
pub use crate::stdlib::u_int32_t; pub type uintptr_t = libc::c_ulong;
pub use crate::stdlib::u_int8_t; pub type output_format = libc::c_uint;
pub use crate::stdlib::uintptr_t; 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... // inlining these on windows prevents them being linkable...
#[inline] #[inline]
unsafe extern "C" fn gain(mut gain_0: s32_t, mut sample: s32_t) -> s32_t {
unsafe extern "C" fn gain( let mut res: s64_t = gain_0 as s64_t * sample as s64_t;
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;
if res as libc::c_longlong > 0x7fffffffffff as libc::c_longlong { 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) { 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] #[no_mangle]
pub unsafe extern "C" fn _scale_and_pack_frames(mut outputptr:
pub unsafe extern "C" fn _scale_and_pack_frames( *mut libc::c_void,
mut outputptr: *mut libc::c_void, mut inputptr: *mut s32_t,
mut inputptr: *mut crate::squeezelite_h::s32_t, mut cnt: frames_t,
mut cnt: crate::squeezelite_h::frames_t, mut gainL: s32_t,
mut gainL: crate::squeezelite_h::s32_t, mut gainR: s32_t,
mut gainR: crate::squeezelite_h::s32_t, mut format: output_format) {
mut format: crate::squeezelite_h::output_format,
) {
match format as libc::c_uint { match format as libc::c_uint {
3 => { 3 => {
let mut optr = outputptr as *mut crate::squeezelite_h::u32_t; let mut optr: *mut u32_t = outputptr as *mut u32_t;
if gainL == 0x10000 as libc::c_int && gainR == 0x10000 as libc::c_int { if gainL == 0x10000 as libc::c_int &&
loop { gainR == 0x10000 as libc::c_int {
loop {
let fresh0 = cnt; let fresh0 = cnt;
cnt = cnt.wrapping_sub(1); cnt = cnt.wrapping_sub(1);
if !(fresh0 != 0) { if !(fresh0 != 0) { break ; }
break;
}
let fresh1 = optr; let fresh1 = optr;
optr = optr.offset(1); optr = optr.offset(1);
*fresh1 = (*inputptr >> 16 as libc::c_int & 0xffff as libc::c_int) *fresh1 =
as libc::c_uint (*inputptr >> 16 as libc::c_int &
| *inputptr.offset(1 as libc::c_int as isize) as libc::c_uint 0xffff as libc::c_int) as libc::c_uint |
& 0xffff0000 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) inputptr = inputptr.offset(2 as libc::c_int as isize)
} }
} else { } else {
loop { loop {
let fresh2 = cnt; let fresh2 = cnt;
cnt = cnt.wrapping_sub(1); cnt = cnt.wrapping_sub(1);
if !(fresh2 != 0) { if !(fresh2 != 0) { break ; }
break;
}
let fresh3 = optr; let fresh3 = optr;
optr = optr.offset(1); optr = optr.offset(1);
*fresh3 = (gain(gainL, *inputptr) >> 16 as libc::c_int & 0xffff as libc::c_int) *fresh3 =
as libc::c_uint (gain(gainL, *inputptr) >> 16 as libc::c_int &
| gain(gainR, *inputptr.offset(1 as libc::c_int as isize)) as libc::c_uint 0xffff as libc::c_int) as libc::c_uint |
& 0xffff0000 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) inputptr = inputptr.offset(2 as libc::c_int as isize)
} }
} }
} }
1 => { 1 => {
let mut optr_0 = outputptr as *mut crate::squeezelite_h::u32_t; 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 { if gainL == 0x10000 as libc::c_int &&
loop { gainR == 0x10000 as libc::c_int {
loop {
let fresh4 = cnt; let fresh4 = cnt;
cnt = cnt.wrapping_sub(1); cnt = cnt.wrapping_sub(1);
if !(fresh4 != 0) { if !(fresh4 != 0) { break ; }
break;
}
let fresh5 = inputptr; let fresh5 = inputptr;
inputptr = inputptr.offset(1); inputptr = inputptr.offset(1);
let fresh6 = optr_0; let fresh6 = optr_0;
optr_0 = optr_0.offset(1); 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; let fresh7 = inputptr;
inputptr = inputptr.offset(1); inputptr = inputptr.offset(1);
let fresh8 = optr_0; let fresh8 = optr_0;
optr_0 = optr_0.offset(1); 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 { } else {
loop { loop {
let fresh9 = cnt; let fresh9 = cnt;
cnt = cnt.wrapping_sub(1); cnt = cnt.wrapping_sub(1);
if !(fresh9 != 0) { if !(fresh9 != 0) { break ; }
break;
}
let fresh10 = inputptr; let fresh10 = inputptr;
inputptr = inputptr.offset(1); inputptr = inputptr.offset(1);
let fresh11 = optr_0; let fresh11 = optr_0;
optr_0 = optr_0.offset(1); optr_0 = optr_0.offset(1);
*fresh11 = *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; let fresh12 = inputptr;
inputptr = inputptr.offset(1); inputptr = inputptr.offset(1);
let fresh13 = optr_0; let fresh13 = optr_0;
optr_0 = optr_0.offset(1); optr_0 = optr_0.offset(1);
*fresh13 = *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 => { 2 => {
let mut optr_1 = outputptr as *mut crate::squeezelite_h::u8_t; 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 { if gainL == 0x10000 as libc::c_int &&
gainR == 0x10000 as libc::c_int {
while cnt != 0 { while cnt != 0 {
// attempt to do 32 bit memory accesses - move 2 frames at once: 16 bytes -> 12 bytes // 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 // 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 if optr_1 as uintptr_t &
== 0 as libc::c_int as libc::c_ulong 0x3 as libc::c_int as libc::c_ulong ==
&& cnt >= 2 as libc::c_int as libc::c_uint 0 as libc::c_int as libc::c_ulong &&
{ cnt >= 2 as libc::c_int as libc::c_uint {
let mut o_ptr = let mut o_ptr: *mut u32_t =
optr_1 as *mut libc::c_void as *mut crate::squeezelite_h::u32_t; optr_1 as *mut libc::c_void as *mut u32_t;
while cnt >= 2 as libc::c_int as libc::c_uint { while cnt >= 2 as libc::c_int as libc::c_uint {
let fresh14 = inputptr; let fresh14 = inputptr;
inputptr = inputptr.offset(1); inputptr = inputptr.offset(1);
let mut l1 = *fresh14; let mut l1: s32_t = *fresh14;
let fresh15 = inputptr; let fresh15 = inputptr;
inputptr = inputptr.offset(1); inputptr = inputptr.offset(1);
let mut r1 = *fresh15; let mut r1: s32_t = *fresh15;
let fresh16 = inputptr; let fresh16 = inputptr;
inputptr = inputptr.offset(1); inputptr = inputptr.offset(1);
let mut l2 = *fresh16; let mut l2: s32_t = *fresh16;
let fresh17 = inputptr; let fresh17 = inputptr;
inputptr = inputptr.offset(1); inputptr = inputptr.offset(1);
let mut r2 = *fresh17; let mut r2: s32_t = *fresh17;
let fresh18 = o_ptr; let fresh18 = o_ptr;
o_ptr = o_ptr.offset(1); o_ptr = o_ptr.offset(1);
*fresh18 = (l1 as libc::c_uint & 0xffffff00 as libc::c_uint) *fresh18 =
>> 8 as libc::c_int (l1 as libc::c_uint &
| ((r1 & 0xff00 as libc::c_int) << 16 as libc::c_int) 0xffffff00 as libc::c_uint) >>
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; let fresh19 = o_ptr;
o_ptr = o_ptr.offset(1); o_ptr = o_ptr.offset(1);
*fresh19 = (r1 as libc::c_uint & 0xffff0000 as libc::c_uint) *fresh19 =
>> 16 as libc::c_int (r1 as libc::c_uint &
| ((l2 & 0xffff00 as libc::c_int) << 8 as libc::c_int) 0xffff0000 as libc::c_uint) >>
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; let fresh20 = o_ptr;
o_ptr = o_ptr.offset(1); o_ptr = o_ptr.offset(1);
*fresh20 = (l2 as libc::c_uint & 0xff000000 as libc::c_uint) *fresh20 =
>> 24 as libc::c_int (l2 as libc::c_uint &
| r2 as libc::c_uint & 0xffffff00 as libc::c_uint; 0xff000000 as libc::c_uint) >>
optr_1 = optr_1.offset(12 as libc::c_int as isize); 24 as libc::c_int |
cnt = (cnt as libc::c_uint) r2 as libc::c_uint &
.wrapping_sub(2 as libc::c_int as libc::c_uint) 0xffffff00 as libc::c_uint;
as crate::squeezelite_h::frames_t optr_1 =
as crate::squeezelite_h::frames_t 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 { } else {
let fresh21 = inputptr; let fresh21 = inputptr;
inputptr = inputptr.offset(1); inputptr = inputptr.offset(1);
let mut lsample = *fresh21; let mut lsample: s32_t = *fresh21;
let fresh22 = inputptr; let fresh22 = inputptr;
inputptr = inputptr.offset(1); inputptr = inputptr.offset(1);
let mut rsample = *fresh22; let mut rsample: s32_t = *fresh22;
let fresh23 = optr_1; let fresh23 = optr_1;
optr_1 = optr_1.offset(1); optr_1 = optr_1.offset(1);
*fresh23 = ((lsample & 0xff00 as libc::c_int) >> 8 as libc::c_int) *fresh23 =
as crate::squeezelite_h::u8_t; ((lsample & 0xff00 as libc::c_int) >>
8 as libc::c_int) as u8_t;
let fresh24 = optr_1; let fresh24 = optr_1;
optr_1 = optr_1.offset(1); optr_1 = optr_1.offset(1);
*fresh24 = ((lsample & 0xff0000 as libc::c_int) >> 16 as libc::c_int) *fresh24 =
as crate::squeezelite_h::u8_t; ((lsample & 0xff0000 as libc::c_int) >>
16 as libc::c_int) as u8_t;
let fresh25 = optr_1; let fresh25 = optr_1;
optr_1 = optr_1.offset(1); optr_1 = optr_1.offset(1);
*fresh25 = ((lsample as libc::c_uint & 0xff000000 as libc::c_uint) *fresh25 =
>> 24 as libc::c_int) ((lsample as libc::c_uint &
as crate::squeezelite_h::u8_t; 0xff000000 as libc::c_uint) >>
24 as libc::c_int) as u8_t;
let fresh26 = optr_1; let fresh26 = optr_1;
optr_1 = optr_1.offset(1); optr_1 = optr_1.offset(1);
*fresh26 = ((rsample & 0xff00 as libc::c_int) >> 8 as libc::c_int) *fresh26 =
as crate::squeezelite_h::u8_t; ((rsample & 0xff00 as libc::c_int) >>
8 as libc::c_int) as u8_t;
let fresh27 = optr_1; let fresh27 = optr_1;
optr_1 = optr_1.offset(1); optr_1 = optr_1.offset(1);
*fresh27 = ((rsample & 0xff0000 as libc::c_int) >> 16 as libc::c_int) *fresh27 =
as crate::squeezelite_h::u8_t; ((rsample & 0xff0000 as libc::c_int) >>
16 as libc::c_int) as u8_t;
let fresh28 = optr_1; let fresh28 = optr_1;
optr_1 = optr_1.offset(1); optr_1 = optr_1.offset(1);
*fresh28 = ((rsample as libc::c_uint & 0xff000000 as libc::c_uint) *fresh28 =
>> 24 as libc::c_int) ((rsample as libc::c_uint &
as crate::squeezelite_h::u8_t; 0xff000000 as libc::c_uint) >>
24 as libc::c_int) as u8_t;
cnt = cnt.wrapping_sub(1) cnt = cnt.wrapping_sub(1)
} }
} }
} else { } else {
while cnt != 0 { while cnt != 0 {
// attempt to do 32 bit memory accesses - move 2 frames at once: 16 bytes -> 12 bytes // 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 // 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 if optr_1 as uintptr_t &
== 0 as libc::c_int as libc::c_ulong 0x3 as libc::c_int as libc::c_ulong ==
&& cnt >= 2 as libc::c_int as libc::c_uint 0 as libc::c_int as libc::c_ulong &&
{ cnt >= 2 as libc::c_int as libc::c_uint {
let mut o_ptr_0 = let mut o_ptr_0: *mut u32_t =
optr_1 as *mut libc::c_void as *mut crate::squeezelite_h::u32_t; optr_1 as *mut libc::c_void as *mut u32_t;
while cnt >= 2 as libc::c_int as libc::c_uint { while cnt >= 2 as libc::c_int as libc::c_uint {
let fresh29 = inputptr; let fresh29 = inputptr;
inputptr = inputptr.offset(1); inputptr = inputptr.offset(1);
let mut l1_0 = gain(gainL, *fresh29); let mut l1_0: s32_t = gain(gainL, *fresh29);
let fresh30 = inputptr; let fresh30 = inputptr;
inputptr = inputptr.offset(1); inputptr = inputptr.offset(1);
let mut r1_0 = gain(gainR, *fresh30); let mut r1_0: s32_t = gain(gainR, *fresh30);
let fresh31 = inputptr; let fresh31 = inputptr;
inputptr = inputptr.offset(1); inputptr = inputptr.offset(1);
let mut l2_0 = gain(gainL, *fresh31); let mut l2_0: s32_t = gain(gainL, *fresh31);
let fresh32 = inputptr; let fresh32 = inputptr;
inputptr = inputptr.offset(1); 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; let fresh33 = o_ptr_0;
o_ptr_0 = o_ptr_0.offset(1); o_ptr_0 = o_ptr_0.offset(1);
*fresh33 = (l1_0 as libc::c_uint & 0xffffff00 as libc::c_uint) *fresh33 =
>> 8 as libc::c_int (l1_0 as libc::c_uint &
| ((r1_0 & 0xff00 as libc::c_int) << 16 as libc::c_int) 0xffffff00 as libc::c_uint) >>
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; let fresh34 = o_ptr_0;
o_ptr_0 = o_ptr_0.offset(1); o_ptr_0 = o_ptr_0.offset(1);
*fresh34 = (r1_0 as libc::c_uint & 0xffff0000 as libc::c_uint) *fresh34 =
>> 16 as libc::c_int (r1_0 as libc::c_uint &
| ((l2_0 & 0xffff00 as libc::c_int) << 8 as libc::c_int) 0xffff0000 as libc::c_uint) >>
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; let fresh35 = o_ptr_0;
o_ptr_0 = o_ptr_0.offset(1); o_ptr_0 = o_ptr_0.offset(1);
*fresh35 = (l2_0 as libc::c_uint & 0xff000000 as libc::c_uint) *fresh35 =
>> 24 as libc::c_int (l2_0 as libc::c_uint &
| r2_0 as libc::c_uint & 0xffffff00 as libc::c_uint; 0xff000000 as libc::c_uint) >>
optr_1 = optr_1.offset(12 as libc::c_int as isize); 24 as libc::c_int |
cnt = (cnt as libc::c_uint) r2_0 as libc::c_uint &
.wrapping_sub(2 as libc::c_int as libc::c_uint) 0xffffff00 as libc::c_uint;
as crate::squeezelite_h::frames_t optr_1 =
as crate::squeezelite_h::frames_t 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 { } else {
let fresh36 = inputptr; let fresh36 = inputptr;
inputptr = inputptr.offset(1); inputptr = inputptr.offset(1);
let mut lsample_0 = gain(gainL, *fresh36); let mut lsample_0: s32_t = gain(gainL, *fresh36);
let fresh37 = inputptr; let fresh37 = inputptr;
inputptr = inputptr.offset(1); inputptr = inputptr.offset(1);
let mut rsample_0 = gain(gainR, *fresh37); let mut rsample_0: s32_t = gain(gainR, *fresh37);
let fresh38 = optr_1; let fresh38 = optr_1;
optr_1 = optr_1.offset(1); optr_1 = optr_1.offset(1);
*fresh38 = ((lsample_0 & 0xff00 as libc::c_int) >> 8 as libc::c_int) *fresh38 =
as crate::squeezelite_h::u8_t; ((lsample_0 & 0xff00 as libc::c_int) >>
8 as libc::c_int) as u8_t;
let fresh39 = optr_1; let fresh39 = optr_1;
optr_1 = optr_1.offset(1); optr_1 = optr_1.offset(1);
*fresh39 = ((lsample_0 & 0xff0000 as libc::c_int) >> 16 as libc::c_int) *fresh39 =
as crate::squeezelite_h::u8_t; ((lsample_0 & 0xff0000 as libc::c_int) >>
16 as libc::c_int) as u8_t;
let fresh40 = optr_1; let fresh40 = optr_1;
optr_1 = optr_1.offset(1); optr_1 = optr_1.offset(1);
*fresh40 = ((lsample_0 as libc::c_uint & 0xff000000 as libc::c_uint) *fresh40 =
>> 24 as libc::c_int) ((lsample_0 as libc::c_uint &
as crate::squeezelite_h::u8_t; 0xff000000 as libc::c_uint) >>
24 as libc::c_int) as u8_t;
let fresh41 = optr_1; let fresh41 = optr_1;
optr_1 = optr_1.offset(1); optr_1 = optr_1.offset(1);
*fresh41 = ((rsample_0 & 0xff00 as libc::c_int) >> 8 as libc::c_int) *fresh41 =
as crate::squeezelite_h::u8_t; ((rsample_0 & 0xff00 as libc::c_int) >>
8 as libc::c_int) as u8_t;
let fresh42 = optr_1; let fresh42 = optr_1;
optr_1 = optr_1.offset(1); optr_1 = optr_1.offset(1);
*fresh42 = ((rsample_0 & 0xff0000 as libc::c_int) >> 16 as libc::c_int) *fresh42 =
as crate::squeezelite_h::u8_t; ((rsample_0 & 0xff0000 as libc::c_int) >>
16 as libc::c_int) as u8_t;
let fresh43 = optr_1; let fresh43 = optr_1;
optr_1 = optr_1.offset(1); optr_1 = optr_1.offset(1);
*fresh43 = ((rsample_0 as libc::c_uint & 0xff000000 as libc::c_uint) *fresh43 =
>> 24 as libc::c_int) ((rsample_0 as libc::c_uint &
as crate::squeezelite_h::u8_t; 0xff000000 as libc::c_uint) >>
24 as libc::c_int) as u8_t;
cnt = cnt.wrapping_sub(1) cnt = cnt.wrapping_sub(1)
} }
} }
} }
} }
0 => { 0 => {
let mut optr_2 = outputptr as *mut crate::squeezelite_h::u32_t; 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 { if gainL == 0x10000 as libc::c_int &&
crate::stdlib::memcpy( gainR == 0x10000 as libc::c_int {
outputptr, memcpy(outputptr, inputptr as *const libc::c_void,
inputptr as *const libc::c_void, cnt.wrapping_mul(8 as libc::c_int as libc::c_uint) as
cnt.wrapping_mul(8 as libc::c_int as libc::c_uint) as libc::c_ulong, libc::c_ulong);
);
} else { } else {
loop { loop {
let fresh44 = cnt; let fresh44 = cnt;
cnt = cnt.wrapping_sub(1); cnt = cnt.wrapping_sub(1);
if !(fresh44 != 0) { if !(fresh44 != 0) { break ; }
break;
}
let fresh45 = inputptr; let fresh45 = inputptr;
inputptr = inputptr.offset(1); inputptr = inputptr.offset(1);
let fresh46 = optr_2; let fresh46 = optr_2;
optr_2 = optr_2.offset(1); 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; let fresh47 = inputptr;
inputptr = inputptr.offset(1); inputptr = inputptr.offset(1);
let fresh48 = optr_2; let fresh48 = optr_2;
optr_2 = optr_2.offset(1); optr_2 = optr_2.offset(1);
*fresh48 = gain(gainR, *fresh47) as crate::squeezelite_h::u32_t *fresh48 = gain(gainR, *fresh47) as u32_t
} }
} }
} }
_ => {} _ => { }
}; };
} }
src/output_pulse.rs
+2 -2
View File
@@ -1,6 +1,6 @@
use ::libc; use ::libc;
// Output using PulseAudio // Output using PulseAudio
/* /*
* Squeezelite - lightweight headless squeezebox emulator * Squeezelite - lightweight headless squeezebox emulator
* *
* (c) Adrian Smith 2012-2015, triode1@btinternet.com * (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 * it under the terms of the GNU General Public License as published by
* the Free Software Foundation, either version 3 of the License, or * the Free Software Foundation, either version 3 of the License, or
* (at your option) any later version. * (at your option) any later version.
* *
* This program is distributed in the hope that it will be useful, * This program is distributed in the hope that it will be useful,
* but WITHOUT ANY WARRANTY; without even the implied warranty of * but WITHOUT ANY WARRANTY; without even the implied warranty of
* MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
src/output_stdout.rs
+351 -244
View File
@@ -1,286 +1,396 @@
use ::libc; 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" { extern "C" {
pub type _IO_wide_data;
pub type _IO_codecvt;
pub type _IO_marker;
#[no_mangle] #[no_mangle]
pub static mut output: crate::squeezelite_h::outputstate; static mut stdout: *mut FILE;
#[no_mangle] #[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] #[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;
} }
pub type size_t = libc::c_ulong;
static mut loglevel: crate::squeezelite_h::log_level = crate::squeezelite_h::lERROR; 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; 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 // buffer to hold output data so we can block on writing outside of output lock, allocated on init
static mut buf: *mut u8_t = 0 as *const u8_t as *mut u8_t;
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 buffill: libc::c_uint = 0; static mut buffill: libc::c_uint = 0;
static mut bytes_per_frame: libc::c_int = 0; static mut bytes_per_frame: libc::c_int = 0;
unsafe extern "C" fn _stdout_write_frames(mut out_frames: frames_t,
unsafe extern "C" fn _stdout_write_frames( mut silence: bool, mut gainL: s32_t,
mut out_frames: crate::squeezelite_h::frames_t, mut gainR: s32_t,
mut silence: bool, mut cross_gain_in: s32_t,
mut gainL: crate::squeezelite_h::s32_t, mut cross_gain_out: s32_t,
mut gainR: crate::squeezelite_h::s32_t, mut cross_ptr: *mut *mut s32_t)
mut cross_gain_in: crate::squeezelite_h::s32_t, -> libc::c_int {
mut cross_gain_out: crate::squeezelite_h::s32_t, let mut obuf: *mut u8_t = 0 as *mut u8_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;
if !silence { if !silence {
if output.fade as libc::c_uint if output.fade as libc::c_uint ==
== crate::squeezelite_h::FADE_ACTIVE as libc::c_int as libc::c_uint FADE_ACTIVE as libc::c_int as libc::c_uint &&
&& output.fade_dir as libc::c_uint output.fade_dir as libc::c_uint ==
== crate::squeezelite_h::FADE_CROSS as libc::c_int as libc::c_uint FADE_CROSS as libc::c_int as libc::c_uint &&
&& !(*cross_ptr).is_null() !(*cross_ptr).is_null() {
{ _apply_cross(outputbuf, out_frames, cross_gain_in, cross_gain_out,
crate::squeezelite_h::_apply_cross( cross_ptr);
outputbuf,
out_frames,
cross_gain_in,
cross_gain_out,
cross_ptr,
);
} }
obuf = (*outputbuf).readp obuf = (*outputbuf).readp
} else { } else { obuf = silencebuf }
obuf = silencebuf _scale_and_pack_frames(buf.offset(buffill.wrapping_mul(bytes_per_frame as
} libc::c_uint)
crate::src::output_pack::_scale_and_pack_frames( as isize) as *mut libc::c_void,
buf.offset(buffill.wrapping_mul(bytes_per_frame as libc::c_uint) as isize) obuf as *mut libc::c_void as *mut s32_t,
as *mut libc::c_void, out_frames, gainL, gainR, output.format);
obuf as *mut libc::c_void as *mut crate::squeezelite_h::s32_t,
out_frames,
gainL,
gainR,
output.format,
);
buffill = buffill.wrapping_add(out_frames); buffill = buffill.wrapping_add(out_frames);
return out_frames as libc::c_int; return out_frames as libc::c_int;
} }
unsafe extern "C" fn output_thread() -> *mut libc::c_void { 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 { match output.format as libc::c_uint {
0 => 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, 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, 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, _ => { 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 { 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.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; output.frames_played_dmp = output.frames_played;
crate::src::output::_output_frames(2048 as libc::c_int as crate::squeezelite_h::frames_t); _output_frames(2048 as libc::c_int as frames_t);
crate::stdlib::pthread_mutex_unlock(&mut (*outputbuf).mutex); pthread_mutex_unlock(&mut (*outputbuf).mutex);
if buffill != 0 { if buffill != 0 {
crate::stdlib::fwrite( fwrite(buf as *const libc::c_void,
buf as *const libc::c_void, bytes_per_frame as libc::c_ulong, buffill as libc::c_ulong,
bytes_per_frame as libc::c_ulong, stdout);
buffill as libc::c_ulong,
crate::stdlib::stdout,
);
buffill = 0 as libc::c_int as libc::c_uint buffill = 0 as libc::c_int as libc::c_uint
} }
} }
return 0 as *mut libc::c_void; return 0 as *mut libc::c_void;
} }
static mut thread: pthread_t = 0;
static mut thread: crate::stdlib::pthread_t = 0;
#[no_mangle] #[no_mangle]
pub unsafe extern "C" fn output_init_stdout(mut level: log_level,
pub unsafe extern "C" fn output_init_stdout( mut output_buf_size: libc::c_uint,
mut level: crate::squeezelite_h::log_level, mut params: *mut libc::c_char,
mut output_buf_size: libc::c_uint, mut rates: *mut libc::c_uint,
mut params: *mut libc::c_char, mut rate_delay: libc::c_uint) {
mut rates: *mut libc::c_uint,
mut rate_delay: libc::c_uint,
) {
loglevel = level; loglevel = level;
if loglevel as libc::c_uint >= crate::squeezelite_h::lINFO as libc::c_int as libc::c_uint { if loglevel as libc::c_uint >= lINFO as libc::c_int as libc::c_uint {
crate::src::utils::logprint( logprint(b"%s %s:%d init output stdout\n\x00" as *const u8 as
b"%s %s:%d init output stdout\n\x00" as *const u8 as *const libc::c_char, *const libc::c_char, logtime(),
crate::src::utils::logtime(), (*::std::mem::transmute::<&[u8; 19],
(*::std::mem::transmute::<&[u8; 19], &[libc::c_char; 19]>(b"output_init_stdout\x00")) &[libc::c_char; 19]>(b"output_init_stdout\x00")).as_ptr(),
.as_ptr(), 130 as libc::c_int);
130 as libc::c_int,
);
} }
buf = crate::stdlib::malloc((2048 as libc::c_int * 8 as libc::c_int) as libc::c_ulong) buf =
as *mut crate::squeezelite_h::u8_t; malloc((2048 as libc::c_int * 8 as libc::c_int) as libc::c_ulong) as
*mut u8_t;
if buf.is_null() { if buf.is_null() {
crate::src::utils::logprint( logprint(b"%s %s:%d unable to malloc buf\n\x00" as *const u8 as
b"%s %s:%d unable to malloc buf\n\x00" as *const u8 as *const libc::c_char, *const libc::c_char, logtime(),
crate::src::utils::logtime(), (*::std::mem::transmute::<&[u8; 19],
(*::std::mem::transmute::<&[u8; 19], &[libc::c_char; 19]>(b"output_init_stdout\x00")) &[libc::c_char; 19]>(b"output_init_stdout\x00")).as_ptr(),
.as_ptr(), 134 as libc::c_int);
134 as libc::c_int, return
);
return;
} }
buffill = 0 as libc::c_int as libc::c_uint; buffill = 0 as libc::c_int as libc::c_uint;
crate::stdlib::memset( memset(&mut output as *mut outputstate as *mut libc::c_void,
&mut output as *mut crate::squeezelite_h::outputstate as *mut libc::c_void, 0 as libc::c_int,
0 as libc::c_int, ::std::mem::size_of::<outputstate>() as libc::c_ulong);
::std::mem::size_of::<crate::squeezelite_h::outputstate>() as libc::c_ulong, output.format = S32_LE;
); output.start_frames =
output.format = crate::squeezelite_h::S32_LE; (2048 as libc::c_int * 2 as libc::c_int) as libc::c_uint;
output.start_frames = (2048 as libc::c_int * 2 as libc::c_int) as libc::c_uint; output.write_cb =
output.write_cb = Some( Some(_stdout_write_frames as
_stdout_write_frames unsafe extern "C" fn(_: frames_t, _: bool, _: s32_t,
as unsafe extern "C" fn( _: s32_t, _: s32_t, _: s32_t,
_: crate::squeezelite_h::frames_t, _: *mut *mut s32_t) -> libc::c_int);
_: 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,
);
output.rate_delay = rate_delay; output.rate_delay = rate_delay;
if !params.is_null() { if !params.is_null() {
if crate::stdlib::strcmp(params, b"32\x00" as *const u8 as *const libc::c_char) == 0 { if strcmp(params, b"32\x00" as *const u8 as *const libc::c_char) == 0
output.format = crate::squeezelite_h::S32_LE {
output.format = S32_LE
} }
if crate::stdlib::strcmp(params, b"24\x00" as *const u8 as *const libc::c_char) == 0 { if strcmp(params, b"24\x00" as *const u8 as *const libc::c_char) == 0
output.format = crate::squeezelite_h::S24_3LE {
output.format = S24_3LE
} }
if crate::stdlib::strcmp(params, b"16\x00" as *const u8 as *const libc::c_char) == 0 { if strcmp(params, b"16\x00" as *const u8 as *const libc::c_char) == 0
output.format = crate::squeezelite_h::S16_LE {
output.format = S16_LE
} }
} }
// ensure output rate is specified to avoid test open // ensure output rate is specified to avoid test open
if *rates.offset(0 as libc::c_int as isize) == 0 { 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( output_init_common(level, b"-\x00" as *const u8 as *const libc::c_char,
level, output_buf_size, rates,
b"-\x00" as *const u8 as *const libc::c_char, 0 as libc::c_int as libc::c_uint);
output_buf_size, let mut attr: pthread_attr_t = pthread_attr_t{__size: [0; 56],};
rates, pthread_attr_init(&mut attr);
0 as libc::c_int as libc::c_uint, pthread_attr_setstacksize(&mut attr,
); (16384 as libc::c_int +
let mut attr = crate::stdlib::pthread_attr_t { __size: [0; 56] }; 64 as libc::c_int * 1024 as libc::c_int) as
crate::stdlib::pthread_attr_init(&mut attr); size_t);
crate::stdlib::pthread_attr_setstacksize( pthread_create(&mut thread, &mut attr,
&mut attr, ::std::mem::transmute::<Option<unsafe extern "C" fn()
(16384 as libc::c_int + 64 as libc::c_int * 1024 as libc::c_int) as crate::stddef_h::size_t, -> *mut libc::c_void>,
); Option<unsafe extern "C" fn(_:
crate::stdlib::pthread_create( *mut libc::c_void)
&mut thread, ->
&mut attr, *mut libc::c_void>>(Some(::std::mem::transmute::<unsafe extern "C" fn()
::std::mem::transmute::< ->
Option<unsafe extern "C" fn() -> *mut libc::c_void>, *mut libc::c_void,
Option<unsafe extern "C" fn(_: *mut libc::c_void) -> *mut libc::c_void>, unsafe extern "C" fn()
>(Some(::std::mem::transmute::< ->
unsafe extern "C" fn() -> *mut libc::c_void, *mut libc::c_void>(output_thread))),
unsafe extern "C" fn() -> *mut libc::c_void, 0 as *mut libc::c_void);
>(output_thread))), pthread_attr_destroy(&mut attr);
0 as *mut libc::c_void,
);
crate::stdlib::pthread_attr_destroy(&mut attr);
} }
/* /*
* Squeezelite - lightweight headless squeezebox emulator * Squeezelite - lightweight headless squeezebox emulator
* *
* (c) Adrian Smith 2012-2015, triode1@btinternet.com * (c) Adrian Smith 2012-2015, triode1@btinternet.com
* Ralph Irving 2015-2017, ralph_irving@hotmail.com * Ralph Irving 2015-2017, ralph_irving@hotmail.com
* *
* This program is free software: you can redistribute it and/or modify * 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 * it under the terms of the GNU General Public License as published by
* the Free Software Foundation, either version 3 of the License, or * the Free Software Foundation, either version 3 of the License, or
* (at your option) any later version. * (at your option) any later version.
* *
* This program is distributed in the hope that it will be useful, * This program is distributed in the hope that it will be useful,
* but WITHOUT ANY WARRANTY; without even the implied warranty of * but WITHOUT ANY WARRANTY; without even the implied warranty of
* MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the * 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_pulse.c
// output_stdout.c // output_stdout.c
#[no_mangle] #[no_mangle]
pub unsafe extern "C" fn output_close_stdout() { 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 { if loglevel as libc::c_uint >= lINFO as libc::c_int as libc::c_uint {
crate::src::utils::logprint( logprint(b"%s %s:%d close output\n\x00" as *const u8 as
b"%s %s:%d close output\n\x00" as *const u8 as *const libc::c_char, *const libc::c_char, logtime(),
crate::src::utils::logtime(), (*::std::mem::transmute::<&[u8; 20],
(*::std::mem::transmute::<&[u8; 20], &[libc::c_char; 20]>(b"output_close_stdout\x00")) &[libc::c_char; 20]>(b"output_close_stdout\x00")).as_ptr(),
.as_ptr(), 174 as libc::c_int);
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; running = 0 as libc::c_int != 0;
crate::stdlib::pthread_mutex_unlock(&mut (*outputbuf).mutex); pthread_mutex_unlock(&mut (*outputbuf).mutex);
crate::stdlib::free(buf as *mut libc::c_void); free(buf as *mut libc::c_void);
crate::src::output::output_close_common(); output_close_common();
} }
src/pcm.rs
+826 -766
View File
File diff suppressed because it is too large Load Diff
src/slimproto.rs
+1778 -2007
View File
File diff suppressed because it is too large Load Diff
src/squeezelite_h.rs
-207
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,
}
src/stdarg_h.rs
-1
View File
@@ -1 +0,0 @@
pub type va_list = crate::internal::__builtin_va_list;
src/stddef_h.rs
-1
View File
@@ -1 +0,0 @@
pub type size_t = libc::c_ulong;
src/stdlib.rs
-2259
View File
File diff suppressed because it is too large Load Diff
src/stream.rs
+854 -911
View File
File diff suppressed because it is too large Load Diff
src/utils.rs
+771 -669
View File
File diff suppressed because it is too large Load Diff
src/vorbis.rs
+804 -582
View File
File diff suppressed because it is too large Load Diff