928 lines
39 KiB
Rust
928 lines
39 KiB
Rust
|
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 <http://www.gnu.org/licenses/>.
|
||
|
|
*
|
||
|
|
*/
|
||
|
|
|
||
|
|
#[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<unsafe extern "C" fn() -> *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<unsafe extern "C" fn(_: *mut crate::stdlib::FLAC__StreamDecoder) -> ()>,
|
||
|
|
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<unsafe extern "C" fn() -> *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<unsafe extern "C" fn(_: *mut crate::stdlib::FLAC__StreamDecoder) -> ()>,
|
||
|
|
>(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 <http://www.gnu.org/licenses/>.
|
||
|
|
*
|
||
|
|
* 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::<flac>() 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;
|
||
|
|
}
|