use ::c2rust_bitfields; use ::libc; pub use crate::stddef_h::size_t; pub use crate::stdlib::__int32_t; pub use crate::stdlib::__uint16_t; pub use crate::stdlib::__uint32_t; pub use crate::stdlib::__uint64_t; pub use crate::stdlib::__uint8_t; pub use crate::stdlib::int32_t; pub use crate::stdlib::__pthread_internal_list; pub use crate::stdlib::__pthread_list_t; pub use crate::stdlib::__pthread_mutex_s; pub use crate::stdlib::pthread_mutex_t; pub use crate::stdlib::u_int32_t; pub use crate::stdlib::u_int64_t; pub use crate::stdlib::u_int8_t; pub use crate::squeezelite_h::buffer; pub use crate::squeezelite_h::codec; pub use crate::squeezelite_h::decode_state; pub use crate::squeezelite_h::decodestate; pub use crate::squeezelite_h::disconnect_code; 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::stream_state; pub use crate::squeezelite_h::streamstate; pub use crate::squeezelite_h::u32_t; pub use crate::squeezelite_h::u64_t; pub use crate::squeezelite_h::u8_t; pub use crate::squeezelite_h::C2RustUnnamed_1; pub use crate::squeezelite_h::_buf_used; pub use crate::squeezelite_h::DECODE_COMPLETE; pub use crate::squeezelite_h::DECODE_ERROR; pub use crate::squeezelite_h::DECODE_READY; pub use crate::squeezelite_h::DECODE_RUNNING; pub use crate::squeezelite_h::DECODE_STOPPED; pub use crate::squeezelite_h::DISCONNECT; pub use crate::squeezelite_h::DISCONNECT_OK; 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::LOCAL_DISCONNECT; 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::RECV_HEADERS; pub use crate::squeezelite_h::REMOTE_DISCONNECT; 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::squeezelite_h::SEND_HEADERS; pub use crate::squeezelite_h::STOPPED; pub use crate::squeezelite_h::STREAMING_BUFFERING; pub use crate::squeezelite_h::STREAMING_FILE; pub use crate::squeezelite_h::STREAMING_HTTP; pub use crate::squeezelite_h::STREAMING_WAIT; pub use crate::squeezelite_h::TIMEOUT; pub use crate::squeezelite_h::UNREACHABLE; pub use crate::src::buffer::_buf_cont_read; pub use crate::src::buffer::_buf_cont_write; pub use crate::src::buffer::_buf_inc_readp; pub use crate::src::buffer::_buf_inc_writep; pub use crate::src::buffer::_buf_space; pub use crate::src::decode::decode_newstream; pub use crate::src::output::_checkfade; pub use crate::src::utils::logprint; pub use crate::src::utils::logtime; use crate::stdlib::malloc; use crate::stdlib::memcpy; pub use crate::stdlib::uint16_t; pub use crate::stdlib::uint32_t; pub use crate::stdlib::uint64_t; pub use crate::stdlib::uint8_t; pub use crate::stdlib::C2RustUnnamed_4; pub use crate::stdlib::C2RustUnnamed_5; pub use crate::stdlib::C2RustUnnamed_6; pub use crate::stdlib::C2RustUnnamed_7; pub use crate::stdlib::FLAC__ChannelAssignment; pub use crate::stdlib::FLAC__EntropyCodingMethod; pub use crate::stdlib::FLAC__EntropyCodingMethodType; pub use crate::stdlib::FLAC__EntropyCodingMethod_PartitionedRice; pub use crate::stdlib::FLAC__EntropyCodingMethod_PartitionedRiceContents; pub use crate::stdlib::FLAC__Frame; pub use crate::stdlib::FLAC__FrameFooter; pub use crate::stdlib::FLAC__FrameHeader; pub use crate::stdlib::FLAC__FrameNumberType; pub use crate::stdlib::FLAC__MetadataType; pub use crate::stdlib::FLAC__StreamDecoder; pub use crate::stdlib::FLAC__StreamDecoderEofCallback; pub use crate::stdlib::FLAC__StreamDecoderErrorCallback; pub use crate::stdlib::FLAC__StreamDecoderErrorStatus; pub use crate::stdlib::FLAC__StreamDecoderInitStatus; pub use crate::stdlib::FLAC__StreamDecoderLengthCallback; pub use crate::stdlib::FLAC__StreamDecoderLengthStatus; pub use crate::stdlib::FLAC__StreamDecoderMetadataCallback; pub use crate::stdlib::FLAC__StreamDecoderPrivate; pub use crate::stdlib::FLAC__StreamDecoderProtected; pub use crate::stdlib::FLAC__StreamDecoderReadCallback; pub use crate::stdlib::FLAC__StreamDecoderReadStatus; pub use crate::stdlib::FLAC__StreamDecoderSeekCallback; pub use crate::stdlib::FLAC__StreamDecoderSeekStatus; pub use crate::stdlib::FLAC__StreamDecoderState; pub use crate::stdlib::FLAC__StreamDecoderTellCallback; pub use crate::stdlib::FLAC__StreamDecoderTellStatus; pub use crate::stdlib::FLAC__StreamDecoderWriteCallback; pub use crate::stdlib::FLAC__StreamDecoderWriteStatus; pub use crate::stdlib::FLAC__StreamMetadata; pub use crate::stdlib::FLAC__StreamMetadata_Application; pub use crate::stdlib::FLAC__StreamMetadata_CueSheet; pub use crate::stdlib::FLAC__StreamMetadata_CueSheet_Index; pub use crate::stdlib::FLAC__StreamMetadata_CueSheet_Track; pub use crate::stdlib::FLAC__StreamMetadata_Padding; pub use crate::stdlib::FLAC__StreamMetadata_Picture; pub use crate::stdlib::FLAC__StreamMetadata_Picture_Type; pub use crate::stdlib::FLAC__StreamMetadata_SeekPoint; pub use crate::stdlib::FLAC__StreamMetadata_SeekTable; pub use crate::stdlib::FLAC__StreamMetadata_StreamInfo; pub use crate::stdlib::FLAC__StreamMetadata_Unknown; pub use crate::stdlib::FLAC__StreamMetadata_VorbisComment; pub use crate::stdlib::FLAC__StreamMetadata_VorbisComment_Entry; pub use crate::stdlib::FLAC__Subframe; pub use crate::stdlib::FLAC__SubframeType; pub use crate::stdlib::FLAC__Subframe_Constant; pub use crate::stdlib::FLAC__Subframe_Fixed; pub use crate::stdlib::FLAC__Subframe_LPC; pub use crate::stdlib::FLAC__Subframe_Verbatim; pub use crate::stdlib::FLAC__bool; pub use crate::stdlib::FLAC__byte; pub use crate::stdlib::FLAC__int32; pub use crate::stdlib::FLAC__uint16; pub use crate::stdlib::FLAC__uint32; pub use crate::stdlib::FLAC__uint64; pub use crate::stdlib::FLAC__uint8; pub use crate::stdlib::FLAC__CHANNEL_ASSIGNMENT_INDEPENDENT; pub use crate::stdlib::FLAC__CHANNEL_ASSIGNMENT_LEFT_SIDE; pub use crate::stdlib::FLAC__CHANNEL_ASSIGNMENT_MID_SIDE; pub use crate::stdlib::FLAC__CHANNEL_ASSIGNMENT_RIGHT_SIDE; pub use crate::stdlib::FLAC__ENTROPY_CODING_METHOD_PARTITIONED_RICE; pub use crate::stdlib::FLAC__ENTROPY_CODING_METHOD_PARTITIONED_RICE2; pub use crate::stdlib::FLAC__FRAME_NUMBER_TYPE_FRAME_NUMBER; pub use crate::stdlib::FLAC__FRAME_NUMBER_TYPE_SAMPLE_NUMBER; pub use crate::stdlib::FLAC__MAX_METADATA_TYPE; pub use crate::stdlib::FLAC__METADATA_TYPE_APPLICATION; pub use crate::stdlib::FLAC__METADATA_TYPE_CUESHEET; pub use crate::stdlib::FLAC__METADATA_TYPE_PADDING; pub use crate::stdlib::FLAC__METADATA_TYPE_PICTURE; pub use crate::stdlib::FLAC__METADATA_TYPE_SEEKTABLE; pub use crate::stdlib::FLAC__METADATA_TYPE_STREAMINFO; pub use crate::stdlib::FLAC__METADATA_TYPE_UNDEFINED; pub use crate::stdlib::FLAC__METADATA_TYPE_VORBIS_COMMENT; pub use crate::stdlib::FLAC__STREAM_DECODER_ABORTED; pub use crate::stdlib::FLAC__STREAM_DECODER_END_OF_STREAM; pub use crate::stdlib::FLAC__STREAM_DECODER_ERROR_STATUS_BAD_HEADER; pub use crate::stdlib::FLAC__STREAM_DECODER_ERROR_STATUS_FRAME_CRC_MISMATCH; pub use crate::stdlib::FLAC__STREAM_DECODER_ERROR_STATUS_LOST_SYNC; pub use crate::stdlib::FLAC__STREAM_DECODER_ERROR_STATUS_UNPARSEABLE_STREAM; pub use crate::stdlib::FLAC__STREAM_DECODER_INIT_STATUS_ALREADY_INITIALIZED; pub use crate::stdlib::FLAC__STREAM_DECODER_INIT_STATUS_ERROR_OPENING_FILE; pub use crate::stdlib::FLAC__STREAM_DECODER_INIT_STATUS_INVALID_CALLBACKS; pub use crate::stdlib::FLAC__STREAM_DECODER_INIT_STATUS_MEMORY_ALLOCATION_ERROR; pub use crate::stdlib::FLAC__STREAM_DECODER_INIT_STATUS_OK; pub use crate::stdlib::FLAC__STREAM_DECODER_INIT_STATUS_UNSUPPORTED_CONTAINER; pub use crate::stdlib::FLAC__STREAM_DECODER_LENGTH_STATUS_ERROR; pub use crate::stdlib::FLAC__STREAM_DECODER_LENGTH_STATUS_OK; pub use crate::stdlib::FLAC__STREAM_DECODER_LENGTH_STATUS_UNSUPPORTED; pub use crate::stdlib::FLAC__STREAM_DECODER_MEMORY_ALLOCATION_ERROR; pub use crate::stdlib::FLAC__STREAM_DECODER_OGG_ERROR; pub use crate::stdlib::FLAC__STREAM_DECODER_READ_FRAME; pub use crate::stdlib::FLAC__STREAM_DECODER_READ_METADATA; pub use crate::stdlib::FLAC__STREAM_DECODER_READ_STATUS_ABORT; pub use crate::stdlib::FLAC__STREAM_DECODER_READ_STATUS_CONTINUE; pub use crate::stdlib::FLAC__STREAM_DECODER_READ_STATUS_END_OF_STREAM; pub use crate::stdlib::FLAC__STREAM_DECODER_SEARCH_FOR_FRAME_SYNC; pub use crate::stdlib::FLAC__STREAM_DECODER_SEARCH_FOR_METADATA; pub use crate::stdlib::FLAC__STREAM_DECODER_SEEK_ERROR; pub use crate::stdlib::FLAC__STREAM_DECODER_SEEK_STATUS_ERROR; pub use crate::stdlib::FLAC__STREAM_DECODER_SEEK_STATUS_OK; pub use crate::stdlib::FLAC__STREAM_DECODER_SEEK_STATUS_UNSUPPORTED; pub use crate::stdlib::FLAC__STREAM_DECODER_TELL_STATUS_ERROR; pub use crate::stdlib::FLAC__STREAM_DECODER_TELL_STATUS_OK; pub use crate::stdlib::FLAC__STREAM_DECODER_TELL_STATUS_UNSUPPORTED; pub use crate::stdlib::FLAC__STREAM_DECODER_UNINITIALIZED; pub use crate::stdlib::FLAC__STREAM_DECODER_WRITE_STATUS_ABORT; pub use crate::stdlib::FLAC__STREAM_DECODER_WRITE_STATUS_CONTINUE; pub use crate::stdlib::FLAC__STREAM_METADATA_PICTURE_TYPE_ARTIST; pub use crate::stdlib::FLAC__STREAM_METADATA_PICTURE_TYPE_BACK_COVER; pub use crate::stdlib::FLAC__STREAM_METADATA_PICTURE_TYPE_BAND; pub use crate::stdlib::FLAC__STREAM_METADATA_PICTURE_TYPE_BAND_LOGOTYPE; pub use crate::stdlib::FLAC__STREAM_METADATA_PICTURE_TYPE_COMPOSER; pub use crate::stdlib::FLAC__STREAM_METADATA_PICTURE_TYPE_CONDUCTOR; pub use crate::stdlib::FLAC__STREAM_METADATA_PICTURE_TYPE_DURING_PERFORMANCE; pub use crate::stdlib::FLAC__STREAM_METADATA_PICTURE_TYPE_DURING_RECORDING; pub use crate::stdlib::FLAC__STREAM_METADATA_PICTURE_TYPE_FILE_ICON; pub use crate::stdlib::FLAC__STREAM_METADATA_PICTURE_TYPE_FILE_ICON_STANDARD; pub use crate::stdlib::FLAC__STREAM_METADATA_PICTURE_TYPE_FISH; pub use crate::stdlib::FLAC__STREAM_METADATA_PICTURE_TYPE_FRONT_COVER; pub use crate::stdlib::FLAC__STREAM_METADATA_PICTURE_TYPE_ILLUSTRATION; pub use crate::stdlib::FLAC__STREAM_METADATA_PICTURE_TYPE_LEAD_ARTIST; pub use crate::stdlib::FLAC__STREAM_METADATA_PICTURE_TYPE_LEAFLET_PAGE; pub use crate::stdlib::FLAC__STREAM_METADATA_PICTURE_TYPE_LYRICIST; pub use crate::stdlib::FLAC__STREAM_METADATA_PICTURE_TYPE_MEDIA; pub use crate::stdlib::FLAC__STREAM_METADATA_PICTURE_TYPE_OTHER; pub use crate::stdlib::FLAC__STREAM_METADATA_PICTURE_TYPE_PUBLISHER_LOGOTYPE; pub use crate::stdlib::FLAC__STREAM_METADATA_PICTURE_TYPE_RECORDING_LOCATION; pub use crate::stdlib::FLAC__STREAM_METADATA_PICTURE_TYPE_UNDEFINED; pub use crate::stdlib::FLAC__STREAM_METADATA_PICTURE_TYPE_VIDEO_SCREEN_CAPTURE; pub use crate::stdlib::FLAC__SUBFRAME_TYPE_CONSTANT; pub use crate::stdlib::FLAC__SUBFRAME_TYPE_FIXED; pub use crate::stdlib::FLAC__SUBFRAME_TYPE_LPC; pub use crate::stdlib::FLAC__SUBFRAME_TYPE_VERBATIM; use crate::stdlib::dlerror; use crate::stdlib::dlopen; use crate::stdlib::dlsym; use crate::stdlib::pthread_mutex_lock; use crate::stdlib::pthread_mutex_unlock; extern "C" { #[no_mangle] pub static mut loglevel: crate::squeezelite_h::log_level; #[no_mangle] pub static mut streambuf: *mut crate::squeezelite_h::buffer; #[no_mangle] pub static mut outputbuf: *mut crate::squeezelite_h::buffer; #[no_mangle] pub static mut stream: crate::squeezelite_h::streamstate; #[no_mangle] pub static mut output: crate::squeezelite_h::outputstate; #[no_mangle] pub static mut decode: crate::squeezelite_h::decodestate; } /* * Squeezelite - lightweight headless squeezeplay emulator for linux * * (c) Adrian Smith 2012, triode1@btinternet.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 * GNU General Public License for more details. * * You should have received a copy of the GNU General Public License * along with this program. If not, see . * */ #[repr(C)] #[derive(Copy, Clone)] pub struct flac { pub decoder: *mut crate::stdlib::FLAC__StreamDecoder, pub FLAC__StreamDecoderErrorStatusString: *mut *const libc::c_char, pub FLAC__StreamDecoderStateString: *mut *const libc::c_char, pub FLAC__stream_decoder_new: Option *mut crate::stdlib::FLAC__StreamDecoder>, pub FLAC__stream_decoder_reset: Option< unsafe extern "C" fn( _: *mut crate::stdlib::FLAC__StreamDecoder, ) -> crate::stdlib::FLAC__bool, >, pub FLAC__stream_decoder_delete: Option ()>, pub FLAC__stream_decoder_init_stream: Option< unsafe extern "C" fn( _: *mut crate::stdlib::FLAC__StreamDecoder, _: crate::stdlib::FLAC__StreamDecoderReadCallback, _: crate::stdlib::FLAC__StreamDecoderSeekCallback, _: crate::stdlib::FLAC__StreamDecoderTellCallback, _: crate::stdlib::FLAC__StreamDecoderLengthCallback, _: crate::stdlib::FLAC__StreamDecoderEofCallback, _: crate::stdlib::FLAC__StreamDecoderWriteCallback, _: crate::stdlib::FLAC__StreamDecoderMetadataCallback, _: crate::stdlib::FLAC__StreamDecoderErrorCallback, _: *mut libc::c_void, ) -> crate::stdlib::FLAC__StreamDecoderInitStatus, >, pub FLAC__stream_decoder_init_ogg_stream: Option< unsafe extern "C" fn( _: *mut crate::stdlib::FLAC__StreamDecoder, _: crate::stdlib::FLAC__StreamDecoderReadCallback, _: crate::stdlib::FLAC__StreamDecoderSeekCallback, _: crate::stdlib::FLAC__StreamDecoderTellCallback, _: crate::stdlib::FLAC__StreamDecoderLengthCallback, _: crate::stdlib::FLAC__StreamDecoderEofCallback, _: crate::stdlib::FLAC__StreamDecoderWriteCallback, _: crate::stdlib::FLAC__StreamDecoderMetadataCallback, _: crate::stdlib::FLAC__StreamDecoderErrorCallback, _: *mut libc::c_void, ) -> crate::stdlib::FLAC__StreamDecoderInitStatus, >, pub FLAC__stream_decoder_process_single: Option< unsafe extern "C" fn( _: *mut crate::stdlib::FLAC__StreamDecoder, ) -> crate::stdlib::FLAC__bool, >, pub FLAC__stream_decoder_get_state: Option< unsafe extern "C" fn( _: *const crate::stdlib::FLAC__StreamDecoder, ) -> crate::stdlib::FLAC__StreamDecoderState, >, } static mut f: *mut flac = 0 as *const flac as *mut flac; unsafe extern "C" fn read_cb( mut decoder: *const crate::stdlib::FLAC__StreamDecoder, mut buffer: *mut crate::stdlib::FLAC__byte, mut want: *mut crate::stddef_h::size_t, mut client_data: *mut libc::c_void, ) -> crate::stdlib::FLAC__StreamDecoderReadStatus { let mut bytes: crate::stddef_h::size_t = 0; let mut end: bool = false; crate::stdlib::pthread_mutex_lock(&mut (*streambuf).mutex); bytes = if crate::squeezelite_h::_buf_used(streambuf) < crate::src::buffer::_buf_cont_read(streambuf) { crate::squeezelite_h::_buf_used(streambuf) } else { crate::src::buffer::_buf_cont_read(streambuf) } as crate::stddef_h::size_t; bytes = if bytes < *want { bytes } else { *want }; end = stream.state as libc::c_uint <= crate::squeezelite_h::DISCONNECT as libc::c_int as libc::c_uint && bytes == 0 as libc::c_int as libc::c_ulong; crate::stdlib::memcpy( buffer as *mut libc::c_void, (*streambuf).readp as *const libc::c_void, bytes, ); crate::src::buffer::_buf_inc_readp(streambuf, bytes as libc::c_uint); crate::stdlib::pthread_mutex_unlock(&mut (*streambuf).mutex); *want = bytes; return if end as libc::c_int != 0 { crate::stdlib::FLAC__STREAM_DECODER_READ_STATUS_END_OF_STREAM as libc::c_int } else { crate::stdlib::FLAC__STREAM_DECODER_READ_STATUS_CONTINUE as libc::c_int } as crate::stdlib::FLAC__StreamDecoderReadStatus; } unsafe extern "C" fn write_cb( mut decoder: *const crate::stdlib::FLAC__StreamDecoder, mut frame: *const crate::stdlib::FLAC__Frame, mut buffer: *const *const crate::stdlib::FLAC__int32, mut client_data: *mut libc::c_void, ) -> crate::stdlib::FLAC__StreamDecoderWriteStatus { let mut frames = (*frame).header.blocksize as crate::stddef_h::size_t; let mut bits_per_sample = (*frame).header.bits_per_sample; let mut channels = (*frame).header.channels; let mut lptr = *buffer.offset(0 as libc::c_int as isize) as *mut crate::stdlib::FLAC__int32; let mut rptr = *buffer.offset(if channels > 1 as libc::c_int as libc::c_uint { 1 as libc::c_int } else { 0 as libc::c_int } as isize) as *mut crate::stdlib::FLAC__int32; if decode.new_stream { crate::stdlib::pthread_mutex_lock(&mut (*outputbuf).mutex); 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 setting track_start\n\x00" as *const u8 as *const libc::c_char, crate::src::utils::logtime(), (*::std::mem::transmute::<&[u8; 9], &[libc::c_char; 9]>(b"write_cb\x00")).as_ptr(), 128 as libc::c_int, ); } output.track_start = (*outputbuf).writep; decode.new_stream = 0 as libc::c_int != 0; output.next_sample_rate = crate::src::decode::decode_newstream( (*frame).header.sample_rate, output.supported_rates.as_mut_ptr(), ); if output.fade_mode as u64 != 0 { crate::src::output::_checkfade(1 as libc::c_int != 0); } crate::stdlib::pthread_mutex_unlock(&mut (*outputbuf).mutex); } crate::stdlib::pthread_mutex_lock(&mut (*outputbuf).mutex); while frames > 0 as libc::c_int as libc::c_ulong { let mut f_0: crate::squeezelite_h::frames_t = 0; let mut count: crate::squeezelite_h::frames_t = 0; let mut optr = 0 as *mut crate::squeezelite_h::s32_t; optr = (*outputbuf).writep as *mut crate::squeezelite_h::s32_t; f_0 = (if crate::src::buffer::_buf_space(outputbuf) < crate::src::buffer::_buf_cont_write(outputbuf) { crate::src::buffer::_buf_space(outputbuf) } else { crate::src::buffer::_buf_cont_write(outputbuf) }) .wrapping_div(8 as libc::c_int as libc::c_uint); f_0 = if (f_0 as libc::c_ulong) < frames { f_0 as libc::c_ulong } else { frames } as crate::squeezelite_h::frames_t; count = f_0; if bits_per_sample == 8 as libc::c_int as libc::c_uint { loop { let fresh0 = count; count = count.wrapping_sub(1); if !(fresh0 != 0) { break; } let fresh1 = lptr; lptr = lptr.offset(1); let fresh2 = optr; optr = optr.offset(1); *fresh2 = *fresh1 << 24 as libc::c_int; let fresh3 = rptr; rptr = rptr.offset(1); let fresh4 = optr; optr = optr.offset(1); *fresh4 = *fresh3 << 24 as libc::c_int } } else if bits_per_sample == 16 as libc::c_int as libc::c_uint { loop { let fresh5 = count; count = count.wrapping_sub(1); if !(fresh5 != 0) { break; } let fresh6 = lptr; lptr = lptr.offset(1); let fresh7 = optr; optr = optr.offset(1); *fresh7 = *fresh6 << 16 as libc::c_int; let fresh8 = rptr; rptr = rptr.offset(1); let fresh9 = optr; optr = optr.offset(1); *fresh9 = *fresh8 << 16 as libc::c_int } } else if bits_per_sample == 24 as libc::c_int as libc::c_uint { loop { let fresh10 = count; count = count.wrapping_sub(1); if !(fresh10 != 0) { break; } let fresh11 = lptr; lptr = lptr.offset(1); let fresh12 = optr; optr = optr.offset(1); *fresh12 = *fresh11 << 8 as libc::c_int; let fresh13 = rptr; rptr = rptr.offset(1); let fresh14 = optr; optr = optr.offset(1); *fresh14 = *fresh13 << 8 as libc::c_int } } else if bits_per_sample == 32 as libc::c_int as libc::c_uint { loop { let fresh15 = count; count = count.wrapping_sub(1); if !(fresh15 != 0) { break; } let fresh16 = lptr; lptr = lptr.offset(1); let fresh17 = optr; optr = optr.offset(1); *fresh17 = *fresh16; let fresh18 = rptr; rptr = rptr.offset(1); let fresh19 = optr; optr = optr.offset(1); *fresh19 = *fresh18 } } else { crate::src::utils::logprint( b"%s %s:%d unsupported bits per sample: %u\n\x00" as *const u8 as *const libc::c_char, crate::src::utils::logtime(), (*::std::mem::transmute::<&[u8; 9], &[libc::c_char; 9]>(b"write_cb\x00")).as_ptr(), 200 as libc::c_int, bits_per_sample, ); } frames = (frames as libc::c_ulong).wrapping_sub(f_0 as libc::c_ulong) as crate::stddef_h::size_t as crate::stddef_h::size_t; crate::src::buffer::_buf_inc_writep( outputbuf, f_0.wrapping_mul(8 as libc::c_int as libc::c_uint), ); } crate::stdlib::pthread_mutex_unlock(&mut (*outputbuf).mutex); return crate::stdlib::FLAC__STREAM_DECODER_WRITE_STATUS_CONTINUE; } unsafe extern "C" fn error_cb( mut decoder: *const crate::stdlib::FLAC__StreamDecoder, mut status: crate::stdlib::FLAC__StreamDecoderErrorStatus, mut client_data: *mut libc::c_void, ) { 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 flac error: %s\n\x00" as *const u8 as *const libc::c_char, crate::src::utils::logtime(), (*::std::mem::transmute::<&[u8; 9], &[libc::c_char; 9]>(b"error_cb\x00")).as_ptr(), 220 as libc::c_int, *(*f) .FLAC__StreamDecoderErrorStatusString .offset(status as isize), ); }; } unsafe extern "C" fn flac_open( mut sample_size: crate::squeezelite_h::u8_t, mut sample_rate: crate::squeezelite_h::u8_t, mut channels: crate::squeezelite_h::u8_t, mut endianness: crate::squeezelite_h::u8_t, ) { if !(*f).decoder.is_null() { (*f).FLAC__stream_decoder_reset .expect("non-null function pointer")((*f).decoder); } else { (*f).decoder = (*f) .FLAC__stream_decoder_new .expect("non-null function pointer")() } if sample_size as libc::c_int == 'o' as i32 { if loglevel as libc::c_uint >= crate::squeezelite_h::lDEBUG as libc::c_int as libc::c_uint { crate::src::utils::logprint( b"%s %s:%d ogg/flac container - using init_ogg_stream\n\x00" as *const u8 as *const libc::c_char, crate::src::utils::logtime(), (*::std::mem::transmute::<&[u8; 10], &[libc::c_char; 10]>(b"flac_open\x00")) .as_ptr(), 231 as libc::c_int, ); } (*f).FLAC__stream_decoder_init_ogg_stream .expect("non-null function pointer")( (*f).decoder, Some( read_cb as unsafe extern "C" fn( _: *const crate::stdlib::FLAC__StreamDecoder, _: *mut crate::stdlib::FLAC__byte, _: *mut crate::stddef_h::size_t, _: *mut libc::c_void, ) -> crate::stdlib::FLAC__StreamDecoderReadStatus, ), None, None, None, None, Some( write_cb as unsafe extern "C" fn( _: *const crate::stdlib::FLAC__StreamDecoder, _: *const crate::stdlib::FLAC__Frame, _: *const *const crate::stdlib::FLAC__int32, _: *mut libc::c_void, ) -> crate::stdlib::FLAC__StreamDecoderWriteStatus, ), None, Some( error_cb as unsafe extern "C" fn( _: *const crate::stdlib::FLAC__StreamDecoder, _: crate::stdlib::FLAC__StreamDecoderErrorStatus, _: *mut libc::c_void, ) -> (), ), 0 as *mut libc::c_void, ); } else { (*f).FLAC__stream_decoder_init_stream .expect("non-null function pointer")( (*f).decoder, Some( read_cb as unsafe extern "C" fn( _: *const crate::stdlib::FLAC__StreamDecoder, _: *mut crate::stdlib::FLAC__byte, _: *mut crate::stddef_h::size_t, _: *mut libc::c_void, ) -> crate::stdlib::FLAC__StreamDecoderReadStatus, ), None, None, None, None, Some( write_cb as unsafe extern "C" fn( _: *const crate::stdlib::FLAC__StreamDecoder, _: *const crate::stdlib::FLAC__Frame, _: *const *const crate::stdlib::FLAC__int32, _: *mut libc::c_void, ) -> crate::stdlib::FLAC__StreamDecoderWriteStatus, ), None, Some( error_cb as unsafe extern "C" fn( _: *const crate::stdlib::FLAC__StreamDecoder, _: crate::stdlib::FLAC__StreamDecoderErrorStatus, _: *mut libc::c_void, ) -> (), ), 0 as *mut libc::c_void, ); }; } unsafe extern "C" fn flac_close() { (*f).FLAC__stream_decoder_delete .expect("non-null function pointer")((*f).decoder); (*f).decoder = 0 as *mut crate::stdlib::FLAC__StreamDecoder; } unsafe extern "C" fn flac_decode() -> crate::squeezelite_h::decode_state { let mut ok = (*f) .FLAC__stream_decoder_process_single .expect("non-null function pointer")((*f).decoder) != 0; let mut state = (*f) .FLAC__stream_decoder_get_state .expect("non-null function pointer")((*f).decoder); if !ok && state as libc::c_uint != crate::stdlib::FLAC__STREAM_DECODER_END_OF_STREAM as libc::c_int as libc::c_uint { 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 flac error: %s\n\x00" as *const u8 as *const libc::c_char, crate::src::utils::logtime(), (*::std::mem::transmute::<&[u8; 12], &[libc::c_char; 12]>(b"flac_decode\x00")) .as_ptr(), 249 as libc::c_int, *(*f).FLAC__StreamDecoderStateString.offset(state as isize), ); } } if state as libc::c_uint == crate::stdlib::FLAC__STREAM_DECODER_END_OF_STREAM as libc::c_int as libc::c_uint { return crate::squeezelite_h::DECODE_COMPLETE; } else if state as libc::c_uint > crate::stdlib::FLAC__STREAM_DECODER_END_OF_STREAM as libc::c_int as libc::c_uint { return crate::squeezelite_h::DECODE_ERROR; } else { return crate::squeezelite_h::DECODE_RUNNING; }; } unsafe extern "C" fn load_flac() -> bool { let mut handle = crate::stdlib::dlopen( b"libFLAC.so.8\x00" as *const u8 as *const libc::c_char, 0x2 as libc::c_int, ); let mut err = 0 as *mut libc::c_char; if handle.is_null() { 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 dlerror: %s\n\x00" as *const u8 as *const libc::c_char, crate::src::utils::logtime(), (*::std::mem::transmute::<&[u8; 10], &[libc::c_char; 10]>(b"load_flac\x00")) .as_ptr(), 267 as libc::c_int, crate::stdlib::dlerror(), ); } return 0 as libc::c_int != 0; } (*f).FLAC__StreamDecoderErrorStatusString = crate::stdlib::dlsym( handle, b"FLAC__StreamDecoderErrorStatusString\x00" as *const u8 as *const libc::c_char, ) as *mut *const libc::c_char; (*f).FLAC__StreamDecoderStateString = crate::stdlib::dlsym( handle, b"FLAC__StreamDecoderStateString\x00" as *const u8 as *const libc::c_char, ) as *mut *const libc::c_char; (*f).FLAC__stream_decoder_new = ::std::mem::transmute::< *mut libc::c_void, Option *mut crate::stdlib::FLAC__StreamDecoder>, >(crate::stdlib::dlsym( handle, b"FLAC__stream_decoder_new\x00" as *const u8 as *const libc::c_char, )); (*f).FLAC__stream_decoder_reset = ::std::mem::transmute::< *mut libc::c_void, Option< unsafe extern "C" fn( _: *mut crate::stdlib::FLAC__StreamDecoder, ) -> crate::stdlib::FLAC__bool, >, >(crate::stdlib::dlsym( handle, b"FLAC__stream_decoder_reset\x00" as *const u8 as *const libc::c_char, )); (*f).FLAC__stream_decoder_delete = ::std::mem::transmute::< *mut libc::c_void, Option ()>, >(crate::stdlib::dlsym( handle, b"FLAC__stream_decoder_delete\x00" as *const u8 as *const libc::c_char, )); (*f).FLAC__stream_decoder_init_stream = ::std::mem::transmute::< *mut libc::c_void, Option< unsafe extern "C" fn( _: *mut crate::stdlib::FLAC__StreamDecoder, _: crate::stdlib::FLAC__StreamDecoderReadCallback, _: crate::stdlib::FLAC__StreamDecoderSeekCallback, _: crate::stdlib::FLAC__StreamDecoderTellCallback, _: crate::stdlib::FLAC__StreamDecoderLengthCallback, _: crate::stdlib::FLAC__StreamDecoderEofCallback, _: crate::stdlib::FLAC__StreamDecoderWriteCallback, _: crate::stdlib::FLAC__StreamDecoderMetadataCallback, _: crate::stdlib::FLAC__StreamDecoderErrorCallback, _: *mut libc::c_void, ) -> crate::stdlib::FLAC__StreamDecoderInitStatus, >, >(crate::stdlib::dlsym( handle, b"FLAC__stream_decoder_init_stream\x00" as *const u8 as *const libc::c_char, )); (*f).FLAC__stream_decoder_init_ogg_stream = ::std::mem::transmute::< *mut libc::c_void, Option< unsafe extern "C" fn( _: *mut crate::stdlib::FLAC__StreamDecoder, _: crate::stdlib::FLAC__StreamDecoderReadCallback, _: crate::stdlib::FLAC__StreamDecoderSeekCallback, _: crate::stdlib::FLAC__StreamDecoderTellCallback, _: crate::stdlib::FLAC__StreamDecoderLengthCallback, _: crate::stdlib::FLAC__StreamDecoderEofCallback, _: crate::stdlib::FLAC__StreamDecoderWriteCallback, _: crate::stdlib::FLAC__StreamDecoderMetadataCallback, _: crate::stdlib::FLAC__StreamDecoderErrorCallback, _: *mut libc::c_void, ) -> crate::stdlib::FLAC__StreamDecoderInitStatus, >, >(crate::stdlib::dlsym( handle, b"FLAC__stream_decoder_init_ogg_stream\x00" as *const u8 as *const libc::c_char, )); (*f).FLAC__stream_decoder_process_single = ::std::mem::transmute::< *mut libc::c_void, Option< unsafe extern "C" fn( _: *mut crate::stdlib::FLAC__StreamDecoder, ) -> crate::stdlib::FLAC__bool, >, >(crate::stdlib::dlsym( handle, b"FLAC__stream_decoder_process_single\x00" as *const u8 as *const libc::c_char, )); (*f).FLAC__stream_decoder_get_state = ::std::mem::transmute::< *mut libc::c_void, Option< unsafe extern "C" fn( _: *const crate::stdlib::FLAC__StreamDecoder, ) -> crate::stdlib::FLAC__StreamDecoderState, >, >(crate::stdlib::dlsym( handle, b"FLAC__stream_decoder_get_state\x00" as *const u8 as *const libc::c_char, )); err = crate::stdlib::dlerror(); if !err.is_null() { 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 dlerror: %s\n\x00" as *const u8 as *const libc::c_char, crate::src::utils::logtime(), (*::std::mem::transmute::<&[u8; 10], &[libc::c_char; 10]>(b"load_flac\x00")) .as_ptr(), 282 as libc::c_int, err, ); } return 0 as libc::c_int != 0; } 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 loaded libFLAC.so.8\n\x00" as *const u8 as *const libc::c_char, crate::src::utils::logtime(), (*::std::mem::transmute::<&[u8; 10], &[libc::c_char; 10]>(b"load_flac\x00")).as_ptr(), 286 as libc::c_int, ); } return 1 as libc::c_int != 0; } /* * 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 * GNU General Public License for more details. * * You should have received a copy of the GNU General Public License * along with this program. If not, see . * * Additions (c) Paul Hermann, 2015-2017 under the same license terms * -Control of Raspberry pi GPIO for amplifier power * -Launch script on power status change from LMS */ // make may define: PORTAUDIO, SELFPIPE, RESAMPLE, RESAMPLE_MP, VISEXPORT, GPIO, IR, DSD, LINKALL to influence build // build detection // dynamically loaded libraries at run time // !LINKALL // config options // do not reduce as icy-meta max is 4080 /* SUN */ /* SUN */ // printf/scanf formats for u64_t // logging // utils.c (non logging) // buffer.c // _* called with mutex locked // slimproto.c // stream.c // decode.c // output.c output_alsa.c output_pa.c output_pack.c // frames played at the point delay is measured // ordered largest first so [0] is max_rate // set in decode thread // set in decode thread // set by slimproto // set by slimproto // set by slimproto // set by slimproto // set by slimproto // set by slimproto // set by slimproto // _* called with mutex locked // output_alsa.c // output_pa.c // output_pulse.c // output_stdout.c // output_pack.c // output_vis.c // dop.c // codecs #[no_mangle] pub unsafe extern "C" fn register_flac() -> *mut crate::squeezelite_h::codec { static mut ret: crate::squeezelite_h::codec = unsafe { { let mut init = crate::squeezelite_h::codec { id: 'f' as i32 as libc::c_char, types: b"ogf,flc\x00" as *const u8 as *const libc::c_char as *mut libc::c_char, min_read_bytes: 16384 as libc::c_int as libc::c_uint, min_space: 204800 as libc::c_int as libc::c_uint, open: Some( flac_open as unsafe extern "C" fn( _: crate::squeezelite_h::u8_t, _: crate::squeezelite_h::u8_t, _: crate::squeezelite_h::u8_t, _: crate::squeezelite_h::u8_t, ) -> (), ), close: Some(flac_close as unsafe extern "C" fn() -> ()), decode: Some( flac_decode as unsafe extern "C" fn() -> crate::squeezelite_h::decode_state, ), }; init } }; f = crate::stdlib::malloc(::std::mem::size_of::() as libc::c_ulong) as *mut flac; if f.is_null() { return 0 as *mut crate::squeezelite_h::codec; } (*f).decoder = 0 as *mut crate::stdlib::FLAC__StreamDecoder; if !load_flac() { return 0 as *mut crate::squeezelite_h::codec; } 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 using flac to decode ogf,flc\n\x00" as *const u8 as *const libc::c_char, crate::src::utils::logtime(), (*::std::mem::transmute::<&[u8; 14], &[libc::c_char; 14]>(b"register_flac\x00")) .as_ptr(), 314 as libc::c_int, ); } return &mut ret; }