Generated on Wed Feb 3 22:16:44 2010 for libfishsound by
1.5.8
libfishsound-1.0.0/doc/libfishsound/html/classes.html 0000644 0001750 0001750 00000003623 11332273474 017661 0000000 0000000
libfishsound: Alphabetical List
Vorbis and Speex bitstreams use a comment format called "Vorbiscomment", defined here. Many standard comment names (such as TITLE, COPYRIGHT and GENRE) are defined in that document.
The following general features of Vorbiscomment are relevant to this API:
Each stream has one comment packet, which occurs before any encoded audio data in the stream.
When encoding, FishSound will generate the comment block and pass it to the encoded() callback in sequence, just like any other packet. Hence, all comments must be set before any call to fish_sound_encode_*().
When decoding, FishSound will decode the comment block before calling the first decoded() callback. Hence, retrieving comment data is possible from as soon as the decoded() callback is first called.
Each comment block contains one Vendor string, which can be retrieved with fish_sound_comment_get_vendor(). When encoding, this string is effectively fixed by the codec libraries; it cannot be set by the application.
The rest of a comment block consists of name = value pairs, with the following restrictions:
Both the name and value must be non-empty
The name is case-insensitive and must consist of ASCII within the range 0x20 to 0x7D inclusive, 0x3D ('=') excluded.
The name is not unique; multiple entries may exist with equivalent name within a Vorbiscomment block.
00001 /*00002 Copyright (C) 2003 Commonwealth Scientific and Industrial Research00003 Organisation (CSIRO) Australia00004
00005 Redistribution and use in source and binary forms, with or without00006 modification, are permitted provided that the following conditions00007 are met:00008
00009 - Redistributions of source code must retain the above copyright00010 notice, this list of conditions and the following disclaimer.00011
00012 - Redistributions in binary form must reproduce the above copyright00013 notice, this list of conditions and the following disclaimer in the00014 documentation and/or other materials provided with the distribution.00015
00016 - Neither the name of CSIRO Australia nor the names of its00017 contributors may be used to endorse or promote products derived from00018 this software without specific prior written permission.00019
00020 THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS00021 ``AS IS'' AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT00022 LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A00023 PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE ORGANISATION OR00024 CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL,00025 EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO,00026 PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR00027 PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF00028 LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING00029 NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS00030 SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.00031 */00032
00033 #ifndef __FISH_SOUND_COMMENT_H__00034 #define __FISH_SOUND_COMMENT_H__00035
00087 #include <fishsound/fishsound.h>00088
00092typedefstruct {
00094char * name;
00095
00097char * value;
00098 } FishSoundComment;
00099
00100 #ifdef __cplusplus00101 extern"C" {
00102 #endif00103
00111 constchar *
00112 fish_sound_comment_get_vendor (FishSound * fsound);
00113
00114
00121 constFishSoundComment *
00122 fish_sound_comment_first (FishSound * fsound);
00123
00131 constFishSoundComment *
00132 fish_sound_comment_next (FishSound * fsound, constFishSoundComment * comment);
00133
00143 constFishSoundComment *
00144 fish_sound_comment_first_byname (FishSound * fsound, char * name);
00145
00156 constFishSoundComment *
00157 fish_sound_comment_next_byname (FishSound * fsound,
00158 constFishSoundComment * comment);
00159
00168 int00169 fish_sound_comment_add (FishSound * fsound, FishSoundComment * comment);
00170
00180 int00181 fish_sound_comment_add_byname (FishSound * fsound, constchar * name,
00182 constchar * value);
00183
00193 int00194 fish_sound_comment_remove (FishSound * fsound, FishSoundComment * comment);
00195
00204 int00205 fish_sound_comment_remove_byname (FishSound * fsound, char * name);
00206
00207 #ifdef __cplusplus00208 }
00209 #endif00210
00211 #endif /* __FISH_SOUND_COMMENTS_H__ */
Generated on Wed Feb 3 22:16:44 2010 for libfishsound by
1.5.8
libfishsound-1.0.0/doc/libfishsound/html/constants_8h.html 0000644 0001750 0001750 00000046760 11332273474 020650 0000000 0000000
libfishsound: constants.h File Reference
00001 /*00002 Copyright (C) 2003 Commonwealth Scientific and Industrial Research00003 Organisation (CSIRO) Australia00004
00005 Redistribution and use in source and binary forms, with or without00006 modification, are permitted provided that the following conditions00007 are met:00008
00009 - Redistributions of source code must retain the above copyright00010 notice, this list of conditions and the following disclaimer.00011
00012 - Redistributions in binary form must reproduce the above copyright00013 notice, this list of conditions and the following disclaimer in the00014 documentation and/or other materials provided with the distribution.00015
00016 - Neither the name of CSIRO Australia nor the names of its00017 contributors may be used to endorse or promote products derived from00018 this software without specific prior written permission.00019
00020 THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS00021 ``AS IS'' AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT00022 LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A00023 PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE ORGANISATION OR00024 CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL,00025 EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO,00026 PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR00027 PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF00028 LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING00029 NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS00030 SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.00031 */00032
00033 #ifndef __FISH_SOUND_CONSTANTS_H__00034 #define __FISH_SOUND_CONSTANTS_H__00035
00041typedefenum_FishSoundMode {
00043FISH_SOUND_DECODE = 0x10,
00044
00046FISH_SOUND_ENCODE = 0x20
00047 } FishSoundMode;
00048
00050typedefenum_FishSoundCodecID {
00052FISH_SOUND_UNKNOWN = 0x00,
00053
00055FISH_SOUND_VORBIS = 0x01,
00056
00058FISH_SOUND_SPEEX = 0x02,
00059
00061FISH_SOUND_FLAC = 0x03
00062 } FishSoundCodecID;
00063
00065typedefenum_FishSoundStopCtl {
00067FISH_SOUND_CONTINUE = 0,
00068
00070FISH_SOUND_STOP_OK = 1,
00071
00073FISH_SOUND_STOP_ERR = -1
00074 } FishSoundStopCtl;
00075
00077typedefenum_FishSoundCommand {
00079FISH_SOUND_COMMAND_NOP = 0x0000,
00080
00082FISH_SOUND_GET_INFO = 0x1000,
00083
00085FISH_SOUND_GET_INTERLEAVE = 0x2000,
00086
00088FISH_SOUND_SET_INTERLEAVE = 0x2001,
00089
00090 FISH_SOUND_SET_ENCODE_VBR = 0x4000,
00091
00092 FISH_SOUND_COMMAND_MAX
00093 } FishSoundCommand;
00094
00096typedefenum_FishSoundError {
00098FISH_SOUND_OK = 0,
00099
00101FISH_SOUND_ERR_GENERIC = -1,
00102
00104FISH_SOUND_ERR_BAD = -2,
00105
00107FISH_SOUND_ERR_INVALID = -3,
00108
00110FISH_SOUND_ERR_OUT_OF_MEMORY = -4,
00111
00113FISH_SOUND_ERR_DISABLED = -10,
00114
00116FISH_SOUND_ERR_SHORT_IDENTIFY = -20,
00117
00119FISH_SOUND_ERR_COMMENT_INVALID = -21
00120 } FishSoundError;
00121
00122 #endif /* __FISH_SOUND_CONSTANTS_H__ */
Generated on Wed Feb 3 22:16:44 2010 for libfishsound by
1.5.8
libfishsound-1.0.0/doc/libfishsound/html/decode_8h.html 0000644 0001750 0001750 00000041534 11332273474 020051 0000000 0000000
libfishsound: decode.h File Reference
No internal buffering is done, so a complete compressed audio packet must be passed each time.
Parameters:
fsound
A FishSound* handle (created with mode FISH_SOUND_DECODE)
buf
A buffer containing a compressed audio packet
bytes
A count of bytes to decode (i.e. the length of buf)
Returns:
The number of bytes consumed
Return values:
FISH_SOUND_ERR_STOP_OK
Decoding was stopped by a FishSoundDecode* callback returning FISH_SOUND_STOP_OK before any input bytes were consumed. This will occur when PCM is decoded from previously buffered input, and stopping is immediately requested.
FISH_SOUND_ERR_STOP_ERR
Decoding was stopped by a FishSoundDecode* callback returning FISH_SOUND_STOP_ERR before any input bytes were consumed. This will occur when PCM is decoded from previously buffered input, and stopping is immediately requested.
00001 /*00002 Copyright (C) 2003 Commonwealth Scientific and Industrial Research00003 Organisation (CSIRO) Australia00004
00005 Redistribution and use in source and binary forms, with or without00006 modification, are permitted provided that the following conditions00007 are met:00008
00009 - Redistributions of source code must retain the above copyright00010 notice, this list of conditions and the following disclaimer.00011
00012 - Redistributions in binary form must reproduce the above copyright00013 notice, this list of conditions and the following disclaimer in the00014 documentation and/or other materials provided with the distribution.00015
00016 - Neither the name of CSIRO Australia nor the names of its00017 contributors may be used to endorse or promote products derived from00018 this software without specific prior written permission.00019
00020 THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS00021 ``AS IS'' AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT00022 LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A00023 PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE ORGANISATION OR00024 CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL,00025 EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO,00026 PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR00027 PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF00028 LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING00029 NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS00030 SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.00031 */00032
00033 #ifndef __FISH_SOUND_DECODE_H__00034 #define __FISH_SOUND_DECODE_H__00035
00036 #ifdef __cplusplus00037 extern"C" {
00038 #endif00039
00057typedef int (*FishSoundDecoded_Float) (FishSound * fsound, float * pcm[],
00058 long frames, void * user_data);
00059
00073typedef int (*FishSoundDecoded_FloatIlv) (FishSound * fsound, float ** pcm,
00074 long frames, void * user_data);
00075
00086 intfish_sound_set_decoded_float (FishSound * fsound,
00087 FishSoundDecoded_Float decoded,
00088 void * user_data);
00089
00100 intfish_sound_set_decoded_float_ilv (FishSound * fsound,
00101 FishSoundDecoded_FloatIlv decoded,
00102 void * user_data);
00103
00123 longfish_sound_decode (FishSound * fsound, unsignedchar * buf, long bytes);
00124
00125 #ifdef __cplusplus00126 }
00127 #endif00128
00129 #endif /* __FISH_SOUND_DECODE_H__ */
Generated on Wed Feb 3 22:16:44 2010 for libfishsound by
1.5.8
libfishsound-1.0.0/doc/libfishsound/html/deprecated_8h.html 0000644 0001750 0001750 00000027662 11332273474 020734 0000000 0000000
libfishsound: deprecated.h File Reference
Signature of a callback for libfishsound to call when it has decoded PCM audio data, and you want this provided as floats using the current interleave method as set by fish_sound_set_interleave().
Set the PCM format used by a FishSound object. The default value is non-interleaved. Prior to libfishsound 0.7.0, you would (optionally) specify whether you wanted to receive interleaved or per-channel PCM data using fish_sound_set_interleave(), the default being per-channel (non-interleaved) PCM. Whether or not your decoded callback expects interleaved or non-interleaved data is now implied by the particular fish_sound_set_decoded_TYPE() method you use to set it, such as fish_sound_set_decoded_float() or fish_sound_set_decoded_float_ilv().
Parameters:
fsound
A FishSound* handle
interleave
Whether to use interleaved PCM or not. Valid values are 0 for non-interleaved, and 1 for interleaved.
Return values:
0
Success
-1
Invalid fsound
Generated on Wed Feb 3 22:16:44 2010 for libfishsound by
1.5.8
libfishsound-1.0.0/doc/libfishsound/html/deprecated_8h-source.html 0000644 0001750 0001750 00000016767 11332273474 022236 0000000 0000000
libfishsound: deprecated.h Source File
00001 /*00002 Copyright (C) 2003 Commonwealth Scientific and Industrial Research00003 Organisation (CSIRO) Australia00004
00005 Redistribution and use in source and binary forms, with or without00006 modification, are permitted provided that the following conditions00007 are met:00008
00009 - Redistributions of source code must retain the above copyright00010 notice, this list of conditions and the following disclaimer.00011
00012 - Redistributions in binary form must reproduce the above copyright00013 notice, this list of conditions and the following disclaimer in the00014 documentation and/or other materials provided with the distribution.00015
00016 - Neither the name of CSIRO Australia nor the names of its00017 contributors may be used to endorse or promote products derived from00018 this software without specific prior written permission.00019
00020 THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS00021 ``AS IS'' AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT00022 LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A00023 PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE ORGANISATION OR00024 CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL,00025 EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO,00026 PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR00027 PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF00028 LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING00029 NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS00030 SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.00031 */00032
00033 #ifndef __FISH_SOUND_DEPRECATED_H__00034 #define __FISH_SOUND_DEPRECATED_H__00035
00040 #ifdef __cplusplus00041 extern"C" {
00042 #endif00043
00050typedefFishSoundDecoded_FloatFishSoundDecoded;
00051
00066 intfish_sound_set_decoded_callback (FishSound * fsound,
00067 FishSoundDecoded decoded,
00068 void * user_data);
00069
00089 intfish_sound_set_interleave (FishSound * fsound, int interleave);
00090
00101 longfish_sound_encode (FishSound * fsound, float ** pcm, long frames);
00102
00103 #ifdef __cplusplus00104 }
00105 #endif00106
00107 #endif /* __FISH_SOUND_DEPRECATED_H__ */
00001 /*00002 Copyright (C) 2003 Commonwealth Scientific and Industrial Research00003 Organisation (CSIRO) Australia00004
00005 Redistribution and use in source and binary forms, with or without00006 modification, are permitted provided that the following conditions00007 are met:00008
00009 - Redistributions of source code must retain the above copyright00010 notice, this list of conditions and the following disclaimer.00011
00012 - Redistributions in binary form must reproduce the above copyright00013 notice, this list of conditions and the following disclaimer in the00014 documentation and/or other materials provided with the distribution.00015
00016 - Neither the name of CSIRO Australia nor the names of its00017 contributors may be used to endorse or promote products derived from00018 this software without specific prior written permission.00019
00020 THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS00021 ``AS IS'' AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT00022 LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A00023 PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE ORGANISATION OR00024 CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL,00025 EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO,00026 PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR00027 PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF00028 LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING00029 NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS00030 SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.00031 */00032
00033 #ifndef __FISH_SOUND_ENCODE_H__00034 #define __FISH_SOUND_ENCODE_H__00035
00036 #ifdef __cplusplus00037 extern"C" {
00038 #endif00039
00055typedef int (*FishSoundEncoded) (FishSound * fsound, unsignedchar * buf,
00056 long bytes, void * user_data);
00057
00066 intfish_sound_set_encoded_callback (FishSound * fsound,
00067 FishSoundEncoded encoded,
00068 void * user_data);
00069
00079 longfish_sound_encode_float (FishSound * fsound, float * pcm[], long frames);
00080
00090 longfish_sound_encode_float_ilv (FishSound * fsound, float ** pcm,
00091 long frames);
00092
00093 #ifdef __cplusplus00094 }
00095 #endif00096
00097 #endif /* __FISH_SOUND_ENCODE_H__ */
Generated on Wed Feb 3 22:16:44 2010 for libfishsound by
1.5.8
libfishsound-1.0.0/doc/libfishsound/html/files.html 0000644 0001750 0001750 00000004671 11332273474 017332 0000000 0000000
libfishsound: File Index
All access is managed via a FishSound* handle. This is instantiated using fish_sound_new() and should be deleted with fish_sound_delete() when no longer required. If there is a discontinuity in the input data (eg. after seeking in an input file), call fish_sound_reset() to reset the internal codec state.
libfishsound provides callback based decoding: you feed it encoded audio data, and it will call your callback with decoded PCM. A more detailed explanation and a full example of decoding Ogg FLAC, Speex and Ogg Vorbis files is provided in the Decoding audio data section.
libfishsound provides callback based encoding: you feed it PCM audio, and it will call your callback with encoded audio data. A more detailed explanation and a full example of encoding Ogg FLAC, Speex and Ogg Vorbis files is provided in the Encoding audio data section.
Query the current frame number of a FishSound object.
For decoding, this is the greatest frame index that has been decoded and made available to a FishSoundDecoded callback. This function is safe to call from within a FishSoundDecoded callback, and corresponds to the frame number of the last frame in the current decoded block.
For encoding, this is the greatest frame index that has been encoded. This function is safe to call from within a FishSoundEncoded callback, and corresponds to the frame number of the last frame encoded in the current block.
Query whether a FishSound object is using interleaved PCM.
Parameters:
fsound
A FishSound* handle
Return values:
0
fsound uses non-interleaved PCM
1
fsound uses interleaved PCM
-1
Invalid fsound, or out of memory.
int fish_sound_identify
(
unsigned char *
buf,
long
bytes
)
Identify a codec based on the first few bytes of data.
Parameters:
buf
A pointer to the first few bytes of the data
bytes
The count of bytes available at buf
Return values:
FISH_SOUND_xxxxxx
FISH_SOUND_VORBIS, FISH_SOUND_SPEEX or FISH_SOUND_FLAC if buf was identified as the initial bytes of a supported codec
FISH_SOUND_UNKNOWN
if the codec could not be identified
FISH_SOUND_ERR_SHORT_IDENTIFY
if bytes is less than 8
Note:
If bytes is exactly 8, then only a weak check is performed, which is fast but may return a false positive.
If bytes is greater than 8, then a stronger check is performed in which an attempt is made to decode buf as the initial header of each supported codec. This is unlikely to return a false positive but is only useful if buf is the entire payload of a packet derived from a lower layer such as Ogg framing or UDP datagrams.
Prepare truncation details for the next block of data.
The semantics of these parameters derives directly from Ogg encapsulation of Vorbis, described here.
When decoding from Ogg, you should call this function with the granulepos and eos of the ogg_packet structure. This call should be made before passing the packet's data to fish_sound_decode(). Failure to do so may result in minor decode errors on the first and/or last packet of the stream.
When encoding into Ogg, you should call this function with the granulepos and eos that will be used for the ogg_packet structure. This call should be made before passing the block of audio data to fish_sound_encode_*(). Failure to do so may result in minor encoding errors on the first and/or last packet of the stream.
Parameters:
fsound
A FishSound* handle
next_granulepos
The "granulepos" for the next block to decode. If unknown, set next_granulepos to -1. Otherwise, next_granulepos specifies the frameno of the final frame in the block. This is authoritative, hence can be used to indicate various forms of truncation at the beginning or end of a stream. Mid-stream, a later-than-expected "granulepos" indicates that some data was missing.
next_eos
A boolean indicating whether the next data block will be the last in the stream.
00001 /*00002 Copyright (C) 2003 Commonwealth Scientific and Industrial Research00003 Organisation (CSIRO) Australia00004
00005 Redistribution and use in source and binary forms, with or without00006 modification, are permitted provided that the following conditions00007 are met:00008
00009 - Redistributions of source code must retain the above copyright00010 notice, this list of conditions and the following disclaimer.00011
00012 - Redistributions in binary form must reproduce the above copyright00013 notice, this list of conditions and the following disclaimer in the00014 documentation and/or other materials provided with the distribution.00015
00016 - Neither the name of CSIRO Australia nor the names of its00017 contributors may be used to endorse or promote products derived from00018 this software without specific prior written permission.00019
00020 THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS00021 ``AS IS'' AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT00022 LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A00023 PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE ORGANISATION OR00024 CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL,00025 EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO,00026 PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR00027 PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF00028 LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING00029 NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS00030 SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.00031 */00032
00033 #ifndef __FISH_SOUND_H__00034 #define __FISH_SOUND_H__00035
00036 #include <fishsound/constants.h>00037
00404typedefstruct {
00406int samplerate;
00407
00409int channels;
00410
00412int format;
00413 } FishSoundInfo;
00414
00418typedefstruct {
00420int format;
00421
00423constchar * name;
00424
00426constchar * extension;
00427 } FishSoundFormat;
00428
00433typedefvoid * FishSound;
00434
00435 #ifdef __cplusplus00436 extern"C" {
00437 #endif00438
00456 int00457 fish_sound_identify (unsignedchar * buf, long bytes);
00458
00465 FishSound * fish_sound_new (int mode, FishSoundInfo * fsinfo);
00466
00472 longfish_sound_flush (FishSound * fsound);
00473
00483 intfish_sound_reset (FishSound * fsound);
00484
00490 intfish_sound_delete (FishSound * fsound);
00491
00500 intfish_sound_command (FishSound * fsound, int command, void * data,
00501 int datasize);
00502
00510 intfish_sound_get_interleave (FishSound * fsound);
00511
00529 longfish_sound_get_frameno (FishSound * fsound);
00530
00544 intfish_sound_set_frameno (FishSound * fsound, long frameno);
00545
00576 intfish_sound_prepare_truncation (FishSound * fsound, long next_granulepos,
00577 int next_eos);
00578
00579 #ifdef __cplusplus00580 }
00581 #endif00582
00583 #include <fishsound/decode.h>00584 #include <fishsound/encode.h>00585 #include <fishsound/comments.h>00586
00587 #include <fishsound/deprecated.h>00588
00589 #endif /* __FISH_SOUND_H__ */
Generated on Wed Feb 3 22:16:44 2010 for libfishsound by
1.5.8
libfishsound-1.0.0/doc/libfishsound/html/functions.html 0000644 0001750 0001750 00000004636 11332273474 020241 0000000 0000000
libfishsound: Data Fields
Generated on Wed Feb 3 22:16:44 2010 for libfishsound by
1.5.8
libfishsound-1.0.0/doc/libfishsound/html/functions_vars.html 0000644 0001750 0001750 00000004473 11332273474 021273 0000000 0000000
libfishsound: Data Fields - Variables
Generated on Wed Feb 3 22:16:44 2010 for libfishsound by
1.5.8
libfishsound-1.0.0/doc/libfishsound/html/globals_enum.html 0000644 0001750 0001750 00000004236 11332273474 020674 0000000 0000000
libfishsound: Data Fields
Generated on Wed Feb 3 22:16:44 2010 for libfishsound by
1.5.8
libfishsound-1.0.0/doc/libfishsound/html/globals_eval.html 0000644 0001750 0001750 00000011216 11332273474 020653 0000000 0000000
libfishsound: Data Fields
Generated on Wed Feb 3 22:16:44 2010 for libfishsound by
1.5.8
libfishsound-1.0.0/doc/libfishsound/html/globals_func.html 0000644 0001750 0001750 00000011601 11332273474 020655 0000000 0000000
libfishsound: Data Fields
Generated on Wed Feb 3 22:16:44 2010 for libfishsound by
1.5.8
libfishsound-1.0.0/doc/libfishsound/html/globals.html 0000644 0001750 0001750 00000023612 11332273474 017647 0000000 0000000
libfishsound: Data Fields
Generated on Wed Feb 3 22:16:44 2010 for libfishsound by
1.5.8
libfishsound-1.0.0/doc/libfishsound/html/globals_type.html 0000644 0001750 0001750 00000005274 11332273474 020714 0000000 0000000
libfishsound: Data Fields
Generated on Wed Feb 3 22:16:44 2010 for libfishsound by
1.5.8
libfishsound-1.0.0/doc/libfishsound/html/group__about.html 0000644 0001750 0001750 00000007624 11332273474 020716 0000000 0000000
libfishsound: About
libfishsound provides a simple programming interface for decoding and encoding audio data using codecs from Xiph.Org.
libfishsound by itself is designed to handle raw codec streams from a lower level layer such as UDP datagrams. When these codecs are used in files, they are commonly encapsulated in Ogg to produce Ogg FLAC, Speex and Ogg Vorbis files. Example C programs using liboggz to read and write these files are provided in the libfishsound sources.
libfishsound is implemented as a wrapper around the existing codec libraries and provides a consistent, higher-level programming interface. The motivation for this is twofold: to simplify the task of developing application software that supports these codecs, and to ensure that valid codec streams are generated.
libfishsound was designed and developed by Conrad Parker on the weekend of October 18-19 2003. Previously the author had implemented Vorbis and Speex support in the following software:
Sweep, a digital audio editor with decoding and GUI control of all encoding options of Vorbis and Speex
Vorbis and Speex importers for libannodex, the basic library for reading and writing Annodex.net media files.
The implementation of libfishsound draws heavily on these sources, and in turn the original example sources of libvorbis and libvorbisenc by Monty, and libspeex by Jean-Marc Valin.
The naming of libfishsound reflects both the Xiph.Org logo and the author's reputation as a dirty, smelly old fish.
libfishsound has been designed to accomodate the various decoding and encoding styles required by a wide variety of software. However, as it is an abstraction of the underlying libvorbis, libvorbisenc and libspeex libraries, it may not be possible to implement some low-level techniques that these libraries enable, such as parallelization of Vorbis sub-block decoding. Nevertheless it is expected that libfishsound is a useful API for most software requiring Vorbis or Speex support, including most applications the author has encountered.
Much of the API design follows the style of libsndfile. The author would like to thank Erik de Castro Lopo for feedback on the design of libfishsound.
Generated on Wed Feb 3 22:16:44 2010 for libfishsound by
1.5.8
libfishsound-1.0.0/doc/libfishsound/html/group__building.html 0000644 0001750 0001750 00000004251 11332273474 021372 0000000 0000000
libfishsound: Building against libfishsound
If you are using GNU autoconf, you do not need to call pkg-config directly. Use the following macro to determine if libfishsound is available:
PKG_CHECK_MODULES(FISHSOUND, fishsound >= 0.6.0,
HAVE_FISHSOUND="yes", HAVE_FISHSOUND="no")
if test "x$HAVE_FISHSOUND" = "xyes" ; then
AC_SUBST(FISHSOUND_CFLAGS)
AC_SUBST(FISHSOUND_LIBS)
fi
(Note that if your application requires FLAC support, you should check for a version of fishsound >= 0.9.0).
If libfishsound is found, HAVE_FISHSOUND will be set to "yes", and the autoconf variables FISHSOUND_CFLAGS and FISHSOUND_LIBS will be set appropriately.
FishSound can be configured on most platforms using the GNU autoconf ./configure system described below.
For Win32, see the README.win32 section. You will need to edit win32/config.h by hand to achieve the customizations described below.
Generated on Wed Feb 3 22:16:44 2010 for libfishsound by
1.5.8
libfishsound-1.0.0/doc/libfishsound/html/group__decode.html 0000644 0001750 0001750 00000006224 11332273474 021022 0000000 0000000
libfishsound: Decoding audio data
create a FishSound* object with mode FISH_SOUND_DECODE. fish_sound_new() will return a new FishSound* object, initialised for decoding, and the FishSoundInfo structure will be cleared.
provide a FishSoundDecoded_* callback for libfishsound to call when it has decoded audio.
(optionally) specify whether you want to receive interleaved or per-channel PCM data, using a fish_sound_set_interleave(). The default is for per-channel (non-interleaved) PCM.
feed encoded audio data to libfishsound via fish_sound_decode(). libfishsound will decode the audio for you, calling the FishSoundDecoded_* callback you provided earlier each time it has a block of audio ready.
This procedure is illustrated in src/examples/fishsound-decode.c. Note that this example additionally:
uses liboggz to demultiplex audio data from an Ogg encapsulated FLAC, Speex or Vorbis stream. The step of feeding encoded data to libfishsound is done within the OggzReadPacket callback.
uses libsndfile to write the decoded audio to a WAV file.
Hence this example code demonstrates all that is needed to decode Ogg FLAC, Speex or Ogg Vorbis files:
Generated on Wed Feb 3 22:16:44 2010 for libfishsound by
1.5.8
libfishsound-1.0.0/doc/libfishsound/html/group__encode.html 0000644 0001750 0001750 00000005326 11332273474 021036 0000000 0000000
libfishsound: Encoding audio data
create a FishSound* object with mode FISH_SOUND_ENCODE, and with a FishSoundInfo structure filled in with the required encoding parameters. fish_sound_new() will return a new FishSound* object initialised for encoding.
provide a FishSoundEncoded callback for libfishsound to call when it has a block of encoded audio
feed raw PCM audio data to libfishsound via fish_sound_encode_*(). libfishsound will encode the audio for you, calling the FishSoundEncoded callback you provided earlier each time it has a block of encoded audio ready.
Generated on Wed Feb 3 22:16:44 2010 for libfishsound by
1.5.8
libfishsound-1.0.0/doc/libfishsound/html/group__win32.html 0000644 0001750 0001750 00000002324 11332273474 020536 0000000 0000000
libfishsound: Building on Win32
Generated on Wed Feb 3 22:16:44 2010 for libfishsound by
1.5.8
libfishsound-1.0.0/doc/libfishsound/html/index.html 0000644 0001750 0001750 00000006625 11332273473 017337 0000000 0000000
libfishsound: Main Page
This is the documentation for the FishSound C API. FishSound provides a simple programming interface for decoding and encoding audio data using Xiph.Org codecs (FLAC, Speex and Vorbis).
libfishsound by itself is designed to handle raw codec streams from a lower level layer such as UDP datagrams. When these codecs are used in files, they are commonly encapsulated in Ogg to produce Ogg FLAC, Speex and Ogg Vorbis files. Example C programs using liboggz to read and write these files are provided in the libfishsound sources.
For more information on the design and history of libfishsound, see the About section of this documentation, and the libfishsound homepage.
libfishsound is provided under the following BSD-style open source license:
Generated on Wed Feb 3 22:16:43 2010 for libfishsound by
1.5.8
libfishsound-1.0.0/doc/libfishsound/html/modules.html 0000644 0001750 0001750 00000003015 11332273474 017667 0000000 0000000
libfishsound: Module Index
------------------------------------------------------------------------
libfishsound 0.9.0: Automatic configuration OK.
General configuration:
Experimental code: ........... no
Decoding support: ............ yes
Encoding support: ............ yes
Library configuration (./src/libfishsound):
FLAC support: ................ yes
Speex support: ............... yes (1.1.x)
Vorbis support: .............. yes
Example programs (./src/examples):
fishsound-identify fishsound-decode fishsound-encode
Installation paths:
libfishsound: ................ /usr/local/lib
C header files: .............. /usr/local/include/fishsound
Documentation: ............... /usr/local/share/doc/libfishsound
Building:
Type 'make' to compile libfishsound.
Type 'make install' to install libfishsound.
Type 'make check' to run test suite (Valgrind testing not enabled)
Example programs will be built but not installed.
------------------------------------------------------------------------
*/
/** \defgroup install Installation
* \section install INSTALL
*
* \include INSTALL
*/
/** \defgroup win32 Building on Win32
* \section win32 README.Win32
*
* \include README.win32
*/
/** \defgroup building Building against libfishsound
*
*
* \section autoconf Using GNU autoconf
*
* If you are using GNU autoconf, you do not need to call pkg-config
* directly. Use the following macro to determine if libfishsound is
* available:
*
PKG_CHECK_MODULES(FISHSOUND, fishsound >= 0.6.0,
HAVE_FISHSOUND="yes", HAVE_FISHSOUND="no")
if test "x$HAVE_FISHSOUND" = "xyes" ; then
AC_SUBST(FISHSOUND_CFLAGS)
AC_SUBST(FISHSOUND_LIBS)
fi
* (Note that if your application requires FLAC support, you should check
* for a version of fishsound >= 0.9.0).
*
* If libfishsound is found, HAVE_FISHSOUND will be set to "yes", and
* the autoconf variables FISHSOUND_CFLAGS and FISHSOUND_LIBS will
* be set appropriately.
*
* \section pkg-config Determining compiler options with pkg-config
*
* If you are not using GNU autoconf in your project, you can use the
* pkg-config tool directly to determine the correct compiler options.
*
*
*/
/** \file
* The libfishsound C API.
*
* \section general General usage
*
* All access is managed via a FishSound* handle. This is instantiated
* using fish_sound_new() and should be deleted with fish_sound_delete()
* when no longer required. If there is a discontinuity in the input
* data (eg. after seeking in an input file), call fish_sound_reset() to
* reset the internal codec state.
*
* \section decoding Decoding
*
* libfishsound provides callback based decoding: you feed it encoded audio
* data, and it will call your callback with decoded PCM. A more detailed
* explanation and a full example of decoding Ogg FLAC, Speex and Ogg Vorbis
* files is provided in the \link decode Decoding audio data \endlink section.
*
* \section encoding Encoding
*
* libfishsound provides callback based encoding: you feed it PCM audio,
* and it will call your callback with encoded audio data. A more detailed
* explanation and a full example of encoding Ogg FLAC, Speex and Ogg Vorbis
* files is provided in the \link encode Encoding audio data \endlink section.
*/
/** \defgroup decode Decoding audio data
*
* To decode audio data using libfishsound:
*
* - create a FishSound* object with mode FISH_SOUND_DECODE. fish_sound_new()
* will return a new FishSound* object, initialised for decoding, and the
* FishSoundInfo structure will be cleared.
* - provide a FishSoundDecoded_* callback for libfishsound to call when it has
* decoded audio.
* - (optionally) specify whether you want to receive interleaved or
* per-channel PCM data, using a fish_sound_set_interleave().
* The default is for per-channel (non-interleaved) PCM.
* - feed encoded audio data to libfishsound via fish_sound_decode().
* libfishsound will decode the audio for you, calling the FishSoundDecoded_*
* callback you provided earlier each time it has a block of audio ready.
* - when finished, call fish_sound_delete().
*
* This procedure is illustrated in src/examples/fishsound-decode.c.
* Note that this example additionally:
* - uses liboggz to
* demultiplex audio data from an Ogg encapsulated FLAC, Speex or Vorbis
* stream. The step of feeding encoded data to libfishsound is done within
* the OggzReadPacket callback.
* - uses libsndfile to
* write the decoded audio to a WAV file.
*
* Hence this example code demonstrates all that is needed to decode
* Ogg FLAC, Speex or Ogg Vorbis files:
*
* \include fishsound-decode.c
*/
/** \defgroup encode Encoding audio data
*
* To encode audio data using libfishsound:
*
* - create a FishSound* object with mode FISH_SOUND_ENCODE, and with a
* FishSoundInfo structure filled in with the required encoding parameters.
* fish_sound_new() will return a new FishSound* object initialised for
* encoding.
* - provide a FishSoundEncoded callback for libfishsound to call when it
* has a block of encoded audio
* - feed raw PCM audio data to libfishsound via fish_sound_encode_*().
* libfishsound will encode the audio for you, calling the FishSoundEncoded
* callback you provided earlier each time it has a block of encoded audio
* ready.
* - when finished, call fish_sound_delete().
*
* This procedure is illustrated in src/examples/fishsound-encode.c.
* Note that this example additionally:
* - uses libsndfile to
* read input from a PCM audio file (WAV, AIFF, etc.)
* - uses liboggz to
* encapsulate the encoded FLAC, Speex or Vorbis data in an Ogg stream.
*
* Hence this example code demonstrates all that is needed to encode
* Ogg FLAC, Speex and Ogg Vorbis files:
*
* \include fishsound-encode.c
*/
/**
* Info about a particular encoder/decoder instance
*/
typedef struct {
/** Sample rate of audio data in Hz */
int samplerate;
/** Count of channels */
int channels;
/** FISH_SOUND_VORBIS, FISH_SOUND_SPEEX, FISH_SOUND_FLAC etc. */
int format;
} FishSoundInfo;
/**
* Info about a particular sound format
*/
typedef struct {
/** FISH_SOUND_VORBIS, FISH_SOUND_SPEEX, FISH_SOUND_FLAC etc. */
int format;
/** Printable name */
const char * name;
/** Commonly used file extension */
const char * extension;
} FishSoundFormat;
/**
* An opaque handle to a FishSound. This is returned by fishsound_new()
* and is passed to all other fish_sound_*() functions.
*/
typedef void * FishSound;
#ifdef __cplusplus
extern "C" {
#endif
/**
* Identify a codec based on the first few bytes of data.
* \param buf A pointer to the first few bytes of the data
* \param bytes The count of bytes available at buf
* \retval FISH_SOUND_xxxxxx FISH_SOUND_VORBIS, FISH_SOUND_SPEEX or
* FISH_SOUND_FLAC if \a buf was identified as the initial bytes of a
* supported codec
* \retval FISH_SOUND_UNKNOWN if the codec could not be identified
* \retval FISH_SOUND_ERR_SHORT_IDENTIFY if \a bytes is less than 8
* \note If \a bytes is exactly 8, then only a weak check is performed,
* which is fast but may return a false positive.
* \note If \a bytes is greater than 8, then a stronger check is performed
* in which an attempt is made to decode \a buf as the initial header of
* each supported codec. This is unlikely to return a false positive but
* is only useful if \a buf is the entire payload of a packet derived from
* a lower layer such as Ogg framing or UDP datagrams.
*/
int
fish_sound_identify (unsigned char * buf, long bytes);
/**
* Instantiate a new FishSound* handle
* \param mode FISH_SOUND_DECODE or FISH_SOUND_ENCODE
* \param fsinfo Encoder configuration, may be NULL for FISH_SOUND_DECODE
* \returns A new FishSound* handle, or NULL on error
*/
FishSound * fish_sound_new (int mode, FishSoundInfo * fsinfo);
/**
* Flush any internally buffered data, forcing encode
* \param fsound A FishSound* handle
* \returns 0 on success, -1 on failure
*/
long fish_sound_flush (FishSound * fsound);
/**
* Reset the codec state of a FishSound object.
*
* When decoding from a seekable file, fish_sound_reset() should be called
* after any seek operations. See also fish_sound_set_frameno().
*
* \param fsound A FishSound* handle
* \returns 0 on success, -1 on failure
*/
int fish_sound_reset (FishSound * fsound);
/**
* Delete a FishSound object
* \param fsound A FishSound* handle
* \returns 0 on success, -1 on failure
*/
int fish_sound_delete (FishSound * fsound);
/**
* Command interface
* \param fsound A FishSound* handle
* \param command The command action
* \param data Command data
* \param datasize Size of the data in bytes
* \returns 0 on success, -1 on failure
*/
int fish_sound_command (FishSound * fsound, int command, void * data,
int datasize);
/**
* Query whether a FishSound object is using interleaved PCM
* \param fsound A FishSound* handle
* \retval 0 \a fsound uses non-interleaved PCM
* \retval 1 \a fsound uses interleaved PCM
* \retval -1 Invalid \a fsound, or out of memory.
*/
int fish_sound_get_interleave (FishSound * fsound);
/**
* Query the current frame number of a FishSound object.
*
* For decoding, this is the greatest frame index that has been decoded and
* made available to a FishSoundDecoded callback. This function is safe to
* call from within a FishSoundDecoded callback, and corresponds to the frame
* number of the last frame in the current decoded block.
*
* For encoding, this is the greatest frame index that has been encoded. This
* function is safe to call from within a FishSoundEncoded callback, and
* corresponds to the frame number of the last frame encoded in the current
* block.
*
* \param fsound A FishSound* handle
* \returns The current frame number
* \retval -1 Invalid \a fsound
*/
long fish_sound_get_frameno (FishSound * fsound);
/**
* Set the current frame number of a FishSound object.
*
* When decoding from a seekable file, fish_sound_set_frameno() should be
* called after any seek operations, otherwise the value returned by
* fish_sound_get_frameno() will simply continue to increment. See also
* fish_sound_reset().
*
* \param fsound A FishSound* handle
* \param frameno The current frame number.
* \retval 0 Success
* \retval -1 Invalid \a fsound
*/
int fish_sound_set_frameno (FishSound * fsound, long frameno);
/**
* Prepare truncation details for the next block of data.
* The semantics of these parameters derives directly from Ogg encapsulation
* of Vorbis, described
* here.
*
* When decoding from Ogg, you should call this function with the \a granulepos
* and \a eos of the \a ogg_packet structure. This call should be made before
* passing the packet's data to fish_sound_decode(). Failure to do so may
* result in minor decode errors on the first and/or last packet of the stream.
*
* When encoding into Ogg, you should call this function with the \a granulepos
* and \a eos that will be used for the \a ogg_packet structure. This call
* should be made before passing the block of audio data to
* fish_sound_encode_*(). Failure to do so may result in minor encoding errors
* on the first and/or last packet of the stream.
*
* \param fsound A FishSound* handle
* \param next_granulepos The "granulepos" for the next block to decode.
* If unknown, set \a next_granulepos to -1. Otherwise,
* \a next_granulepos specifies the frameno of the final frame in the
* block. This is authoritative, hence can be used to indicate
* various forms of truncation at the beginning or end of a stream.
* Mid-stream, a later-than-expected "granulepos" indicates that some
* data was missing.
* \param next_eos A boolean indicating whether the next data block will be
* the last in the stream.
* \retval 0 Success
* \retval -1 Invalid \a fsound
*/
int fish_sound_prepare_truncation (FishSound * fsound, long next_granulepos,
int next_eos);
#ifdef __cplusplus
}
#endif
#include
#include
#include
#include
#endif /* __FISH_SOUND_H__ */
libfishsound-1.0.0/include/fishsound/decode.h 0000644 0001750 0001750 00000012714 11163316023 016144 0000000 0000000 /*
Copyright (C) 2003 Commonwealth Scientific and Industrial Research
Organisation (CSIRO) Australia
Redistribution and use in source and binary forms, with or without
modification, are permitted provided that the following conditions
are met:
- Redistributions of source code must retain the above copyright
notice, this list of conditions and the following disclaimer.
- Redistributions in binary form must reproduce the above copyright
notice, this list of conditions and the following disclaimer in the
documentation and/or other materials provided with the distribution.
- Neither the name of CSIRO Australia nor the names of its
contributors may be used to endorse or promote products derived from
this software without specific prior written permission.
THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS
``AS IS'' AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT
LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A
PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE ORGANISATION OR
CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL,
EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO,
PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR
PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF
LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING
NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS
SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
*/
#ifndef __FISH_SOUND_DECODE_H__
#define __FISH_SOUND_DECODE_H__
#ifdef __cplusplus
extern "C" {
#endif
/** \file
* Decode functions and callback prototypes
*/
/**
* Signature of a callback for libfishsound to call when it has decoded
* PCM audio data, and you want this provided as non-interleaved floats.
* \param fsound The FishSound* handle
* \param pcm The decoded audio
* \param frames The count of frames decoded
* \param user_data Arbitrary user data
* \retval FISH_SOUND_CONTINUE Continue decoding
* \retval FISH_SOUND_STOP_OK Stop decoding immediately and
* return control to the fish_sound_decode() caller
* \retval FISH_SOUND_STOP_ERR Stop decoding immediately, purge buffered
* data, and return control to the fish_sound_decode() caller
*/
typedef int (*FishSoundDecoded_Float) (FishSound * fsound, float * pcm[],
long frames, void * user_data);
/**
* Signature of a callback for libfishsound to call when it has decoded
* PCM audio data, and you want this provided as interleaved floats.
* \param fsound The FishSound* handle
* \param pcm The decoded audio
* \param frames The count of frames decoded
* \param user_data Arbitrary user data
* \retval FISH_SOUND_CONTINUE Continue decoding
* \retval FISH_SOUND_STOP_OK Stop decoding immediately and
* return control to the fish_sound_decode() caller
* \retval FISH_SOUND_STOP_ERR Stop decoding immediately, purge buffered
* data, and return control to the fish_sound_decode() caller
*/
typedef int (*FishSoundDecoded_FloatIlv) (FishSound * fsound, float ** pcm,
long frames, void * user_data);
/**
* Set the callback for libfishsound to call when it has a block of decoded
* PCM audio ready, and you want this provided as non-interleaved floats.
* \param fsound A FishSound* handle (created with mode FISH_SOUND_DECODE)
* \param decoded The callback to call
* \param user_data Arbitrary user data to pass to the callback
* \retval 0 Success
* \retval FISH_SOUND_ERR_BAD Not a valid FishSound* handle
* \retval FISH_SOUND_ERR_OUT_OF_MEMORY Out of memory
*/
int fish_sound_set_decoded_float (FishSound * fsound,
FishSoundDecoded_Float decoded,
void * user_data);
/**
* Set the callback for libfishsound to call when it has a block of decoded
* PCM audio ready, and you want this provided as interleaved floats.
* \param fsound A FishSound* handle (created with mode FISH_SOUND_DECODE)
* \param decoded The callback to call
* \param user_data Arbitrary user data to pass to the callback
* \retval 0 Success
* \retval FISH_SOUND_ERR_BAD Not a valid FishSound* handle
* \retval FISH_SOUND_ERR_OUT_OF_MEMORY Out of memory
*/
int fish_sound_set_decoded_float_ilv (FishSound * fsound,
FishSoundDecoded_FloatIlv decoded,
void * user_data);
/**
* Decode a block of compressed data.
* No internal buffering is done, so a complete compressed audio packet
* must be passed each time.
* \param fsound A FishSound* handle (created with mode FISH_SOUND_DECODE)
* \param buf A buffer containing a compressed audio packet
* \param bytes A count of bytes to decode (i.e. the length of buf)
* \returns The number of bytes consumed
* \retval FISH_SOUND_ERR_STOP_OK Decoding was stopped by a FishSoundDecode*
* callback returning FISH_SOUND_STOP_OK before any input bytes were consumed.
* This will occur when PCM is decoded from previously buffered input, and
* stopping is immediately requested.
* \retval FISH_SOUND_ERR_STOP_ERR Decoding was stopped by a FishSoundDecode*
* callback returning FISH_SOUND_STOP_ERR before any input bytes were consumed.
* This will occur when PCM is decoded from previously buffered input, and
* stopping is immediately requested.
* \retval FISH_SOUND_ERR_BAD Not a valid FishSound* handle
* \retval FISH_SOUND_ERR_OUT_OF_MEMORY Out of memory
*/
long fish_sound_decode (FishSound * fsound, unsigned char * buf, long bytes);
#ifdef __cplusplus
}
#endif
#endif /* __FISH_SOUND_DECODE_H__ */
libfishsound-1.0.0/include/fishsound/encode.h 0000644 0001750 0001750 00000007106 11163316023 016155 0000000 0000000 /*
Copyright (C) 2003 Commonwealth Scientific and Industrial Research
Organisation (CSIRO) Australia
Redistribution and use in source and binary forms, with or without
modification, are permitted provided that the following conditions
are met:
- Redistributions of source code must retain the above copyright
notice, this list of conditions and the following disclaimer.
- Redistributions in binary form must reproduce the above copyright
notice, this list of conditions and the following disclaimer in the
documentation and/or other materials provided with the distribution.
- Neither the name of CSIRO Australia nor the names of its
contributors may be used to endorse or promote products derived from
this software without specific prior written permission.
THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS
``AS IS'' AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT
LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A
PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE ORGANISATION OR
CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL,
EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO,
PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR
PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF
LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING
NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS
SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
*/
#ifndef __FISH_SOUND_ENCODE_H__
#define __FISH_SOUND_ENCODE_H__
#ifdef __cplusplus
extern "C" {
#endif
/** \file
* Encode functions and callback prototypes
*/
/**
* Signature of a callback for libfishsound to call when it has encoded
* data.
* \param fsound The FishSound* handle
* \param buf The encoded data
* \param bytes The count of bytes encoded
* \param user_data Arbitrary user data
* \retval 0 to continue
* \retval non-zero to stop encoding immediately and
* return control to the fish_sound_encode() caller
*/
typedef int (*FishSoundEncoded) (FishSound * fsound, unsigned char * buf,
long bytes, void * user_data);
/**
* Set the callback for libfishsound to call when it has a block of
* encoded data ready
* \param fsound A FishSound* handle (created with mode FISH_SOUND_ENCODE)
* \param encoded The callback to call
* \param user_data Arbitrary user data to pass to the callback
* \returns 0 on success, -1 on failure
*/
int fish_sound_set_encoded_callback (FishSound * fsound,
FishSoundEncoded encoded,
void * user_data);
/**
* Encode a block of PCM audio given as non-interleaved floats.
* \param fsound A FishSound* handle (created with mode FISH_SOUND_ENCODE)
* \param pcm The audio data to encode
* \param frames A count of frames to encode
* \returns The number of frames encoded
* \note For multichannel audio, the audio data is interpreted according
* to the current PCM style
*/
long fish_sound_encode_float (FishSound * fsound, float * pcm[], long frames);
/**
* Encode a block of audio given as interleaved floats.
* \param fsound A FishSound* handle (created with mode FISH_SOUND_ENCODE)
* \param pcm The audio data to encode
* \param frames A count of frames to encode
* \returns The number of frames encoded
* \note For multichannel audio, the audio data is interpreted according
* to the current PCM style
*/
long fish_sound_encode_float_ilv (FishSound * fsound, float ** pcm,
long frames);
#ifdef __cplusplus
}
#endif
#endif /* __FISH_SOUND_ENCODE_H__ */
libfishsound-1.0.0/include/fishsound/comments.h 0000644 0001750 0001750 00000017444 11021125460 016547 0000000 0000000 /*
Copyright (C) 2003 Commonwealth Scientific and Industrial Research
Organisation (CSIRO) Australia
Redistribution and use in source and binary forms, with or without
modification, are permitted provided that the following conditions
are met:
- Redistributions of source code must retain the above copyright
notice, this list of conditions and the following disclaimer.
- Redistributions in binary form must reproduce the above copyright
notice, this list of conditions and the following disclaimer in the
documentation and/or other materials provided with the distribution.
- Neither the name of CSIRO Australia nor the names of its
contributors may be used to endorse or promote products derived from
this software without specific prior written permission.
THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS
``AS IS'' AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT
LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A
PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE ORGANISATION OR
CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL,
EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO,
PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR
PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF
LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING
NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS
SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
*/
#ifndef __FISH_SOUND_COMMENT_H__
#define __FISH_SOUND_COMMENT_H__
/** \file
* Encoding and decoding of comments.
*
* Vorbis and Speex bitstreams
* use a comment format called "Vorbiscomment", defined
* here.
* Many standard comment names (such as TITLE, COPYRIGHT and GENRE) are
* defined in that document.
*
* The following general features of Vorbiscomment are relevant to this API:
* - Each stream has one comment packet, which occurs before any encoded
* audio data in the stream.
* - When encoding, FishSound will generate the comment block and pass it
* to the encoded() callback in sequence, just like any other packet.
* Hence, all comments must be set before any call to fish_sound_encode_*().
* - When decoding, FishSound will decode the comment block before calling
* the first decoded() callback. Hence, retrieving comment data is possible
* from as soon as the decoded() callback is first called.
*
* Each comment block contains one Vendor string, which can be retrieved
* with fish_sound_comment_get_vendor(). When encoding, this string is
* effectively fixed by the codec libraries; it cannot be set by the
* application.
*
* The rest of a comment block consists of \a name = \a value pairs, with
* the following restrictions:
* - Both the \a name and \a value must be non-empty
* - The \a name is case-insensitive and must consist of ASCII within the
* range 0x20 to 0x7D inclusive, 0x3D ('=') excluded.
* - The \a name is not unique; multiple entries may exist with equivalent
* \a name within a Vorbiscomment block.
* - The \a value may be any UTF-8 string.
*
* \section comments_get Retrieving comments
*
* FishSound contains API methods to iterate through all comments associated
* with a FishSound* handle (fish_sound_comment_first() and
* fish_sound_comment_next(), and to iterate through comments matching a
* particular name (fish_sound_comment_first_byname() and
* fish_sound_comment_next_byname()). Given that multiple comments may exist
* with the same \a name, you should not use
* fish_sound_comment_first_byname() as a simple "get" function.
*
* \section comments_set Encoding comments
*
* For encoding, FishSound contains API methods for adding comments
* (fish_sound_comment_add() and fish_sound_comment_add_byname()
* and for removing comments
* (fish_sound_comment_remove() and fish_sound_comment_remove_byname()).
*/
#include
/**
* A comment.
*/
typedef struct {
/** The name of the comment, eg. "AUTHOR" */
char * name;
/** The value of the comment, as UTF-8 */
char * value;
} FishSoundComment;
#ifdef __cplusplus
extern "C" {
#endif
/**
* Retrieve the vendor string.
* \param fsound A FishSound* handle
* \returns A read-only copy of the vendor string
* \retval NULL No vendor string is associated with \a fsound,
* or \a fsound is NULL.
*/
const char *
fish_sound_comment_get_vendor (FishSound * fsound);
/**
* Retrieve the first comment.
* \param fsound A FishSound* handle
* \returns A read-only copy of the first comment, or NULL if no comments
* exist for this FishSound* object.
*/
const FishSoundComment *
fish_sound_comment_first (FishSound * fsound);
/**
* Retrieve the next comment.
* \param fsound A FishSound* handle
* \param comment The previous comment.
* \returns A read-only copy of the comment immediately following the given
* comment.
*/
const FishSoundComment *
fish_sound_comment_next (FishSound * fsound, const FishSoundComment * comment);
/**
* Retrieve the first comment with a given name.
* \param fsound A FishSound* handle
* \param name the name of the comment to retrieve.
* \returns A read-only copy of the first comment matching the given \a name.
* \retval NULL no match was found.
* \note If \a name is NULL, the behaviour is the same as for
* fish_sound_comment_first()
*/
const FishSoundComment *
fish_sound_comment_first_byname (FishSound * fsound, char * name);
/**
* Retrieve the next comment following and with the same name as a given
* comment.
* \param fsound A FishSound* handle
* \param comment A comment
* \returns A read-only copy of the next comment with the same name as
* \a comment.
* \retval NULL no further comments with the same name exist for
* this FishSound* object.
*/
const FishSoundComment *
fish_sound_comment_next_byname (FishSound * fsound,
const FishSoundComment * comment);
/**
* Add a comment
* \param fsound A FishSound* handle (created with mode FISH_SOUND_ENCODE)
* \param comment The comment to add
* \retval 0 Success
* \retval FISH_SOUND_ERR_BAD \a fsound is not a valid FishSound* handle
* \retval FISH_SOUND_ERR_INVALID Operation not suitable for this FishSound
*/
int
fish_sound_comment_add (FishSound * fsound, FishSoundComment * comment);
/**
* Add a comment by name and value.
* \param fsound A FishSound* handle (created with mode FISH_SOUND_ENCODE)
* \param name The name of the comment to add
* \param value The contents of the comment to add
* \retval 0 Success
* \retval FISH_SOUND_ERR_BAD \a fsound is not a valid FishSound* handle
* \retval FISH_SOUND_ERR_INVALID Operation not suitable for this FishSound
*/
int
fish_sound_comment_add_byname (FishSound * fsound, const char * name,
const char * value);
/**
* Remove a comment
* \param fsound A FishSound* handle (created with FISH_SOUND_ENCODE)
* \param comment The comment to remove.
* \retval 1 Success: comment removed
* \retval 0 No-op: comment not found, nothing to remove
* \retval FISH_SOUND_ERR_BAD \a fsound is not a valid FishSound* handle
* \retval FISH_SOUND_ERR_INVALID Operation not suitable for this FishSound
*/
int
fish_sound_comment_remove (FishSound * fsound, FishSoundComment * comment);
/**
* Remove all comments with a given name.
* \param fsound A FishSound* handle (created with FISH_SOUND_ENCODE)
* \param name The name of the comments to remove
* \retval ">= 0" The number of comments removed
* \retval FISH_SOUND_ERR_BAD \a fsound is not a valid FishSound* handle
* \retval FISH_SOUND_ERR_INVALID Operation not suitable for this FishSound
*/
int
fish_sound_comment_remove_byname (FishSound * fsound, char * name);
#ifdef __cplusplus
}
#endif
#endif /* __FISH_SOUND_COMMENTS_H__ */
libfishsound-1.0.0/include/fishsound/constants.h 0000644 0001750 0001750 00000007434 11163316023 016740 0000000 0000000 /*
Copyright (C) 2003 Commonwealth Scientific and Industrial Research
Organisation (CSIRO) Australia
Redistribution and use in source and binary forms, with or without
modification, are permitted provided that the following conditions
are met:
- Redistributions of source code must retain the above copyright
notice, this list of conditions and the following disclaimer.
- Redistributions in binary form must reproduce the above copyright
notice, this list of conditions and the following disclaimer in the
documentation and/or other materials provided with the distribution.
- Neither the name of CSIRO Australia nor the names of its
contributors may be used to endorse or promote products derived from
this software without specific prior written permission.
THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS
``AS IS'' AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT
LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A
PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE ORGANISATION OR
CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL,
EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO,
PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR
PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF
LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING
NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS
SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
*/
#ifndef __FISH_SOUND_CONSTANTS_H__
#define __FISH_SOUND_CONSTANTS_H__
/** \file
* Constants used by libfishsound
*/
/** Mode of operation (encode or decode) */
typedef enum _FishSoundMode {
/** Decode */
FISH_SOUND_DECODE = 0x10,
/** Encode */
FISH_SOUND_ENCODE = 0x20
} FishSoundMode;
/** Identifiers for supported codecs */
typedef enum _FishSoundCodecID {
/** Unknown */
FISH_SOUND_UNKNOWN = 0x00,
/** Vorbis */
FISH_SOUND_VORBIS = 0x01,
/** Speex */
FISH_SOUND_SPEEX = 0x02,
/** Flac */
FISH_SOUND_FLAC = 0x03
} FishSoundCodecID;
/** Decode callback return values */
typedef enum _FishSoundStopCtl {
/** Continue calling decode callbacks */
FISH_SOUND_CONTINUE = 0,
/** Stop calling callbacks, but retain buffered data */
FISH_SOUND_STOP_OK = 1,
/** Stop calling callbacks, and purge buffered data */
FISH_SOUND_STOP_ERR = -1
} FishSoundStopCtl;
/** Command codes */
typedef enum _FishSoundCommand {
/** No operation */
FISH_SOUND_COMMAND_NOP = 0x0000,
/** Retrieve the FishSoundInfo */
FISH_SOUND_GET_INFO = 0x1000,
/** Query if multichannel audio should be interpreted as interleaved */
FISH_SOUND_GET_INTERLEAVE = 0x2000,
/** Set to 1 to interleave, 0 to non-interleave */
FISH_SOUND_SET_INTERLEAVE = 0x2001,
FISH_SOUND_SET_ENCODE_VBR = 0x4000,
FISH_SOUND_COMMAND_MAX
} FishSoundCommand;
/** Error values */
typedef enum _FishSoundError {
/** No error */
FISH_SOUND_OK = 0,
/** generic error */
FISH_SOUND_ERR_GENERIC = -1,
/** Not a valid FishSound* handle */
FISH_SOUND_ERR_BAD = -2,
/** The requested operation is not suitable for this FishSound* handle */
FISH_SOUND_ERR_INVALID = -3,
/** Out of memory */
FISH_SOUND_ERR_OUT_OF_MEMORY = -4,
/** Functionality disabled at build time */
FISH_SOUND_ERR_DISABLED = -10,
/** Too few bytes passed to fish_sound_identify() */
FISH_SOUND_ERR_SHORT_IDENTIFY = -20,
/** Comment violates VorbisComment restrictions */
FISH_SOUND_ERR_COMMENT_INVALID = -21
} FishSoundError;
#endif /* __FISH_SOUND_CONSTANTS_H__ */
libfishsound-1.0.0/include/fishsound/deprecated.h 0000644 0001750 0001750 00000010210 11163316023 017006 0000000 0000000 /*
Copyright (C) 2003 Commonwealth Scientific and Industrial Research
Organisation (CSIRO) Australia
Redistribution and use in source and binary forms, with or without
modification, are permitted provided that the following conditions
are met:
- Redistributions of source code must retain the above copyright
notice, this list of conditions and the following disclaimer.
- Redistributions in binary form must reproduce the above copyright
notice, this list of conditions and the following disclaimer in the
documentation and/or other materials provided with the distribution.
- Neither the name of CSIRO Australia nor the names of its
contributors may be used to endorse or promote products derived from
this software without specific prior written permission.
THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS
``AS IS'' AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT
LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A
PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE ORGANISATION OR
CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL,
EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO,
PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR
PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF
LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING
NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS
SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
*/
#ifndef __FISH_SOUND_DEPRECATED_H__
#define __FISH_SOUND_DEPRECATED_H__
/** \file
* Deprecated interfaces
*/
#ifdef __cplusplus
extern "C" {
#endif
/**
* DEPRECATED TYPE.
* Signature of a callback for libfishsound to call when it has decoded
* PCM audio data, and you want this provided as floats using the current
* interleave method as set by fish_sound_set_interleave().
*/
typedef FishSoundDecoded_Float FishSoundDecoded;
/**
* DEPRECATED FUNCTION.
* Set the callback for libfishsound to call when it has a block of decoded
* PCM audio ready, and you want this provided as floats using the current
* interleave method as set by fish_sound_set_interleave().
* This function, and fish_sound_set_interleave(), have been superceded by
* the typesafe fish_sound_set_decoded_TYPE() callbacks, such as
* fish_sound_set_decoded_float() or fish_sound_set_decoded_float_ilv().
*
* \param fsound A FishSound* handle (created with mode FISH_SOUND_DECODE)
* \param decoded The callback to call
* \param user_data Arbitrary user data to pass to the callback
* \returns 0 on success, -1 on failure
*/
int fish_sound_set_decoded_callback (FishSound * fsound,
FishSoundDecoded decoded,
void * user_data);
/**
* DEPRECATED FUNCTION.
* Set the PCM format used by a FishSound object. The default value is
* non-interleaved.
* Prior to libfishsound 0.7.0, you would (optionally) specify whether you
* wanted to receive interleaved or per-channel PCM data using
* fish_sound_set_interleave(), the default being per-channel
* (non-interleaved) PCM.
* Whether or not your decoded callback expects interleaved or
* non-interleaved data is now implied by the particular
* fish_sound_set_decoded_TYPE() method you use to set it, such as
* fish_sound_set_decoded_float() or fish_sound_set_decoded_float_ilv().
*
* \param fsound A FishSound* handle
* \param interleave Whether to use interleaved PCM or not. Valid values are
* 0 for non-interleaved, and 1 for interleaved.
* \retval 0 Success
* \retval -1 Invalid \a fsound
*/
int fish_sound_set_interleave (FishSound * fsound, int interleave);
/**
* DEPRECATED FUNCTION.
* Encode a block of audio
* \param fsound A FishSound* handle (created with mode FISH_SOUND_ENCODE)
* \param pcm The audio data to encode
* \param frames A count of frames to encode
* \returns The number of frames encoded
* \note For multichannel audio, the audio data is interpreted according
* to the current PCM style
*/
long fish_sound_encode (FishSound * fsound, float ** pcm, long frames);
#ifdef __cplusplus
}
#endif
#endif /* __FISH_SOUND_DEPRECATED_H__ */
libfishsound-1.0.0/include/fishsound/Makefile.am 0000644 0001750 0001750 00000000327 11163316023 016601 0000000 0000000 ## Process this file with automake to produce Makefile.in
# Include files to install
includedir = $(prefix)/include/fishsound
include_HEADERS = fishsound.h decode.h encode.h comments.h constants.h \
deprecated.h
libfishsound-1.0.0/include/fishsound/Makefile.in 0000644 0001750 0001750 00000030605 11332275622 016623 0000000 0000000 # Makefile.in generated by automake 1.10.2 from Makefile.am.
# @configure_input@
# Copyright (C) 1994, 1995, 1996, 1997, 1998, 1999, 2000, 2001, 2002,
# 2003, 2004, 2005, 2006, 2007, 2008 Free Software Foundation, Inc.
# This Makefile.in is free software; the Free Software Foundation
# gives unlimited permission to copy and/or distribute it,
# with or without modifications, as long as this notice is preserved.
# This program is distributed in the hope that it will be useful,
# but WITHOUT ANY WARRANTY, to the extent permitted by law; without
# even the implied warranty of MERCHANTABILITY or FITNESS FOR A
# PARTICULAR PURPOSE.
@SET_MAKE@
VPATH = @srcdir@
pkgdatadir = $(datadir)/@PACKAGE@
pkglibdir = $(libdir)/@PACKAGE@
pkgincludedir = $(includedir)/@PACKAGE@
am__cd = CDPATH="$${ZSH_VERSION+.}$(PATH_SEPARATOR)" && cd
install_sh_DATA = $(install_sh) -c -m 644
install_sh_PROGRAM = $(install_sh) -c
install_sh_SCRIPT = $(install_sh) -c
INSTALL_HEADER = $(INSTALL_DATA)
transform = $(program_transform_name)
NORMAL_INSTALL = :
PRE_INSTALL = :
POST_INSTALL = :
NORMAL_UNINSTALL = :
PRE_UNINSTALL = :
POST_UNINSTALL = :
build_triplet = @build@
host_triplet = @host@
target_triplet = @target@
subdir = include/fishsound
DIST_COMMON = $(include_HEADERS) $(srcdir)/Makefile.am \
$(srcdir)/Makefile.in
ACLOCAL_M4 = $(top_srcdir)/aclocal.m4
am__aclocal_m4_deps = $(top_srcdir)/m4/as-ac-expand.m4 \
$(top_srcdir)/configure.ac
am__configure_deps = $(am__aclocal_m4_deps) $(CONFIGURE_DEPENDENCIES) \
$(ACLOCAL_M4)
mkinstalldirs = $(install_sh) -d
CONFIG_HEADER = $(top_builddir)/config.h
CONFIG_CLEAN_FILES =
SOURCES =
DIST_SOURCES =
am__vpath_adj_setup = srcdirstrip=`echo "$(srcdir)" | sed 's|.|.|g'`;
am__vpath_adj = case $$p in \
$(srcdir)/*) f=`echo "$$p" | sed "s|^$$srcdirstrip/||"`;; \
*) f=$$p;; \
esac;
am__strip_dir = `echo $$p | sed -e 's|^.*/||'`;
am__installdirs = "$(DESTDIR)$(includedir)"
includeHEADERS_INSTALL = $(INSTALL_HEADER)
HEADERS = $(include_HEADERS)
ETAGS = etags
CTAGS = ctags
DISTFILES = $(DIST_COMMON) $(DIST_SOURCES) $(TEXINFOS) $(EXTRA_DIST)
ACLOCAL = @ACLOCAL@
ACLOCAL_AMFLAGS = @ACLOCAL_AMFLAGS@
AMTAR = @AMTAR@
AR = @AR@
AUTOCONF = @AUTOCONF@
AUTOHEADER = @AUTOHEADER@
AUTOMAKE = @AUTOMAKE@
AWK = @AWK@
BINDIR = @BINDIR@
CC = @CC@
CCDEPMODE = @CCDEPMODE@
CFLAGS = @CFLAGS@
CPP = @CPP@
CPPFLAGS = @CPPFLAGS@
CYGPATH_W = @CYGPATH_W@
DEFS = @DEFS@
DEPDIR = @DEPDIR@
DOCDIR = @DOCDIR@
DSYMUTIL = @DSYMUTIL@
DUMPBIN = @DUMPBIN@
ECHO_C = @ECHO_C@
ECHO_N = @ECHO_N@
ECHO_T = @ECHO_T@
EGREP = @EGREP@
EXEEXT = @EXEEXT@
FGREP = @FGREP@
FLAC_CFLAGS = @FLAC_CFLAGS@
FLAC_LIBS = @FLAC_LIBS@
GREP = @GREP@
HAVE_DOXYGEN = @HAVE_DOXYGEN@
HAVE_PKG_CONFIG = @HAVE_PKG_CONFIG@
HAVE_VALGRIND = @HAVE_VALGRIND@
INCLUDEDIR = @INCLUDEDIR@
INSTALL = @INSTALL@
INSTALL_DATA = @INSTALL_DATA@
INSTALL_PROGRAM = @INSTALL_PROGRAM@
INSTALL_SCRIPT = @INSTALL_SCRIPT@
INSTALL_STRIP_PROGRAM = @INSTALL_STRIP_PROGRAM@
LD = @LD@
LDFLAGS = @LDFLAGS@
LIBDIR = @LIBDIR@
LIBOBJS = @LIBOBJS@
LIBS = @LIBS@
LIBTOOL = @LIBTOOL@
LIPO = @LIPO@
LN_S = @LN_S@
LTLIBOBJS = @LTLIBOBJS@
MAKEINFO = @MAKEINFO@
MKDIR_P = @MKDIR_P@
NM = @NM@
NMEDIT = @NMEDIT@
OBJDUMP = @OBJDUMP@
OBJEXT = @OBJEXT@
OGGZ_CFLAGS = @OGGZ_CFLAGS@
OGGZ_LIBS = @OGGZ_LIBS@
OTOOL = @OTOOL@
OTOOL64 = @OTOOL64@
PACKAGE = @PACKAGE@
PACKAGE_BUGREPORT = @PACKAGE_BUGREPORT@
PACKAGE_NAME = @PACKAGE_NAME@
PACKAGE_STRING = @PACKAGE_STRING@
PACKAGE_TARNAME = @PACKAGE_TARNAME@
PACKAGE_VERSION = @PACKAGE_VERSION@
PATH_SEPARATOR = @PATH_SEPARATOR@
PKG_CONFIG = @PKG_CONFIG@
RANLIB = @RANLIB@
SED = @SED@
SET_MAKE = @SET_MAKE@
SHARED_VERSION_INFO = @SHARED_VERSION_INFO@
SHELL = @SHELL@
SHLIB_VERSION_ARG = @SHLIB_VERSION_ARG@
SNDFILE_CFLAGS = @SNDFILE_CFLAGS@
SNDFILE_LIBS = @SNDFILE_LIBS@
SPEEX_CFLAGS = @SPEEX_CFLAGS@
SPEEX_LIBS = @SPEEX_LIBS@
STRIP = @STRIP@
VALGRIND_ENVIRONMENT = @VALGRIND_ENVIRONMENT@
VERSION = @VERSION@
VORBISENC_CFLAGS = @VORBISENC_CFLAGS@
VORBISENC_LIBS = @VORBISENC_LIBS@
VORBIS_CFLAGS = @VORBIS_CFLAGS@
VORBIS_LIBS = @VORBIS_LIBS@
abs_builddir = @abs_builddir@
abs_srcdir = @abs_srcdir@
abs_top_builddir = @abs_top_builddir@
abs_top_srcdir = @abs_top_srcdir@
ac_ct_CC = @ac_ct_CC@
ac_ct_DUMPBIN = @ac_ct_DUMPBIN@
am__include = @am__include@
am__leading_dot = @am__leading_dot@
am__quote = @am__quote@
am__tar = @am__tar@
am__untar = @am__untar@
bindir = @bindir@
build = @build@
build_alias = @build_alias@
build_cpu = @build_cpu@
build_os = @build_os@
build_vendor = @build_vendor@
builddir = @builddir@
datadir = @datadir@
datarootdir = @datarootdir@
docdir = @docdir@
dvidir = @dvidir@
exec_prefix = @exec_prefix@
fishsound_pkgdeps = @fishsound_pkgdeps@
host = @host@
host_alias = @host_alias@
host_cpu = @host_cpu@
host_os = @host_os@
host_vendor = @host_vendor@
htmldir = @htmldir@
# Include files to install
includedir = $(prefix)/include/fishsound
infodir = @infodir@
install_sh = @install_sh@
libdir = @libdir@
libexecdir = @libexecdir@
localedir = @localedir@
localstatedir = @localstatedir@
lt_ECHO = @lt_ECHO@
mandir = @mandir@
mkdir_p = @mkdir_p@
oldincludedir = @oldincludedir@
pdfdir = @pdfdir@
prefix = @prefix@
program_transform_name = @program_transform_name@
psdir = @psdir@
sbindir = @sbindir@
sharedstatedir = @sharedstatedir@
srcdir = @srcdir@
sysconfdir = @sysconfdir@
target = @target@
target_alias = @target_alias@
target_cpu = @target_cpu@
target_os = @target_os@
target_vendor = @target_vendor@
top_build_prefix = @top_build_prefix@
top_builddir = @top_builddir@
top_srcdir = @top_srcdir@
include_HEADERS = fishsound.h decode.h encode.h comments.h constants.h \
deprecated.h
all: all-am
.SUFFIXES:
$(srcdir)/Makefile.in: $(srcdir)/Makefile.am $(am__configure_deps)
@for dep in $?; do \
case '$(am__configure_deps)' in \
*$$dep*) \
( cd $(top_builddir) && $(MAKE) $(AM_MAKEFLAGS) am--refresh ) \
&& { if test -f $@; then exit 0; else break; fi; }; \
exit 1;; \
esac; \
done; \
echo ' cd $(top_srcdir) && $(AUTOMAKE) --gnu include/fishsound/Makefile'; \
cd $(top_srcdir) && \
$(AUTOMAKE) --gnu include/fishsound/Makefile
.PRECIOUS: Makefile
Makefile: $(srcdir)/Makefile.in $(top_builddir)/config.status
@case '$?' in \
*config.status*) \
cd $(top_builddir) && $(MAKE) $(AM_MAKEFLAGS) am--refresh;; \
*) \
echo ' cd $(top_builddir) && $(SHELL) ./config.status $(subdir)/$@ $(am__depfiles_maybe)'; \
cd $(top_builddir) && $(SHELL) ./config.status $(subdir)/$@ $(am__depfiles_maybe);; \
esac;
$(top_builddir)/config.status: $(top_srcdir)/configure $(CONFIG_STATUS_DEPENDENCIES)
cd $(top_builddir) && $(MAKE) $(AM_MAKEFLAGS) am--refresh
$(top_srcdir)/configure: $(am__configure_deps)
cd $(top_builddir) && $(MAKE) $(AM_MAKEFLAGS) am--refresh
$(ACLOCAL_M4): $(am__aclocal_m4_deps)
cd $(top_builddir) && $(MAKE) $(AM_MAKEFLAGS) am--refresh
mostlyclean-libtool:
-rm -f *.lo
clean-libtool:
-rm -rf .libs _libs
install-includeHEADERS: $(include_HEADERS)
@$(NORMAL_INSTALL)
test -z "$(includedir)" || $(MKDIR_P) "$(DESTDIR)$(includedir)"
@list='$(include_HEADERS)'; for p in $$list; do \
if test -f "$$p"; then d=; else d="$(srcdir)/"; fi; \
f=$(am__strip_dir) \
echo " $(includeHEADERS_INSTALL) '$$d$$p' '$(DESTDIR)$(includedir)/$$f'"; \
$(includeHEADERS_INSTALL) "$$d$$p" "$(DESTDIR)$(includedir)/$$f"; \
done
uninstall-includeHEADERS:
@$(NORMAL_UNINSTALL)
@list='$(include_HEADERS)'; for p in $$list; do \
f=$(am__strip_dir) \
echo " rm -f '$(DESTDIR)$(includedir)/$$f'"; \
rm -f "$(DESTDIR)$(includedir)/$$f"; \
done
ID: $(HEADERS) $(SOURCES) $(LISP) $(TAGS_FILES)
list='$(SOURCES) $(HEADERS) $(LISP) $(TAGS_FILES)'; \
unique=`for i in $$list; do \
if test -f "$$i"; then echo $$i; else echo $(srcdir)/$$i; fi; \
done | \
$(AWK) '{ files[$$0] = 1; nonempty = 1; } \
END { if (nonempty) { for (i in files) print i; }; }'`; \
mkid -fID $$unique
tags: TAGS
TAGS: $(HEADERS) $(SOURCES) $(TAGS_DEPENDENCIES) \
$(TAGS_FILES) $(LISP)
tags=; \
here=`pwd`; \
list='$(SOURCES) $(HEADERS) $(LISP) $(TAGS_FILES)'; \
unique=`for i in $$list; do \
if test -f "$$i"; then echo $$i; else echo $(srcdir)/$$i; fi; \
done | \
$(AWK) '{ files[$$0] = 1; nonempty = 1; } \
END { if (nonempty) { for (i in files) print i; }; }'`; \
if test -z "$(ETAGS_ARGS)$$tags$$unique"; then :; else \
test -n "$$unique" || unique=$$empty_fix; \
$(ETAGS) $(ETAGSFLAGS) $(AM_ETAGSFLAGS) $(ETAGS_ARGS) \
$$tags $$unique; \
fi
ctags: CTAGS
CTAGS: $(HEADERS) $(SOURCES) $(TAGS_DEPENDENCIES) \
$(TAGS_FILES) $(LISP)
tags=; \
list='$(SOURCES) $(HEADERS) $(LISP) $(TAGS_FILES)'; \
unique=`for i in $$list; do \
if test -f "$$i"; then echo $$i; else echo $(srcdir)/$$i; fi; \
done | \
$(AWK) '{ files[$$0] = 1; nonempty = 1; } \
END { if (nonempty) { for (i in files) print i; }; }'`; \
test -z "$(CTAGS_ARGS)$$tags$$unique" \
|| $(CTAGS) $(CTAGSFLAGS) $(AM_CTAGSFLAGS) $(CTAGS_ARGS) \
$$tags $$unique
GTAGS:
here=`$(am__cd) $(top_builddir) && pwd` \
&& cd $(top_srcdir) \
&& gtags -i $(GTAGS_ARGS) $$here
distclean-tags:
-rm -f TAGS ID GTAGS GRTAGS GSYMS GPATH tags
distdir: $(DISTFILES)
@srcdirstrip=`echo "$(srcdir)" | sed 's/[].[^$$\\*]/\\\\&/g'`; \
topsrcdirstrip=`echo "$(top_srcdir)" | sed 's/[].[^$$\\*]/\\\\&/g'`; \
list='$(DISTFILES)'; \
dist_files=`for file in $$list; do echo $$file; done | \
sed -e "s|^$$srcdirstrip/||;t" \
-e "s|^$$topsrcdirstrip/|$(top_builddir)/|;t"`; \
case $$dist_files in \
*/*) $(MKDIR_P) `echo "$$dist_files" | \
sed '/\//!d;s|^|$(distdir)/|;s,/[^/]*$$,,' | \
sort -u` ;; \
esac; \
for file in $$dist_files; do \
if test -f $$file || test -d $$file; then d=.; else d=$(srcdir); fi; \
if test -d $$d/$$file; then \
dir=`echo "/$$file" | sed -e 's,/[^/]*$$,,'`; \
if test -d $(srcdir)/$$file && test $$d != $(srcdir); then \
cp -pR $(srcdir)/$$file $(distdir)$$dir || exit 1; \
fi; \
cp -pR $$d/$$file $(distdir)$$dir || exit 1; \
else \
test -f $(distdir)/$$file \
|| cp -p $$d/$$file $(distdir)/$$file \
|| exit 1; \
fi; \
done
check-am: all-am
check: check-am
all-am: Makefile $(HEADERS)
installdirs:
for dir in "$(DESTDIR)$(includedir)"; do \
test -z "$$dir" || $(MKDIR_P) "$$dir"; \
done
install: install-am
install-exec: install-exec-am
install-data: install-data-am
uninstall: uninstall-am
install-am: all-am
@$(MAKE) $(AM_MAKEFLAGS) install-exec-am install-data-am
installcheck: installcheck-am
install-strip:
$(MAKE) $(AM_MAKEFLAGS) INSTALL_PROGRAM="$(INSTALL_STRIP_PROGRAM)" \
install_sh_PROGRAM="$(INSTALL_STRIP_PROGRAM)" INSTALL_STRIP_FLAG=-s \
`test -z '$(STRIP)' || \
echo "INSTALL_PROGRAM_ENV=STRIPPROG='$(STRIP)'"` install
mostlyclean-generic:
clean-generic:
distclean-generic:
-test -z "$(CONFIG_CLEAN_FILES)" || rm -f $(CONFIG_CLEAN_FILES)
maintainer-clean-generic:
@echo "This command is intended for maintainers to use"
@echo "it deletes files that may require special tools to rebuild."
clean: clean-am
clean-am: clean-generic clean-libtool mostlyclean-am
distclean: distclean-am
-rm -f Makefile
distclean-am: clean-am distclean-generic distclean-tags
dvi: dvi-am
dvi-am:
html: html-am
info: info-am
info-am:
install-data-am: install-includeHEADERS
install-dvi: install-dvi-am
install-exec-am:
install-html: install-html-am
install-info: install-info-am
install-man:
install-pdf: install-pdf-am
install-ps: install-ps-am
installcheck-am:
maintainer-clean: maintainer-clean-am
-rm -f Makefile
maintainer-clean-am: distclean-am maintainer-clean-generic
mostlyclean: mostlyclean-am
mostlyclean-am: mostlyclean-generic mostlyclean-libtool
pdf: pdf-am
pdf-am:
ps: ps-am
ps-am:
uninstall-am: uninstall-includeHEADERS
.MAKE: install-am install-strip
.PHONY: CTAGS GTAGS all all-am check check-am clean clean-generic \
clean-libtool ctags distclean distclean-generic \
distclean-libtool distclean-tags distdir dvi dvi-am html \
html-am info info-am install install-am install-data \
install-data-am install-dvi install-dvi-am install-exec \
install-exec-am install-html install-html-am \
install-includeHEADERS install-info install-info-am \
install-man install-pdf install-pdf-am install-ps \
install-ps-am install-strip installcheck installcheck-am \
installdirs maintainer-clean maintainer-clean-generic \
mostlyclean mostlyclean-generic mostlyclean-libtool pdf pdf-am \
ps ps-am tags uninstall uninstall-am uninstall-includeHEADERS
# Tell versions [3.59,3.63) of GNU make to not export all variables.
# Otherwise a system limit (for SysV at least) may be exceeded.
.NOEXPORT:
libfishsound-1.0.0/src/ 0000777 0001750 0001750 00000000000 11332275631 012000 5 0000000 0000000 libfishsound-1.0.0/src/Makefile.am 0000644 0001750 0001750 00000000141 11005257656 013750 0000000 0000000 ## Process this file with automake to produce Makefile.in
SUBDIRS = libfishsound examples tests
libfishsound-1.0.0/src/Makefile.in 0000644 0001750 0001750 00000035713 11332275622 013772 0000000 0000000 # Makefile.in generated by automake 1.10.2 from Makefile.am.
# @configure_input@
# Copyright (C) 1994, 1995, 1996, 1997, 1998, 1999, 2000, 2001, 2002,
# 2003, 2004, 2005, 2006, 2007, 2008 Free Software Foundation, Inc.
# This Makefile.in is free software; the Free Software Foundation
# gives unlimited permission to copy and/or distribute it,
# with or without modifications, as long as this notice is preserved.
# This program is distributed in the hope that it will be useful,
# but WITHOUT ANY WARRANTY, to the extent permitted by law; without
# even the implied warranty of MERCHANTABILITY or FITNESS FOR A
# PARTICULAR PURPOSE.
@SET_MAKE@
VPATH = @srcdir@
pkgdatadir = $(datadir)/@PACKAGE@
pkglibdir = $(libdir)/@PACKAGE@
pkgincludedir = $(includedir)/@PACKAGE@
am__cd = CDPATH="$${ZSH_VERSION+.}$(PATH_SEPARATOR)" && cd
install_sh_DATA = $(install_sh) -c -m 644
install_sh_PROGRAM = $(install_sh) -c
install_sh_SCRIPT = $(install_sh) -c
INSTALL_HEADER = $(INSTALL_DATA)
transform = $(program_transform_name)
NORMAL_INSTALL = :
PRE_INSTALL = :
POST_INSTALL = :
NORMAL_UNINSTALL = :
PRE_UNINSTALL = :
POST_UNINSTALL = :
build_triplet = @build@
host_triplet = @host@
target_triplet = @target@
subdir = src
DIST_COMMON = $(srcdir)/Makefile.am $(srcdir)/Makefile.in
ACLOCAL_M4 = $(top_srcdir)/aclocal.m4
am__aclocal_m4_deps = $(top_srcdir)/m4/as-ac-expand.m4 \
$(top_srcdir)/configure.ac
am__configure_deps = $(am__aclocal_m4_deps) $(CONFIGURE_DEPENDENCIES) \
$(ACLOCAL_M4)
mkinstalldirs = $(install_sh) -d
CONFIG_HEADER = $(top_builddir)/config.h
CONFIG_CLEAN_FILES =
SOURCES =
DIST_SOURCES =
RECURSIVE_TARGETS = all-recursive check-recursive dvi-recursive \
html-recursive info-recursive install-data-recursive \
install-dvi-recursive install-exec-recursive \
install-html-recursive install-info-recursive \
install-pdf-recursive install-ps-recursive install-recursive \
installcheck-recursive installdirs-recursive pdf-recursive \
ps-recursive uninstall-recursive
RECURSIVE_CLEAN_TARGETS = mostlyclean-recursive clean-recursive \
distclean-recursive maintainer-clean-recursive
ETAGS = etags
CTAGS = ctags
DIST_SUBDIRS = $(SUBDIRS)
DISTFILES = $(DIST_COMMON) $(DIST_SOURCES) $(TEXINFOS) $(EXTRA_DIST)
ACLOCAL = @ACLOCAL@
ACLOCAL_AMFLAGS = @ACLOCAL_AMFLAGS@
AMTAR = @AMTAR@
AR = @AR@
AUTOCONF = @AUTOCONF@
AUTOHEADER = @AUTOHEADER@
AUTOMAKE = @AUTOMAKE@
AWK = @AWK@
BINDIR = @BINDIR@
CC = @CC@
CCDEPMODE = @CCDEPMODE@
CFLAGS = @CFLAGS@
CPP = @CPP@
CPPFLAGS = @CPPFLAGS@
CYGPATH_W = @CYGPATH_W@
DEFS = @DEFS@
DEPDIR = @DEPDIR@
DOCDIR = @DOCDIR@
DSYMUTIL = @DSYMUTIL@
DUMPBIN = @DUMPBIN@
ECHO_C = @ECHO_C@
ECHO_N = @ECHO_N@
ECHO_T = @ECHO_T@
EGREP = @EGREP@
EXEEXT = @EXEEXT@
FGREP = @FGREP@
FLAC_CFLAGS = @FLAC_CFLAGS@
FLAC_LIBS = @FLAC_LIBS@
GREP = @GREP@
HAVE_DOXYGEN = @HAVE_DOXYGEN@
HAVE_PKG_CONFIG = @HAVE_PKG_CONFIG@
HAVE_VALGRIND = @HAVE_VALGRIND@
INCLUDEDIR = @INCLUDEDIR@
INSTALL = @INSTALL@
INSTALL_DATA = @INSTALL_DATA@
INSTALL_PROGRAM = @INSTALL_PROGRAM@
INSTALL_SCRIPT = @INSTALL_SCRIPT@
INSTALL_STRIP_PROGRAM = @INSTALL_STRIP_PROGRAM@
LD = @LD@
LDFLAGS = @LDFLAGS@
LIBDIR = @LIBDIR@
LIBOBJS = @LIBOBJS@
LIBS = @LIBS@
LIBTOOL = @LIBTOOL@
LIPO = @LIPO@
LN_S = @LN_S@
LTLIBOBJS = @LTLIBOBJS@
MAKEINFO = @MAKEINFO@
MKDIR_P = @MKDIR_P@
NM = @NM@
NMEDIT = @NMEDIT@
OBJDUMP = @OBJDUMP@
OBJEXT = @OBJEXT@
OGGZ_CFLAGS = @OGGZ_CFLAGS@
OGGZ_LIBS = @OGGZ_LIBS@
OTOOL = @OTOOL@
OTOOL64 = @OTOOL64@
PACKAGE = @PACKAGE@
PACKAGE_BUGREPORT = @PACKAGE_BUGREPORT@
PACKAGE_NAME = @PACKAGE_NAME@
PACKAGE_STRING = @PACKAGE_STRING@
PACKAGE_TARNAME = @PACKAGE_TARNAME@
PACKAGE_VERSION = @PACKAGE_VERSION@
PATH_SEPARATOR = @PATH_SEPARATOR@
PKG_CONFIG = @PKG_CONFIG@
RANLIB = @RANLIB@
SED = @SED@
SET_MAKE = @SET_MAKE@
SHARED_VERSION_INFO = @SHARED_VERSION_INFO@
SHELL = @SHELL@
SHLIB_VERSION_ARG = @SHLIB_VERSION_ARG@
SNDFILE_CFLAGS = @SNDFILE_CFLAGS@
SNDFILE_LIBS = @SNDFILE_LIBS@
SPEEX_CFLAGS = @SPEEX_CFLAGS@
SPEEX_LIBS = @SPEEX_LIBS@
STRIP = @STRIP@
VALGRIND_ENVIRONMENT = @VALGRIND_ENVIRONMENT@
VERSION = @VERSION@
VORBISENC_CFLAGS = @VORBISENC_CFLAGS@
VORBISENC_LIBS = @VORBISENC_LIBS@
VORBIS_CFLAGS = @VORBIS_CFLAGS@
VORBIS_LIBS = @VORBIS_LIBS@
abs_builddir = @abs_builddir@
abs_srcdir = @abs_srcdir@
abs_top_builddir = @abs_top_builddir@
abs_top_srcdir = @abs_top_srcdir@
ac_ct_CC = @ac_ct_CC@
ac_ct_DUMPBIN = @ac_ct_DUMPBIN@
am__include = @am__include@
am__leading_dot = @am__leading_dot@
am__quote = @am__quote@
am__tar = @am__tar@
am__untar = @am__untar@
bindir = @bindir@
build = @build@
build_alias = @build_alias@
build_cpu = @build_cpu@
build_os = @build_os@
build_vendor = @build_vendor@
builddir = @builddir@
datadir = @datadir@
datarootdir = @datarootdir@
docdir = @docdir@
dvidir = @dvidir@
exec_prefix = @exec_prefix@
fishsound_pkgdeps = @fishsound_pkgdeps@
host = @host@
host_alias = @host_alias@
host_cpu = @host_cpu@
host_os = @host_os@
host_vendor = @host_vendor@
htmldir = @htmldir@
includedir = @includedir@
infodir = @infodir@
install_sh = @install_sh@
libdir = @libdir@
libexecdir = @libexecdir@
localedir = @localedir@
localstatedir = @localstatedir@
lt_ECHO = @lt_ECHO@
mandir = @mandir@
mkdir_p = @mkdir_p@
oldincludedir = @oldincludedir@
pdfdir = @pdfdir@
prefix = @prefix@
program_transform_name = @program_transform_name@
psdir = @psdir@
sbindir = @sbindir@
sharedstatedir = @sharedstatedir@
srcdir = @srcdir@
sysconfdir = @sysconfdir@
target = @target@
target_alias = @target_alias@
target_cpu = @target_cpu@
target_os = @target_os@
target_vendor = @target_vendor@
top_build_prefix = @top_build_prefix@
top_builddir = @top_builddir@
top_srcdir = @top_srcdir@
SUBDIRS = libfishsound examples tests
all: all-recursive
.SUFFIXES:
$(srcdir)/Makefile.in: $(srcdir)/Makefile.am $(am__configure_deps)
@for dep in $?; do \
case '$(am__configure_deps)' in \
*$$dep*) \
( cd $(top_builddir) && $(MAKE) $(AM_MAKEFLAGS) am--refresh ) \
&& { if test -f $@; then exit 0; else break; fi; }; \
exit 1;; \
esac; \
done; \
echo ' cd $(top_srcdir) && $(AUTOMAKE) --gnu src/Makefile'; \
cd $(top_srcdir) && \
$(AUTOMAKE) --gnu src/Makefile
.PRECIOUS: Makefile
Makefile: $(srcdir)/Makefile.in $(top_builddir)/config.status
@case '$?' in \
*config.status*) \
cd $(top_builddir) && $(MAKE) $(AM_MAKEFLAGS) am--refresh;; \
*) \
echo ' cd $(top_builddir) && $(SHELL) ./config.status $(subdir)/$@ $(am__depfiles_maybe)'; \
cd $(top_builddir) && $(SHELL) ./config.status $(subdir)/$@ $(am__depfiles_maybe);; \
esac;
$(top_builddir)/config.status: $(top_srcdir)/configure $(CONFIG_STATUS_DEPENDENCIES)
cd $(top_builddir) && $(MAKE) $(AM_MAKEFLAGS) am--refresh
$(top_srcdir)/configure: $(am__configure_deps)
cd $(top_builddir) && $(MAKE) $(AM_MAKEFLAGS) am--refresh
$(ACLOCAL_M4): $(am__aclocal_m4_deps)
cd $(top_builddir) && $(MAKE) $(AM_MAKEFLAGS) am--refresh
mostlyclean-libtool:
-rm -f *.lo
clean-libtool:
-rm -rf .libs _libs
# This directory's subdirectories are mostly independent; you can cd
# into them and run `make' without going through this Makefile.
# To change the values of `make' variables: instead of editing Makefiles,
# (1) if the variable is set in `config.status', edit `config.status'
# (which will cause the Makefiles to be regenerated when you run `make');
# (2) otherwise, pass the desired values on the `make' command line.
$(RECURSIVE_TARGETS):
@failcom='exit 1'; \
for f in x $$MAKEFLAGS; do \
case $$f in \
*=* | --[!k]*);; \
*k*) failcom='fail=yes';; \
esac; \
done; \
dot_seen=no; \
target=`echo $@ | sed s/-recursive//`; \
list='$(SUBDIRS)'; for subdir in $$list; do \
echo "Making $$target in $$subdir"; \
if test "$$subdir" = "."; then \
dot_seen=yes; \
local_target="$$target-am"; \
else \
local_target="$$target"; \
fi; \
(cd $$subdir && $(MAKE) $(AM_MAKEFLAGS) $$local_target) \
|| eval $$failcom; \
done; \
if test "$$dot_seen" = "no"; then \
$(MAKE) $(AM_MAKEFLAGS) "$$target-am" || exit 1; \
fi; test -z "$$fail"
$(RECURSIVE_CLEAN_TARGETS):
@failcom='exit 1'; \
for f in x $$MAKEFLAGS; do \
case $$f in \
*=* | --[!k]*);; \
*k*) failcom='fail=yes';; \
esac; \
done; \
dot_seen=no; \
case "$@" in \
distclean-* | maintainer-clean-*) list='$(DIST_SUBDIRS)' ;; \
*) list='$(SUBDIRS)' ;; \
esac; \
rev=''; for subdir in $$list; do \
if test "$$subdir" = "."; then :; else \
rev="$$subdir $$rev"; \
fi; \
done; \
rev="$$rev ."; \
target=`echo $@ | sed s/-recursive//`; \
for subdir in $$rev; do \
echo "Making $$target in $$subdir"; \
if test "$$subdir" = "."; then \
local_target="$$target-am"; \
else \
local_target="$$target"; \
fi; \
(cd $$subdir && $(MAKE) $(AM_MAKEFLAGS) $$local_target) \
|| eval $$failcom; \
done && test -z "$$fail"
tags-recursive:
list='$(SUBDIRS)'; for subdir in $$list; do \
test "$$subdir" = . || (cd $$subdir && $(MAKE) $(AM_MAKEFLAGS) tags); \
done
ctags-recursive:
list='$(SUBDIRS)'; for subdir in $$list; do \
test "$$subdir" = . || (cd $$subdir && $(MAKE) $(AM_MAKEFLAGS) ctags); \
done
ID: $(HEADERS) $(SOURCES) $(LISP) $(TAGS_FILES)
list='$(SOURCES) $(HEADERS) $(LISP) $(TAGS_FILES)'; \
unique=`for i in $$list; do \
if test -f "$$i"; then echo $$i; else echo $(srcdir)/$$i; fi; \
done | \
$(AWK) '{ files[$$0] = 1; nonempty = 1; } \
END { if (nonempty) { for (i in files) print i; }; }'`; \
mkid -fID $$unique
tags: TAGS
TAGS: tags-recursive $(HEADERS) $(SOURCES) $(TAGS_DEPENDENCIES) \
$(TAGS_FILES) $(LISP)
tags=; \
here=`pwd`; \
if ($(ETAGS) --etags-include --version) >/dev/null 2>&1; then \
include_option=--etags-include; \
empty_fix=.; \
else \
include_option=--include; \
empty_fix=; \
fi; \
list='$(SUBDIRS)'; for subdir in $$list; do \
if test "$$subdir" = .; then :; else \
test ! -f $$subdir/TAGS || \
tags="$$tags $$include_option=$$here/$$subdir/TAGS"; \
fi; \
done; \
list='$(SOURCES) $(HEADERS) $(LISP) $(TAGS_FILES)'; \
unique=`for i in $$list; do \
if test -f "$$i"; then echo $$i; else echo $(srcdir)/$$i; fi; \
done | \
$(AWK) '{ files[$$0] = 1; nonempty = 1; } \
END { if (nonempty) { for (i in files) print i; }; }'`; \
if test -z "$(ETAGS_ARGS)$$tags$$unique"; then :; else \
test -n "$$unique" || unique=$$empty_fix; \
$(ETAGS) $(ETAGSFLAGS) $(AM_ETAGSFLAGS) $(ETAGS_ARGS) \
$$tags $$unique; \
fi
ctags: CTAGS
CTAGS: ctags-recursive $(HEADERS) $(SOURCES) $(TAGS_DEPENDENCIES) \
$(TAGS_FILES) $(LISP)
tags=; \
list='$(SOURCES) $(HEADERS) $(LISP) $(TAGS_FILES)'; \
unique=`for i in $$list; do \
if test -f "$$i"; then echo $$i; else echo $(srcdir)/$$i; fi; \
done | \
$(AWK) '{ files[$$0] = 1; nonempty = 1; } \
END { if (nonempty) { for (i in files) print i; }; }'`; \
test -z "$(CTAGS_ARGS)$$tags$$unique" \
|| $(CTAGS) $(CTAGSFLAGS) $(AM_CTAGSFLAGS) $(CTAGS_ARGS) \
$$tags $$unique
GTAGS:
here=`$(am__cd) $(top_builddir) && pwd` \
&& cd $(top_srcdir) \
&& gtags -i $(GTAGS_ARGS) $$here
distclean-tags:
-rm -f TAGS ID GTAGS GRTAGS GSYMS GPATH tags
distdir: $(DISTFILES)
@srcdirstrip=`echo "$(srcdir)" | sed 's/[].[^$$\\*]/\\\\&/g'`; \
topsrcdirstrip=`echo "$(top_srcdir)" | sed 's/[].[^$$\\*]/\\\\&/g'`; \
list='$(DISTFILES)'; \
dist_files=`for file in $$list; do echo $$file; done | \
sed -e "s|^$$srcdirstrip/||;t" \
-e "s|^$$topsrcdirstrip/|$(top_builddir)/|;t"`; \
case $$dist_files in \
*/*) $(MKDIR_P) `echo "$$dist_files" | \
sed '/\//!d;s|^|$(distdir)/|;s,/[^/]*$$,,' | \
sort -u` ;; \
esac; \
for file in $$dist_files; do \
if test -f $$file || test -d $$file; then d=.; else d=$(srcdir); fi; \
if test -d $$d/$$file; then \
dir=`echo "/$$file" | sed -e 's,/[^/]*$$,,'`; \
if test -d $(srcdir)/$$file && test $$d != $(srcdir); then \
cp -pR $(srcdir)/$$file $(distdir)$$dir || exit 1; \
fi; \
cp -pR $$d/$$file $(distdir)$$dir || exit 1; \
else \
test -f $(distdir)/$$file \
|| cp -p $$d/$$file $(distdir)/$$file \
|| exit 1; \
fi; \
done
list='$(DIST_SUBDIRS)'; for subdir in $$list; do \
if test "$$subdir" = .; then :; else \
test -d "$(distdir)/$$subdir" \
|| $(MKDIR_P) "$(distdir)/$$subdir" \
|| exit 1; \
distdir=`$(am__cd) $(distdir) && pwd`; \
top_distdir=`$(am__cd) $(top_distdir) && pwd`; \
(cd $$subdir && \
$(MAKE) $(AM_MAKEFLAGS) \
top_distdir="$$top_distdir" \
distdir="$$distdir/$$subdir" \
am__remove_distdir=: \
am__skip_length_check=: \
distdir) \
|| exit 1; \
fi; \
done
check-am: all-am
check: check-recursive
all-am: Makefile
installdirs: installdirs-recursive
installdirs-am:
install: install-recursive
install-exec: install-exec-recursive
install-data: install-data-recursive
uninstall: uninstall-recursive
install-am: all-am
@$(MAKE) $(AM_MAKEFLAGS) install-exec-am install-data-am
installcheck: installcheck-recursive
install-strip:
$(MAKE) $(AM_MAKEFLAGS) INSTALL_PROGRAM="$(INSTALL_STRIP_PROGRAM)" \
install_sh_PROGRAM="$(INSTALL_STRIP_PROGRAM)" INSTALL_STRIP_FLAG=-s \
`test -z '$(STRIP)' || \
echo "INSTALL_PROGRAM_ENV=STRIPPROG='$(STRIP)'"` install
mostlyclean-generic:
clean-generic:
distclean-generic:
-test -z "$(CONFIG_CLEAN_FILES)" || rm -f $(CONFIG_CLEAN_FILES)
maintainer-clean-generic:
@echo "This command is intended for maintainers to use"
@echo "it deletes files that may require special tools to rebuild."
clean: clean-recursive
clean-am: clean-generic clean-libtool mostlyclean-am
distclean: distclean-recursive
-rm -f Makefile
distclean-am: clean-am distclean-generic distclean-tags
dvi: dvi-recursive
dvi-am:
html: html-recursive
info: info-recursive
info-am:
install-data-am:
install-dvi: install-dvi-recursive
install-exec-am:
install-html: install-html-recursive
install-info: install-info-recursive
install-man:
install-pdf: install-pdf-recursive
install-ps: install-ps-recursive
installcheck-am:
maintainer-clean: maintainer-clean-recursive
-rm -f Makefile
maintainer-clean-am: distclean-am maintainer-clean-generic
mostlyclean: mostlyclean-recursive
mostlyclean-am: mostlyclean-generic mostlyclean-libtool
pdf: pdf-recursive
pdf-am:
ps: ps-recursive
ps-am:
uninstall-am:
.MAKE: $(RECURSIVE_CLEAN_TARGETS) $(RECURSIVE_TARGETS) install-am \
install-strip
.PHONY: $(RECURSIVE_CLEAN_TARGETS) $(RECURSIVE_TARGETS) CTAGS GTAGS \
all all-am check check-am clean clean-generic clean-libtool \
ctags ctags-recursive distclean distclean-generic \
distclean-libtool distclean-tags distdir dvi dvi-am html \
html-am info info-am install install-am install-data \
install-data-am install-dvi install-dvi-am install-exec \
install-exec-am install-html install-html-am install-info \
install-info-am install-man install-pdf install-pdf-am \
install-ps install-ps-am install-strip installcheck \
installcheck-am installdirs installdirs-am maintainer-clean \
maintainer-clean-generic mostlyclean mostlyclean-generic \
mostlyclean-libtool pdf pdf-am ps ps-am tags tags-recursive \
uninstall uninstall-am
# Tell versions [3.59,3.63) of GNU make to not export all variables.
# Otherwise a system limit (for SysV at least) may be exceeded.
.NOEXPORT:
libfishsound-1.0.0/src/libfishsound/ 0000777 0001750 0001750 00000000000 11332275631 014471 5 0000000 0000000 libfishsound-1.0.0/src/libfishsound/debug.h 0000644 0001750 0001750 00000003427 11332275512 015650 0000000 0000000 /*
* A generic debugging printer.
*
* Conrad Parker , May 2009
*
* Usage:
*
* #define DEBUG_LEVEL 3
* #include "debug.h"
*
* ...
* debug_printf (2, "Something went wrong");
* ...
*
* The macro print_debug(level, fmt) prints a formatted debugging message
* of level 'level' to stderr. You should set the maximum tolerable debug
* level before including debug.h. If it is 0, or if neither DEBUG_LEVEL
* nor DEBUG are defined, then the debug_printf() macro is ignored, and
* none of this file is included.
*/
#ifndef __DEBUG_H__
#define __DEBUG_H__
/* MSVC can't handle C99 */
#if (defined (_MSCVER) || defined (_MSC_VER))
#define debug_printf //
#else
#ifdef DEBUG
#ifndef DEBUG_LEVEL
#define DEBUG_LEVEL 1
#endif
#endif
#if (DEBUG_LEVEL > 0)
#define DEBUG_MAXLINE 4096
#include
#include
#include
#include
/*
* debug_print_err (func, line, fmt)
*
* Print a formatted error message to stderr.
*/
static void
debug_print_err (const char * func, int line, const char * fmt, ...)
{
va_list ap;
int errno_save;
char buf[DEBUG_MAXLINE];
int n=0;
errno_save = errno;
va_start (ap, fmt);
if (func) {
snprintf (buf+n, DEBUG_MAXLINE-n, "%s():%d: ", func, line);
n = strlen (buf);
}
vsnprintf (buf+n, DEBUG_MAXLINE-n, fmt, ap);
n = strlen (buf);
fflush (stdout); /* in case stdout and stderr are the same */
fputs (buf, stderr);
fputc ('\n', stderr);
fflush (NULL);
va_end (ap);
}
/*
* debug_printf (level, fmt)
*
* Print a formatted debugging message of level 'level' to stderr
*/
#define debug_printf(x,y...) {if (x <= DEBUG_LEVEL) debug_print_err (__func__, __LINE__, y);}
#undef MAXLINE
#else
#define debug_printf(x,...)
#endif
#endif /* non-C99 */
#endif /* __DEBUG_H__ */
libfishsound-1.0.0/src/libfishsound/private.h 0000644 0001750 0001750 00000013535 11163316023 016230 0000000 0000000 /*
Copyright (C) 2003 Commonwealth Scientific and Industrial Research
Organisation (CSIRO) Australia
Redistribution and use in source and binary forms, with or without
modification, are permitted provided that the following conditions
are met:
- Redistributions of source code must retain the above copyright
notice, this list of conditions and the following disclaimer.
- Redistributions in binary form must reproduce the above copyright
notice, this list of conditions and the following disclaimer in the
documentation and/or other materials provided with the distribution.
- Neither the name of CSIRO Australia nor the names of its
contributors may be used to endorse or promote products derived from
this software without specific prior written permission.
THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS
``AS IS'' AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT
LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A
PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE ORGANISATION OR
CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL,
EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO,
PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR
PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF
LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING
NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS
SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
*/
#ifndef __FISH_SOUND_PRIVATE_H__
#define __FISH_SOUND_PRIVATE_H__
#include
#include "fs_compat.h"
#include "fs_vector.h"
#include
#undef MIN
#define MIN(a,b) (((a)<(b))?(a):(b))
typedef struct _FishSound FishSound;
typedef struct _FishSoundInfo FishSoundInfo;
typedef struct _FishSoundCodec FishSoundCodec;
typedef struct _FishSoundFormat FishSoundFormat;
typedef struct _FishSoundComment FishSoundComment;
typedef int (*FSCodecIdentify) (unsigned char * buf, long bytes);
typedef FishSound * (*FSCodecInit) (FishSound * fsound);
typedef FishSound * (*FSCodecDelete) (FishSound * fsound);
typedef int (*FSCodecReset) (FishSound * fsound);
typedef int (*FSCodecUpdate) (FishSound * fsound, int interleave);
typedef int (*FSCodecCommand) (FishSound * fsound, int command,
void * data, int datasize);
typedef long (*FSCodecDecode) (FishSound * fsound, unsigned char * buf,
long bytes);
typedef long (*FSCodecEncode_Float) (FishSound * fsound, float * pcm[],
long frames);
typedef long (*FSCodecEncode_FloatIlv) (FishSound * fsound,
float ** pcm, long frames);
typedef long (*FSCodecFlush) (FishSound * fsound);
#include
#include
struct _FishSoundFormat {
int format;
const char * name;
const char * extension;
};
struct _FishSoundCodec {
struct _FishSoundFormat format;
FSCodecInit init;
FSCodecDelete del;
FSCodecReset reset;
FSCodecUpdate update;
FSCodecCommand command;
FSCodecDecode decode;
FSCodecEncode_FloatIlv encode_f_ilv;
FSCodecEncode_Float encode_f;
FSCodecFlush flush;
};
struct _FishSoundInfo {
int samplerate;
int channels;
int format;
};
struct _FishSoundComment {
char * name;
char * value;
};
union FishSoundCallback {
FishSoundDecoded_Float decoded_float;
FishSoundDecoded_FloatIlv decoded_float_ilv;
FishSoundEncoded encoded;
};
struct _FishSound {
/** FISH_SOUND_DECODE or FISH_SOUND_ENCODE */
FishSoundMode mode;
/** General info related to sound */
FishSoundInfo info;
/** Interleave boolean */
int interleave;
/**
* Current frameno.
*/
long frameno;
/**
* Truncation frameno for the next block of data sent to decode.
* In Ogg encapsulation, this is represented by the Ogg packet's
* "granulepos" field.
*/
long next_granulepos;
/**
* Flag if the next block of data sent to decode will be the last one
* for this stream (eos = End Of Stream).
* In Ogg encapsulation, this is represented by the Ogg packet's
* "eos" field.
*/
int next_eos;
/** The codec class structure */
FishSoundCodec * codec;
/** codec specific data */
void * codec_data;
/* encode or decode callback */
union FishSoundCallback callback;
/** user data for encode/decode callback */
void * user_data;
/** The comments */
char * vendor;
FishSoundVector * comments;
};
int fish_sound_identify (unsigned char * buf, long bytes);
int fish_sound_set_format (FishSound * fsound, int format);
/* Format specific interfaces */
int fish_sound_vorbis_identify (unsigned char * buf, long bytes);
FishSoundCodec * fish_sound_vorbis_codec (void);
int fish_sound_speex_identify (unsigned char * buf, long bytes);
FishSoundCodec * fish_sound_speex_codec (void);
int fish_sound_flac_identify (unsigned char * buf, long bytes);
FishSoundCodec * fish_sound_flac_codec (void);
/* comments */
int fish_sound_comments_init (FishSound * fsound);
int fish_sound_comments_free (FishSound * fsound);
int fish_sound_comments_decode (FishSound * fsound, unsigned char * buf,
long bytes);
long fish_sound_comments_encode (FishSound * fsound, unsigned char * buf,
long length);
/**
* Set the vendor string.
* \param fsound A FishSound* handle (created with FISH_SOUND_ENCODE)
* \param vendor The vendor string.
* \retval 0 Success
* \retval FISH_SOUND_ERR_BAD \a fsound is not a valid FishSound* handle
* \retval FISH_SOUND_ERR_INVALID Operation not suitable for this FishSound
*/
int
fish_sound_comment_set_vendor (FishSound * fsound, const char * vendor);
const FishSoundComment * fish_sound_comment_first (FishSound * fsound);
const FishSoundComment *
fish_sound_comment_next (FishSound * fsound, const FishSoundComment * comment);
#endif /* __FISH_SOUND_PRIVATE_H__ */
libfishsound-1.0.0/src/libfishsound/convert.h 0000644 0001750 0001750 00000004454 11163316023 016236 0000000 0000000 /*
Copyright (C) 2003 Commonwealth Scientific and Industrial Research
Organisation (CSIRO) Australia
Redistribution and use in source and binary forms, with or without
modification, are permitted provided that the following conditions
are met:
- Redistributions of source code must retain the above copyright
notice, this list of conditions and the following disclaimer.
- Redistributions in binary form must reproduce the above copyright
notice, this list of conditions and the following disclaimer in the
documentation and/or other materials provided with the distribution.
- Neither the name of CSIRO Australia nor the names of its
contributors may be used to endorse or promote products derived from
this software without specific prior written permission.
THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS
``AS IS'' AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT
LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A
PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE ORGANISATION OR
CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL,
EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO,
PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR
PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF
LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING
NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS
SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
*/
#ifndef __FISH_SOUND_CONVERT_H__
#define __FISH_SOUND_CONVERT_H__
/* inline functions */
static inline void
_fs_deinterleave (float ** src, float * dest[],
long frames, int channels, float mult_factor)
{
int i, j;
float * d, * s = (float *)src;
for (i = 0; i < frames; i++) {
for (j = 0; j < channels; j++) {
d = dest[j];
d[i] = s[i*channels + j] * mult_factor;
}
}
}
static inline void
_fs_interleave (float * src[], float ** dest,
long frames, int channels, float mult_factor)
{
int i, j;
float * s, * d = (float *)dest;
for (i = 0; i < frames; i++) {
for (j = 0; j < channels; j++) {
s = src[j];
d[i*channels + j] = s[i] * mult_factor;
}
}
}
#endif /* __FISH_SOUND_CONVERT_H__ */
libfishsound-1.0.0/src/libfishsound/fs_compat.h 0000644 0001750 0001750 00000003743 11021125461 016526 0000000 0000000 /*
Copyright (C) 2003 Commonwealth Scientific and Industrial Research
Organisation (CSIRO) Australia
Redistribution and use in source and binary forms, with or without
modification, are permitted provided that the following conditions
are met:
- Redistributions of source code must retain the above copyright
notice, this list of conditions and the following disclaimer.
- Redistributions in binary form must reproduce the above copyright
notice, this list of conditions and the following disclaimer in the
documentation and/or other materials provided with the distribution.
- Neither the name of CSIRO Australia nor the names of its
contributors may be used to endorse or promote products derived from
this software without specific prior written permission.
THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS
``AS IS'' AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT
LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A
PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE ORGANISATION OR
CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL,
EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO,
PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR
PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF
LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING
NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS
SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
*/
#include "config.h"
/* WINDOWS */
#ifdef _WIN32
#define inline __inline
#define alloca _alloca
#define strncasecmp _strnicmp
#define snprintf _snprintf
#ifndef __SYMBIAN32__
#define strcasecmp _stricmp
#endif /* ! __SYMBIAN32__ */
#endif
/* malloc/realloc/free macros */
#ifndef fs_malloc
#define fs_malloc malloc
#endif
#ifndef fs_realloc
#define fs_realloc realloc
#endif
#ifndef fs_free
#define fs_free free
#endif
libfishsound-1.0.0/src/libfishsound/fs_vector.h 0000644 0001750 0001750 00000005270 11005257656 016560 0000000 0000000 /*
Copyright (C) 2003 Commonwealth Scientific and Industrial Research
Organisation (CSIRO) Australia
Redistribution and use in source and binary forms, with or without
modification, are permitted provided that the following conditions
are met:
- Redistributions of source code must retain the above copyright
notice, this list of conditions and the following disclaimer.
- Redistributions in binary form must reproduce the above copyright
notice, this list of conditions and the following disclaimer in the
documentation and/or other materials provided with the distribution.
- Neither the name of CSIRO Australia nor the names of its
contributors may be used to endorse or promote products derived from
this software without specific prior written permission.
THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS
``AS IS'' AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT
LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A
PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE ORGANISATION OR
CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL,
EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO,
PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR
PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF
LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING
NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS
SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
*/
#ifndef __FS_VECTOR_H__
#define __FS_VECTOR_H__
typedef void FishSoundVector;
typedef int (*FishSoundFunc) (void * data);
typedef int (*FishSoundCmpFunc) (void * data1, void * data2);
FishSoundVector *
fs_vector_new (FishSoundCmpFunc cmp);
void
fs_vector_delete (FishSoundVector * vector);
void *
fs_vector_nth (FishSoundVector * vector, int n);
int
fs_vector_find_index (FishSoundVector * vector, const void * data);
void *
fs_vector_find (FishSoundVector * vector, const void * data);
int
fs_vector_foreach (FishSoundVector * vector, FishSoundFunc func);
int
fs_vector_size (FishSoundVector * vector);
/**
* Add an element to a vector.
* \param vector An FishSoundVector
* \param data The new element to add
* \retval data If the element was successfully added
* \retval NULL If adding the element failed due to a realloc() error
*/
void *
fs_vector_insert (FishSoundVector * vector, void * data);
/**
* Remove a (void *) element of a vector
* \retval \a vector on success
* \retval NULL on failure (realloc error)
*/
FishSoundVector *
fs_vector_remove (FishSoundVector * vector, void * data);
#endif /* __FS_VECTOR_H__ */
libfishsound-1.0.0/src/libfishsound/Makefile.am 0000644 0001750 0001750 00000001262 11332275512 016440 0000000 0000000 ## Process this file with automake to produce Makefile.in
AM_CFLAGS = -Wall -pedantic
INCLUDES = $(INCLTDL) \
-I$(top_builddir) \
-I$(top_srcdir)/include \
$(VORBIS_CFLAGS) $(SPEEX_CFLAGS) $(FLAC_CFLAGS)
EXTRA_DIST = Version_script.in
# Libraries to build
lib_LTLIBRARIES = libfishsound.la
noinst_HEADERS = \
debug.h \
private.h \
convert.h \
fs_compat.h \
fs_vector.h
libfishsound_la_SOURCES = \
fishsound.c \
decode.c \
encode.c \
comments.c \
speex.c \
vorbis.c \
flac.c \
fs_vector.c
libfishsound_la_LDFLAGS = -version-info @SHARED_VERSION_INFO@ @SHLIB_VERSION_ARG@
libfishsound_la_LIBADD = $(VORBIS_LIBS) $(SPEEX_LIBS) $(FLAC_LIBS)
libfishsound-1.0.0/src/libfishsound/Makefile.in 0000644 0001750 0001750 00000041456 11332275622 016464 0000000 0000000 # Makefile.in generated by automake 1.10.2 from Makefile.am.
# @configure_input@
# Copyright (C) 1994, 1995, 1996, 1997, 1998, 1999, 2000, 2001, 2002,
# 2003, 2004, 2005, 2006, 2007, 2008 Free Software Foundation, Inc.
# This Makefile.in is free software; the Free Software Foundation
# gives unlimited permission to copy and/or distribute it,
# with or without modifications, as long as this notice is preserved.
# This program is distributed in the hope that it will be useful,
# but WITHOUT ANY WARRANTY, to the extent permitted by law; without
# even the implied warranty of MERCHANTABILITY or FITNESS FOR A
# PARTICULAR PURPOSE.
@SET_MAKE@
VPATH = @srcdir@
pkgdatadir = $(datadir)/@PACKAGE@
pkglibdir = $(libdir)/@PACKAGE@
pkgincludedir = $(includedir)/@PACKAGE@
am__cd = CDPATH="$${ZSH_VERSION+.}$(PATH_SEPARATOR)" && cd
install_sh_DATA = $(install_sh) -c -m 644
install_sh_PROGRAM = $(install_sh) -c
install_sh_SCRIPT = $(install_sh) -c
INSTALL_HEADER = $(INSTALL_DATA)
transform = $(program_transform_name)
NORMAL_INSTALL = :
PRE_INSTALL = :
POST_INSTALL = :
NORMAL_UNINSTALL = :
PRE_UNINSTALL = :
POST_UNINSTALL = :
build_triplet = @build@
host_triplet = @host@
target_triplet = @target@
subdir = src/libfishsound
DIST_COMMON = $(noinst_HEADERS) $(srcdir)/Makefile.am \
$(srcdir)/Makefile.in $(srcdir)/Version_script.in
ACLOCAL_M4 = $(top_srcdir)/aclocal.m4
am__aclocal_m4_deps = $(top_srcdir)/m4/as-ac-expand.m4 \
$(top_srcdir)/configure.ac
am__configure_deps = $(am__aclocal_m4_deps) $(CONFIGURE_DEPENDENCIES) \
$(ACLOCAL_M4)
mkinstalldirs = $(install_sh) -d
CONFIG_HEADER = $(top_builddir)/config.h
CONFIG_CLEAN_FILES = Version_script
am__vpath_adj_setup = srcdirstrip=`echo "$(srcdir)" | sed 's|.|.|g'`;
am__vpath_adj = case $$p in \
$(srcdir)/*) f=`echo "$$p" | sed "s|^$$srcdirstrip/||"`;; \
*) f=$$p;; \
esac;
am__strip_dir = `echo $$p | sed -e 's|^.*/||'`;
am__installdirs = "$(DESTDIR)$(libdir)"
libLTLIBRARIES_INSTALL = $(INSTALL)
LTLIBRARIES = $(lib_LTLIBRARIES)
am__DEPENDENCIES_1 =
libfishsound_la_DEPENDENCIES = $(am__DEPENDENCIES_1) \
$(am__DEPENDENCIES_1) $(am__DEPENDENCIES_1)
am_libfishsound_la_OBJECTS = fishsound.lo decode.lo encode.lo \
comments.lo speex.lo vorbis.lo flac.lo fs_vector.lo
libfishsound_la_OBJECTS = $(am_libfishsound_la_OBJECTS)
libfishsound_la_LINK = $(LIBTOOL) --tag=CC $(AM_LIBTOOLFLAGS) \
$(LIBTOOLFLAGS) --mode=link $(CCLD) $(AM_CFLAGS) $(CFLAGS) \
$(libfishsound_la_LDFLAGS) $(LDFLAGS) -o $@
DEFAULT_INCLUDES = -I.@am__isrc@ -I$(top_builddir)
depcomp = $(SHELL) $(top_srcdir)/depcomp
am__depfiles_maybe = depfiles
COMPILE = $(CC) $(DEFS) $(DEFAULT_INCLUDES) $(INCLUDES) $(AM_CPPFLAGS) \
$(CPPFLAGS) $(AM_CFLAGS) $(CFLAGS)
LTCOMPILE = $(LIBTOOL) --tag=CC $(AM_LIBTOOLFLAGS) $(LIBTOOLFLAGS) \
--mode=compile $(CC) $(DEFS) $(DEFAULT_INCLUDES) $(INCLUDES) \
$(AM_CPPFLAGS) $(CPPFLAGS) $(AM_CFLAGS) $(CFLAGS)
CCLD = $(CC)
LINK = $(LIBTOOL) --tag=CC $(AM_LIBTOOLFLAGS) $(LIBTOOLFLAGS) \
--mode=link $(CCLD) $(AM_CFLAGS) $(CFLAGS) $(AM_LDFLAGS) \
$(LDFLAGS) -o $@
SOURCES = $(libfishsound_la_SOURCES)
DIST_SOURCES = $(libfishsound_la_SOURCES)
HEADERS = $(noinst_HEADERS)
ETAGS = etags
CTAGS = ctags
DISTFILES = $(DIST_COMMON) $(DIST_SOURCES) $(TEXINFOS) $(EXTRA_DIST)
ACLOCAL = @ACLOCAL@
ACLOCAL_AMFLAGS = @ACLOCAL_AMFLAGS@
AMTAR = @AMTAR@
AR = @AR@
AUTOCONF = @AUTOCONF@
AUTOHEADER = @AUTOHEADER@
AUTOMAKE = @AUTOMAKE@
AWK = @AWK@
BINDIR = @BINDIR@
CC = @CC@
CCDEPMODE = @CCDEPMODE@
CFLAGS = @CFLAGS@
CPP = @CPP@
CPPFLAGS = @CPPFLAGS@
CYGPATH_W = @CYGPATH_W@
DEFS = @DEFS@
DEPDIR = @DEPDIR@
DOCDIR = @DOCDIR@
DSYMUTIL = @DSYMUTIL@
DUMPBIN = @DUMPBIN@
ECHO_C = @ECHO_C@
ECHO_N = @ECHO_N@
ECHO_T = @ECHO_T@
EGREP = @EGREP@
EXEEXT = @EXEEXT@
FGREP = @FGREP@
FLAC_CFLAGS = @FLAC_CFLAGS@
FLAC_LIBS = @FLAC_LIBS@
GREP = @GREP@
HAVE_DOXYGEN = @HAVE_DOXYGEN@
HAVE_PKG_CONFIG = @HAVE_PKG_CONFIG@
HAVE_VALGRIND = @HAVE_VALGRIND@
INCLUDEDIR = @INCLUDEDIR@
INSTALL = @INSTALL@
INSTALL_DATA = @INSTALL_DATA@
INSTALL_PROGRAM = @INSTALL_PROGRAM@
INSTALL_SCRIPT = @INSTALL_SCRIPT@
INSTALL_STRIP_PROGRAM = @INSTALL_STRIP_PROGRAM@
LD = @LD@
LDFLAGS = @LDFLAGS@
LIBDIR = @LIBDIR@
LIBOBJS = @LIBOBJS@
LIBS = @LIBS@
LIBTOOL = @LIBTOOL@
LIPO = @LIPO@
LN_S = @LN_S@
LTLIBOBJS = @LTLIBOBJS@
MAKEINFO = @MAKEINFO@
MKDIR_P = @MKDIR_P@
NM = @NM@
NMEDIT = @NMEDIT@
OBJDUMP = @OBJDUMP@
OBJEXT = @OBJEXT@
OGGZ_CFLAGS = @OGGZ_CFLAGS@
OGGZ_LIBS = @OGGZ_LIBS@
OTOOL = @OTOOL@
OTOOL64 = @OTOOL64@
PACKAGE = @PACKAGE@
PACKAGE_BUGREPORT = @PACKAGE_BUGREPORT@
PACKAGE_NAME = @PACKAGE_NAME@
PACKAGE_STRING = @PACKAGE_STRING@
PACKAGE_TARNAME = @PACKAGE_TARNAME@
PACKAGE_VERSION = @PACKAGE_VERSION@
PATH_SEPARATOR = @PATH_SEPARATOR@
PKG_CONFIG = @PKG_CONFIG@
RANLIB = @RANLIB@
SED = @SED@
SET_MAKE = @SET_MAKE@
SHARED_VERSION_INFO = @SHARED_VERSION_INFO@
SHELL = @SHELL@
SHLIB_VERSION_ARG = @SHLIB_VERSION_ARG@
SNDFILE_CFLAGS = @SNDFILE_CFLAGS@
SNDFILE_LIBS = @SNDFILE_LIBS@
SPEEX_CFLAGS = @SPEEX_CFLAGS@
SPEEX_LIBS = @SPEEX_LIBS@
STRIP = @STRIP@
VALGRIND_ENVIRONMENT = @VALGRIND_ENVIRONMENT@
VERSION = @VERSION@
VORBISENC_CFLAGS = @VORBISENC_CFLAGS@
VORBISENC_LIBS = @VORBISENC_LIBS@
VORBIS_CFLAGS = @VORBIS_CFLAGS@
VORBIS_LIBS = @VORBIS_LIBS@
abs_builddir = @abs_builddir@
abs_srcdir = @abs_srcdir@
abs_top_builddir = @abs_top_builddir@
abs_top_srcdir = @abs_top_srcdir@
ac_ct_CC = @ac_ct_CC@
ac_ct_DUMPBIN = @ac_ct_DUMPBIN@
am__include = @am__include@
am__leading_dot = @am__leading_dot@
am__quote = @am__quote@
am__tar = @am__tar@
am__untar = @am__untar@
bindir = @bindir@
build = @build@
build_alias = @build_alias@
build_cpu = @build_cpu@
build_os = @build_os@
build_vendor = @build_vendor@
builddir = @builddir@
datadir = @datadir@
datarootdir = @datarootdir@
docdir = @docdir@
dvidir = @dvidir@
exec_prefix = @exec_prefix@
fishsound_pkgdeps = @fishsound_pkgdeps@
host = @host@
host_alias = @host_alias@
host_cpu = @host_cpu@
host_os = @host_os@
host_vendor = @host_vendor@
htmldir = @htmldir@
includedir = @includedir@
infodir = @infodir@
install_sh = @install_sh@
libdir = @libdir@
libexecdir = @libexecdir@
localedir = @localedir@
localstatedir = @localstatedir@
lt_ECHO = @lt_ECHO@
mandir = @mandir@
mkdir_p = @mkdir_p@
oldincludedir = @oldincludedir@
pdfdir = @pdfdir@
prefix = @prefix@
program_transform_name = @program_transform_name@
psdir = @psdir@
sbindir = @sbindir@
sharedstatedir = @sharedstatedir@
srcdir = @srcdir@
sysconfdir = @sysconfdir@
target = @target@
target_alias = @target_alias@
target_cpu = @target_cpu@
target_os = @target_os@
target_vendor = @target_vendor@
top_build_prefix = @top_build_prefix@
top_builddir = @top_builddir@
top_srcdir = @top_srcdir@
AM_CFLAGS = -Wall -pedantic
INCLUDES = $(INCLTDL) \
-I$(top_builddir) \
-I$(top_srcdir)/include \
$(VORBIS_CFLAGS) $(SPEEX_CFLAGS) $(FLAC_CFLAGS)
EXTRA_DIST = Version_script.in
# Libraries to build
lib_LTLIBRARIES = libfishsound.la
noinst_HEADERS = \
debug.h \
private.h \
convert.h \
fs_compat.h \
fs_vector.h
libfishsound_la_SOURCES = \
fishsound.c \
decode.c \
encode.c \
comments.c \
speex.c \
vorbis.c \
flac.c \
fs_vector.c
libfishsound_la_LDFLAGS = -version-info @SHARED_VERSION_INFO@ @SHLIB_VERSION_ARG@
libfishsound_la_LIBADD = $(VORBIS_LIBS) $(SPEEX_LIBS) $(FLAC_LIBS)
all: all-am
.SUFFIXES:
.SUFFIXES: .c .lo .o .obj
$(srcdir)/Makefile.in: $(srcdir)/Makefile.am $(am__configure_deps)
@for dep in $?; do \
case '$(am__configure_deps)' in \
*$$dep*) \
( cd $(top_builddir) && $(MAKE) $(AM_MAKEFLAGS) am--refresh ) \
&& { if test -f $@; then exit 0; else break; fi; }; \
exit 1;; \
esac; \
done; \
echo ' cd $(top_srcdir) && $(AUTOMAKE) --gnu src/libfishsound/Makefile'; \
cd $(top_srcdir) && \
$(AUTOMAKE) --gnu src/libfishsound/Makefile
.PRECIOUS: Makefile
Makefile: $(srcdir)/Makefile.in $(top_builddir)/config.status
@case '$?' in \
*config.status*) \
cd $(top_builddir) && $(MAKE) $(AM_MAKEFLAGS) am--refresh;; \
*) \
echo ' cd $(top_builddir) && $(SHELL) ./config.status $(subdir)/$@ $(am__depfiles_maybe)'; \
cd $(top_builddir) && $(SHELL) ./config.status $(subdir)/$@ $(am__depfiles_maybe);; \
esac;
$(top_builddir)/config.status: $(top_srcdir)/configure $(CONFIG_STATUS_DEPENDENCIES)
cd $(top_builddir) && $(MAKE) $(AM_MAKEFLAGS) am--refresh
$(top_srcdir)/configure: $(am__configure_deps)
cd $(top_builddir) && $(MAKE) $(AM_MAKEFLAGS) am--refresh
$(ACLOCAL_M4): $(am__aclocal_m4_deps)
cd $(top_builddir) && $(MAKE) $(AM_MAKEFLAGS) am--refresh
Version_script: $(top_builddir)/config.status $(srcdir)/Version_script.in
cd $(top_builddir) && $(SHELL) ./config.status $(subdir)/$@
install-libLTLIBRARIES: $(lib_LTLIBRARIES)
@$(NORMAL_INSTALL)
test -z "$(libdir)" || $(MKDIR_P) "$(DESTDIR)$(libdir)"
@list='$(lib_LTLIBRARIES)'; for p in $$list; do \
if test -f $$p; then \
f=$(am__strip_dir) \
echo " $(LIBTOOL) $(AM_LIBTOOLFLAGS) $(LIBTOOLFLAGS) --mode=install $(libLTLIBRARIES_INSTALL) $(INSTALL_STRIP_FLAG) '$$p' '$(DESTDIR)$(libdir)/$$f'"; \
$(LIBTOOL) $(AM_LIBTOOLFLAGS) $(LIBTOOLFLAGS) --mode=install $(libLTLIBRARIES_INSTALL) $(INSTALL_STRIP_FLAG) "$$p" "$(DESTDIR)$(libdir)/$$f"; \
else :; fi; \
done
uninstall-libLTLIBRARIES:
@$(NORMAL_UNINSTALL)
@list='$(lib_LTLIBRARIES)'; for p in $$list; do \
p=$(am__strip_dir) \
echo " $(LIBTOOL) $(AM_LIBTOOLFLAGS) $(LIBTOOLFLAGS) --mode=uninstall rm -f '$(DESTDIR)$(libdir)/$$p'"; \
$(LIBTOOL) $(AM_LIBTOOLFLAGS) $(LIBTOOLFLAGS) --mode=uninstall rm -f "$(DESTDIR)$(libdir)/$$p"; \
done
clean-libLTLIBRARIES:
-test -z "$(lib_LTLIBRARIES)" || rm -f $(lib_LTLIBRARIES)
@list='$(lib_LTLIBRARIES)'; for p in $$list; do \
dir="`echo $$p | sed -e 's|/[^/]*$$||'`"; \
test "$$dir" != "$$p" || dir=.; \
echo "rm -f \"$${dir}/so_locations\""; \
rm -f "$${dir}/so_locations"; \
done
libfishsound.la: $(libfishsound_la_OBJECTS) $(libfishsound_la_DEPENDENCIES)
$(libfishsound_la_LINK) -rpath $(libdir) $(libfishsound_la_OBJECTS) $(libfishsound_la_LIBADD) $(LIBS)
mostlyclean-compile:
-rm -f *.$(OBJEXT)
distclean-compile:
-rm -f *.tab.c
@AMDEP_TRUE@@am__include@ @am__quote@./$(DEPDIR)/comments.Plo@am__quote@
@AMDEP_TRUE@@am__include@ @am__quote@./$(DEPDIR)/decode.Plo@am__quote@
@AMDEP_TRUE@@am__include@ @am__quote@./$(DEPDIR)/encode.Plo@am__quote@
@AMDEP_TRUE@@am__include@ @am__quote@./$(DEPDIR)/fishsound.Plo@am__quote@
@AMDEP_TRUE@@am__include@ @am__quote@./$(DEPDIR)/flac.Plo@am__quote@
@AMDEP_TRUE@@am__include@ @am__quote@./$(DEPDIR)/fs_vector.Plo@am__quote@
@AMDEP_TRUE@@am__include@ @am__quote@./$(DEPDIR)/speex.Plo@am__quote@
@AMDEP_TRUE@@am__include@ @am__quote@./$(DEPDIR)/vorbis.Plo@am__quote@
.c.o:
@am__fastdepCC_TRUE@ $(COMPILE) -MT $@ -MD -MP -MF $(DEPDIR)/$*.Tpo -c -o $@ $<
@am__fastdepCC_TRUE@ mv -f $(DEPDIR)/$*.Tpo $(DEPDIR)/$*.Po
@AMDEP_TRUE@@am__fastdepCC_FALSE@ source='$<' object='$@' libtool=no @AMDEPBACKSLASH@
@AMDEP_TRUE@@am__fastdepCC_FALSE@ DEPDIR=$(DEPDIR) $(CCDEPMODE) $(depcomp) @AMDEPBACKSLASH@
@am__fastdepCC_FALSE@ $(COMPILE) -c $<
.c.obj:
@am__fastdepCC_TRUE@ $(COMPILE) -MT $@ -MD -MP -MF $(DEPDIR)/$*.Tpo -c -o $@ `$(CYGPATH_W) '$<'`
@am__fastdepCC_TRUE@ mv -f $(DEPDIR)/$*.Tpo $(DEPDIR)/$*.Po
@AMDEP_TRUE@@am__fastdepCC_FALSE@ source='$<' object='$@' libtool=no @AMDEPBACKSLASH@
@AMDEP_TRUE@@am__fastdepCC_FALSE@ DEPDIR=$(DEPDIR) $(CCDEPMODE) $(depcomp) @AMDEPBACKSLASH@
@am__fastdepCC_FALSE@ $(COMPILE) -c `$(CYGPATH_W) '$<'`
.c.lo:
@am__fastdepCC_TRUE@ $(LTCOMPILE) -MT $@ -MD -MP -MF $(DEPDIR)/$*.Tpo -c -o $@ $<
@am__fastdepCC_TRUE@ mv -f $(DEPDIR)/$*.Tpo $(DEPDIR)/$*.Plo
@AMDEP_TRUE@@am__fastdepCC_FALSE@ source='$<' object='$@' libtool=yes @AMDEPBACKSLASH@
@AMDEP_TRUE@@am__fastdepCC_FALSE@ DEPDIR=$(DEPDIR) $(CCDEPMODE) $(depcomp) @AMDEPBACKSLASH@
@am__fastdepCC_FALSE@ $(LTCOMPILE) -c -o $@ $<
mostlyclean-libtool:
-rm -f *.lo
clean-libtool:
-rm -rf .libs _libs
ID: $(HEADERS) $(SOURCES) $(LISP) $(TAGS_FILES)
list='$(SOURCES) $(HEADERS) $(LISP) $(TAGS_FILES)'; \
unique=`for i in $$list; do \
if test -f "$$i"; then echo $$i; else echo $(srcdir)/$$i; fi; \
done | \
$(AWK) '{ files[$$0] = 1; nonempty = 1; } \
END { if (nonempty) { for (i in files) print i; }; }'`; \
mkid -fID $$unique
tags: TAGS
TAGS: $(HEADERS) $(SOURCES) $(TAGS_DEPENDENCIES) \
$(TAGS_FILES) $(LISP)
tags=; \
here=`pwd`; \
list='$(SOURCES) $(HEADERS) $(LISP) $(TAGS_FILES)'; \
unique=`for i in $$list; do \
if test -f "$$i"; then echo $$i; else echo $(srcdir)/$$i; fi; \
done | \
$(AWK) '{ files[$$0] = 1; nonempty = 1; } \
END { if (nonempty) { for (i in files) print i; }; }'`; \
if test -z "$(ETAGS_ARGS)$$tags$$unique"; then :; else \
test -n "$$unique" || unique=$$empty_fix; \
$(ETAGS) $(ETAGSFLAGS) $(AM_ETAGSFLAGS) $(ETAGS_ARGS) \
$$tags $$unique; \
fi
ctags: CTAGS
CTAGS: $(HEADERS) $(SOURCES) $(TAGS_DEPENDENCIES) \
$(TAGS_FILES) $(LISP)
tags=; \
list='$(SOURCES) $(HEADERS) $(LISP) $(TAGS_FILES)'; \
unique=`for i in $$list; do \
if test -f "$$i"; then echo $$i; else echo $(srcdir)/$$i; fi; \
done | \
$(AWK) '{ files[$$0] = 1; nonempty = 1; } \
END { if (nonempty) { for (i in files) print i; }; }'`; \
test -z "$(CTAGS_ARGS)$$tags$$unique" \
|| $(CTAGS) $(CTAGSFLAGS) $(AM_CTAGSFLAGS) $(CTAGS_ARGS) \
$$tags $$unique
GTAGS:
here=`$(am__cd) $(top_builddir) && pwd` \
&& cd $(top_srcdir) \
&& gtags -i $(GTAGS_ARGS) $$here
distclean-tags:
-rm -f TAGS ID GTAGS GRTAGS GSYMS GPATH tags
distdir: $(DISTFILES)
@srcdirstrip=`echo "$(srcdir)" | sed 's/[].[^$$\\*]/\\\\&/g'`; \
topsrcdirstrip=`echo "$(top_srcdir)" | sed 's/[].[^$$\\*]/\\\\&/g'`; \
list='$(DISTFILES)'; \
dist_files=`for file in $$list; do echo $$file; done | \
sed -e "s|^$$srcdirstrip/||;t" \
-e "s|^$$topsrcdirstrip/|$(top_builddir)/|;t"`; \
case $$dist_files in \
*/*) $(MKDIR_P) `echo "$$dist_files" | \
sed '/\//!d;s|^|$(distdir)/|;s,/[^/]*$$,,' | \
sort -u` ;; \
esac; \
for file in $$dist_files; do \
if test -f $$file || test -d $$file; then d=.; else d=$(srcdir); fi; \
if test -d $$d/$$file; then \
dir=`echo "/$$file" | sed -e 's,/[^/]*$$,,'`; \
if test -d $(srcdir)/$$file && test $$d != $(srcdir); then \
cp -pR $(srcdir)/$$file $(distdir)$$dir || exit 1; \
fi; \
cp -pR $$d/$$file $(distdir)$$dir || exit 1; \
else \
test -f $(distdir)/$$file \
|| cp -p $$d/$$file $(distdir)/$$file \
|| exit 1; \
fi; \
done
check-am: all-am
check: check-am
all-am: Makefile $(LTLIBRARIES) $(HEADERS)
installdirs:
for dir in "$(DESTDIR)$(libdir)"; do \
test -z "$$dir" || $(MKDIR_P) "$$dir"; \
done
install: install-am
install-exec: install-exec-am
install-data: install-data-am
uninstall: uninstall-am
install-am: all-am
@$(MAKE) $(AM_MAKEFLAGS) install-exec-am install-data-am
installcheck: installcheck-am
install-strip:
$(MAKE) $(AM_MAKEFLAGS) INSTALL_PROGRAM="$(INSTALL_STRIP_PROGRAM)" \
install_sh_PROGRAM="$(INSTALL_STRIP_PROGRAM)" INSTALL_STRIP_FLAG=-s \
`test -z '$(STRIP)' || \
echo "INSTALL_PROGRAM_ENV=STRIPPROG='$(STRIP)'"` install
mostlyclean-generic:
clean-generic:
distclean-generic:
-test -z "$(CONFIG_CLEAN_FILES)" || rm -f $(CONFIG_CLEAN_FILES)
maintainer-clean-generic:
@echo "This command is intended for maintainers to use"
@echo "it deletes files that may require special tools to rebuild."
clean: clean-am
clean-am: clean-generic clean-libLTLIBRARIES clean-libtool \
mostlyclean-am
distclean: distclean-am
-rm -rf ./$(DEPDIR)
-rm -f Makefile
distclean-am: clean-am distclean-compile distclean-generic \
distclean-tags
dvi: dvi-am
dvi-am:
html: html-am
info: info-am
info-am:
install-data-am:
install-dvi: install-dvi-am
install-exec-am: install-libLTLIBRARIES
install-html: install-html-am
install-info: install-info-am
install-man:
install-pdf: install-pdf-am
install-ps: install-ps-am
installcheck-am:
maintainer-clean: maintainer-clean-am
-rm -rf ./$(DEPDIR)
-rm -f Makefile
maintainer-clean-am: distclean-am maintainer-clean-generic
mostlyclean: mostlyclean-am
mostlyclean-am: mostlyclean-compile mostlyclean-generic \
mostlyclean-libtool
pdf: pdf-am
pdf-am:
ps: ps-am
ps-am:
uninstall-am: uninstall-libLTLIBRARIES
.MAKE: install-am install-strip
.PHONY: CTAGS GTAGS all all-am check check-am clean clean-generic \
clean-libLTLIBRARIES clean-libtool ctags distclean \
distclean-compile distclean-generic distclean-libtool \
distclean-tags distdir dvi dvi-am html html-am info info-am \
install install-am install-data install-data-am install-dvi \
install-dvi-am install-exec install-exec-am install-html \
install-html-am install-info install-info-am \
install-libLTLIBRARIES install-man install-pdf install-pdf-am \
install-ps install-ps-am install-strip installcheck \
installcheck-am installdirs maintainer-clean \
maintainer-clean-generic mostlyclean mostlyclean-compile \
mostlyclean-generic mostlyclean-libtool pdf pdf-am ps ps-am \
tags uninstall uninstall-am uninstall-libLTLIBRARIES
# Tell versions [3.59,3.63) of GNU make to not export all variables.
# Otherwise a system limit (for SysV at least) may be exceeded.
.NOEXPORT:
libfishsound-1.0.0/src/libfishsound/Version_script.in 0000644 0001750 0001750 00000001755 11163316023 017747 0000000 0000000 #
# Export file for libfishsound
#
# Only the symbols listed in the global section will be callable from
# applications linking to libfishsound.
#
@PACKAGE@.so
{
global:
fish_sound_identify;
fish_sound_new;
fish_sound_set_decoded_callback;
fish_sound_set_encoded_callback;
fish_sound_decode;
fish_sound_encode;
fish_sound_reset;
fish_sound_flush;
fish_sound_delete;
fish_sound_command;
fish_sound_get_interleave;
fish_sound_set_interleave;
fish_sound_get_frameno;
fish_sound_set_frameno;
fish_sound_prepare_truncation;
fish_sound_set_decoded_float;
fish_sound_set_decoded_float_ilv;
fish_sound_encode_float;
fish_sound_encode_float_ilv;
fish_sound_comment_get_vendor;
fish_sound_comment_first;
fish_sound_comment_first_byname;
fish_sound_comment_next;
fish_sound_comment_next_byname;
fish_sound_comment_add;
fish_sound_comment_add_byname;
fish_sound_comment_remove;
fish_sound_comment_remove_byname;
local:
*;
};
libfishsound-1.0.0/src/libfishsound/fishsound.c 0000644 0001750 0001750 00000014137 11163316023 016552 0000000 0000000 /*
Copyright (C) 2003 Commonwealth Scientific and Industrial Research
Organisation (CSIRO) Australia
Redistribution and use in source and binary forms, with or without
modification, are permitted provided that the following conditions
are met:
- Redistributions of source code must retain the above copyright
notice, this list of conditions and the following disclaimer.
- Redistributions in binary form must reproduce the above copyright
notice, this list of conditions and the following disclaimer in the
documentation and/or other materials provided with the distribution.
- Neither the name of CSIRO Australia nor the names of its
contributors may be used to endorse or promote products derived from
this software without specific prior written permission.
THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS
``AS IS'' AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT
LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A
PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE ORGANISATION OR
CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL,
EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO,
PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR
PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF
LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING
NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS
SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
*/
#include "config.h"
#include
#include
#include "private.h"
int
fish_sound_identify (unsigned char * buf, long bytes)
{
if (bytes < 8) return FISH_SOUND_ERR_SHORT_IDENTIFY;
if (HAVE_VORBIS &&
fish_sound_vorbis_identify (buf, bytes) != FISH_SOUND_UNKNOWN)
return FISH_SOUND_VORBIS;
if (HAVE_SPEEX &&
fish_sound_speex_identify (buf, bytes) != FISH_SOUND_UNKNOWN)
return FISH_SOUND_SPEEX;
if (fish_sound_flac_identify (buf, bytes) != FISH_SOUND_UNKNOWN)
return FISH_SOUND_FLAC;
return FISH_SOUND_UNKNOWN;
}
int
fish_sound_set_format (FishSound * fsound, int format)
{
if (format == FISH_SOUND_VORBIS) {
fsound->codec = fish_sound_vorbis_codec ();
} else if (format == FISH_SOUND_SPEEX) {
fsound->codec = fish_sound_speex_codec ();
} else if (format == FISH_SOUND_FLAC) {
fsound->codec = fish_sound_flac_codec ();
} else {
return -1;
}
if (fsound->codec && fsound->codec->init)
if (fsound->codec->init (fsound) == NULL) return -1;
fsound->info.format = format;
return format;
}
FishSound *
fish_sound_new (int mode, FishSoundInfo * fsinfo)
{
FishSound * fsound;
if (!FS_DECODE && mode == FISH_SOUND_DECODE) return NULL;
if (!FS_ENCODE && mode == FISH_SOUND_ENCODE) return NULL;
if (mode == FISH_SOUND_ENCODE) {
if (fsinfo == NULL) {
return NULL;
} else {
if (!(HAVE_VORBIS && HAVE_VORBISENC)) {
if (fsinfo->format == FISH_SOUND_VORBIS) return NULL;
}
if (!HAVE_SPEEX) {
if (fsinfo->format == FISH_SOUND_SPEEX) return NULL;
}
if (!HAVE_FLAC) {
if (fsinfo->format == FISH_SOUND_FLAC) return NULL;
}
}
} else if (mode != FISH_SOUND_DECODE) {
return NULL;
}
fsound = fs_malloc (sizeof (FishSound));
if (fsound == NULL) return NULL;
fsound->mode = mode;
fsound->interleave = 0;
fsound->frameno = 0;
fsound->next_granulepos = -1;
fsound->next_eos = 0;
fsound->codec = NULL;
fsound->codec_data = NULL;
fsound->callback.encoded = NULL;
fsound->user_data = NULL;
fish_sound_comments_init (fsound);
if (mode == FISH_SOUND_DECODE) {
fsound->info.samplerate = 0;
fsound->info.channels = 0;
fsound->info.format = FISH_SOUND_UNKNOWN;
} else if (mode == FISH_SOUND_ENCODE) {
fsound->info.samplerate = fsinfo->samplerate;
fsound->info.channels = fsinfo->channels;
fsound->info.format = fsinfo->format;
if (fish_sound_set_format (fsound, fsinfo->format) == -1) {
fs_free (fsound);
return NULL;
}
}
return fsound;
}
long
fish_sound_flush (FishSound * fsound)
{
if (fsound == NULL) return -1;
if (fsound->codec && fsound->codec->flush)
return fsound->codec->flush (fsound);
return 0;
}
int
fish_sound_reset (FishSound * fsound)
{
if (fsound == NULL) return -1;
if (fsound->codec && fsound->codec->reset)
return fsound->codec->reset (fsound);
return 0;
}
FishSound *
fish_sound_delete (FishSound * fsound)
{
if (fsound == NULL) return NULL;
if (fsound->codec && fsound->codec->del)
fsound->codec->del (fsound);
fs_free (fsound->codec);
fish_sound_comments_free (fsound);
fs_free (fsound);
return NULL;
}
int
fish_sound_command (FishSound * fsound, int command, void * data, int datasize)
{
FishSoundInfo * fsinfo = (FishSoundInfo *)data;
int * pi = (int *)data;
if (fsound == NULL) return -1;
switch (command) {
case FISH_SOUND_GET_INFO:
memcpy (fsinfo, &fsound->info, sizeof (FishSoundInfo));
break;
case FISH_SOUND_GET_INTERLEAVE:
*pi = fsound->interleave;
break;
case FISH_SOUND_SET_INTERLEAVE:
fsound->interleave = (*pi ? 1 : 0);
break;
default:
if (fsound->codec && fsound->codec->command)
return fsound->codec->command (fsound, command, data, datasize);
break;
}
return 0;
}
int
fish_sound_get_interleave (FishSound * fsound)
{
if (fsound == NULL) return -1;
return fsound->interleave;
}
#ifndef FS_DISABLE_DEPRECATED
int
fish_sound_set_interleave (FishSound * fsound, int interleave)
{
if (fsound == NULL) return -1;
fsound->interleave = (interleave ? 1 : 0);
return 0;
}
#endif
long
fish_sound_get_frameno (FishSound * fsound)
{
if (fsound == NULL) return -1L;
return fsound->frameno;
}
int
fish_sound_set_frameno (FishSound * fsound, long frameno)
{
if (fsound == NULL) return -1;
fsound->frameno = frameno;
return 0;
}
int
fish_sound_prepare_truncation (FishSound * fsound, long next_granulepos,
int next_eos)
{
if (fsound == NULL) return -1;
fsound->next_granulepos = next_granulepos;
fsound->next_eos = next_eos;
return 0;
}
libfishsound-1.0.0/src/libfishsound/decode.c 0000644 0001750 0001750 00000007154 11163316023 015774 0000000 0000000 /*
Copyright (C) 2003 Commonwealth Scientific and Industrial Research
Organisation (CSIRO) Australia
Redistribution and use in source and binary forms, with or without
modification, are permitted provided that the following conditions
are met:
- Redistributions of source code must retain the above copyright
notice, this list of conditions and the following disclaimer.
- Redistributions in binary form must reproduce the above copyright
notice, this list of conditions and the following disclaimer in the
documentation and/or other materials provided with the distribution.
- Neither the name of CSIRO Australia nor the names of its
contributors may be used to endorse or promote products derived from
this software without specific prior written permission.
THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS
``AS IS'' AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT
LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A
PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE ORGANISATION OR
CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL,
EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO,
PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR
PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF
LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING
NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS
SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
*/
#include "config.h"
#include
#include
#include "private.h"
static int
fs_decode_update (FishSound * fsound, int interleave)
{
int ret = 0;
if (fsound->codec && fsound->codec->update)
ret = fsound->codec->update (fsound, interleave);
if (ret >= 0) {
fsound->interleave = interleave;
}
return ret;
}
int fish_sound_set_decoded_float (FishSound * fsound,
FishSoundDecoded_Float decoded,
void * user_data)
{
int ret = 0;
if (fsound == NULL) return FISH_SOUND_ERR_BAD;
#if FS_DECODE
ret = fs_decode_update (fsound, 0);
if (ret >= 0) {
fsound->callback.decoded_float = decoded;
fsound->user_data = user_data;
}
#else
return FISH_SOUND_ERR_DISABLED;
#endif
return ret;
}
int fish_sound_set_decoded_float_ilv (FishSound * fsound,
FishSoundDecoded_FloatIlv decoded,
void * user_data)
{
int ret = 0;
if (fsound == NULL) return FISH_SOUND_ERR_BAD;
#if FS_DECODE
ret = fs_decode_update (fsound, 1);
if (ret >= 0) {
fsound->callback.decoded_float_ilv = decoded;
fsound->user_data = user_data;
}
#else
return FISH_SOUND_ERR_DISABLED;
#endif
return ret;
}
long
fish_sound_decode (FishSound * fsound, unsigned char * buf, long bytes)
{
int format;
if (fsound == NULL) return FISH_SOUND_ERR_BAD;
#if FS_DECODE
if (fsound->info.format == FISH_SOUND_UNKNOWN) {
format = fish_sound_identify (buf, bytes);
if (format == FISH_SOUND_UNKNOWN) return -1;
fish_sound_set_format (fsound, format);
}
/*printf ("format: %s\n", fsound->codec->format->name);*/
if (fsound->codec && fsound->codec->decode)
return fsound->codec->decode (fsound, buf, bytes);
#else
return FISH_SOUND_ERR_DISABLED;
#endif
return 0;
}
/* DEPRECATED */
int fish_sound_set_decoded_callback (FishSound * fsound,
FishSoundDecoded_Float decoded,
void * user_data)
{
if (fsound == NULL) return -1;
return fsound->interleave ?
fish_sound_set_decoded_float_ilv (fsound, decoded, user_data) :
fish_sound_set_decoded_float (fsound, decoded, user_data);
}
libfishsound-1.0.0/src/libfishsound/encode.c 0000644 0001750 0001750 00000006026 11332275512 016010 0000000 0000000 /*
Copyright (C) 2003 Commonwealth Scientific and Industrial Research
Organisation (CSIRO) Australia
Redistribution and use in source and binary forms, with or without
modification, are permitted provided that the following conditions
are met:
- Redistributions of source code must retain the above copyright
notice, this list of conditions and the following disclaimer.
- Redistributions in binary form must reproduce the above copyright
notice, this list of conditions and the following disclaimer in the
documentation and/or other materials provided with the distribution.
- Neither the name of CSIRO Australia nor the names of its
contributors may be used to endorse or promote products derived from
this software without specific prior written permission.
THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS
``AS IS'' AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT
LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A
PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE ORGANISATION OR
CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL,
EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO,
PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR
PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF
LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING
NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS
SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
*/
#include "config.h"
#include
#include
#include "private.h"
int
fish_sound_set_encoded_callback (FishSound * fsound,
FishSoundEncoded encoded,
void * user_data)
{
if (fsound == NULL) return -1;
#if FS_ENCODE
fsound->callback.encoded = encoded;
fsound->user_data = user_data;
#else
return FISH_SOUND_ERR_DISABLED;
#endif
return 0;
}
long fish_sound_encode_float (FishSound * fsound, float * pcm[], long frames)
{
if (fsound == NULL) return -1;
#if FS_ENCODE
if (fsound->codec && fsound->codec->encode_f)
return fsound->codec->encode_f (fsound, pcm, frames);
#else
return FISH_SOUND_ERR_DISABLED;
#endif
return 0;
}
long fish_sound_encode_float_ilv (FishSound * fsound, float ** pcm,
long frames)
{
if (fsound == NULL) return -1;
#if FS_ENCODE
if (fsound->codec && fsound->codec->encode_f_ilv)
return fsound->codec->encode_f_ilv (fsound, pcm, frames);
#else
return FISH_SOUND_ERR_DISABLED;
#endif
return 0;
}
#ifndef FS_DISABLE_DEPRECATED
long
fish_sound_encode (FishSound * fsound, float ** pcm, long frames)
{
if (fsound == NULL) return -1;
#if FS_ENCODE
if (fsound->interleave) {
if (fsound->codec && fsound->codec->encode_f_ilv)
return fsound->codec->encode_f_ilv (fsound, pcm, frames);
} else {
if (fsound->codec && fsound->codec->encode_f)
return fsound->codec->encode_f (fsound, pcm, frames);
}
#else
return FISH_SOUND_ERR_DISABLED;
#endif
return 0;
}
#endif /* DEPRECATED */
libfishsound-1.0.0/src/libfishsound/comments.c 0000644 0001750 0001750 00000040200 11332275512 016370 0000000 0000000 /*
Copyright (C) 2003 Commonwealth Scientific and Industrial Research
Organisation (CSIRO) Australia
Redistribution and use in source and binary forms, with or without
modification, are permitted provided that the following conditions
are met:
- Redistributions of source code must retain the above copyright
notice, this list of conditions and the following disclaimer.
- Redistributions in binary form must reproduce the above copyright
notice, this list of conditions and the following disclaimer in the
documentation and/or other materials provided with the distribution.
- Neither the name of CSIRO Australia nor the names of its
contributors may be used to endorse or promote products derived from
this software without specific prior written permission.
THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS
``AS IS'' AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT
LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A
PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE ORGANISATION OR
CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL,
EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO,
PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR
PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF
LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING
NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS
SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
*/
#include "config.h"
#include
#include
#include
#include /* ULONG_MAX */
#ifndef WIN32
#include
#endif
#include "private.h"
/*#define DEBUG*/
#include "debug.h"
/* Ensure comment vector length can be expressed in 32 bits
* including space for the trailing NUL */
#define MAX_COMMENT_LENGTH 0xFFFFFFFE
#define fs_comment_clamp(c) MIN((c),MAX_COMMENT_LENGTH)
static size_t
fs_comment_len (const char * s)
{
size_t len;
if (s == NULL) return 0;
len = strlen (s);
return fs_comment_clamp(len);
}
static char *
fs_strdup (const char * s)
{
char * ret;
if (s == NULL) return NULL;
ret = fs_malloc (fs_comment_len(s) + 1);
if (ret == NULL) return NULL;
return strcpy (ret, s);
}
static char *
fs_strdup_len (const char * s, size_t len)
{
char * ret;
if (s == NULL) return NULL;
if (len == 0) return NULL;
len = fs_comment_clamp(len);
ret = fs_malloc (len + 1);
if (ret == NULL) return NULL;
if (strncpy (ret, s, len) == NULL) {
fs_free (ret);
return NULL;
}
ret[len] = '\0';
return ret;
}
static char *
fs_index_len (const char * s, char c, int len)
{
int i;
for (i = 0; *s && i < len; i++, s++) {
if (*s == c) return (char *)s;
}
if (i < len) return (char *)s;
return NULL;
}
/*
Comments will be stored in the Vorbis style.
It is describled in the "Structure" section of
http://www.xiph.org/ogg/vorbis/doc/v-comment.html
The comment header is decoded as follows:
1) [vendor_length] = read an unsigned integer of 32 bits
2) [vendor_string] = read a UTF-8 vector as [vendor_length] octets
3) [user_comment_list_length] = read an unsigned integer of 32 bits
4) iterate [user_comment_list_length] times {
5) [length] = read an unsigned integer of 32 bits
6) this iteration's user comment = read a UTF-8 vector as [length] octets
}
7) [framing_bit] = read a single bit as boolean
8) if ( [framing_bit] unset or end of packet ) then ERROR
9) done.
If you have troubles, please write to ymnk@jcraft.com.
*/
#define readint(buf, base) (((buf[base+3]<<24)&0xff000000)| \
((buf[base+2]<<16)&0xff0000)| \
((buf[base+1]<<8)&0xff00)| \
(buf[base]&0xff))
#define writeint(buf, base, val) do{ buf[base+3]=((val)>>24)&0xff; \
buf[base+2]=((val)>>16)&0xff; \
buf[base+1]=((val)>>8)&0xff; \
buf[base]=(val)&0xff; \
}while(0)
static int
fs_comment_validate_byname (const char * name)
{
const char * c;
if (!name) return 0;
for (c = name; *c; c++) {
if (*c < 0x20 || *c > 0x7D || *c == 0x3D) {
debug_printf (1, "XXX char %c in %s invalid", *c, name);
return 0;
}
}
/* XXX: we really should validate value as UTF-8 here, but ... */
return 1;
}
static FishSoundComment *
fs_comment_new (const char * name, const char * value)
{
FishSoundComment * comment;
if (!fs_comment_validate_byname (name)) return NULL;
/* Ensures that name != NULL and contains only valid characters */
comment = fs_malloc (sizeof (FishSoundComment));
if (comment == NULL) return NULL;
comment->name = fs_strdup (name);
if (comment->name == NULL) {
fs_free (comment);
return NULL;
}
if (value) {
comment->value = fs_strdup (value);
if (comment->value == NULL) {
fs_free (comment->name);
fs_free (comment);
return NULL;
}
} else {
comment->value = NULL;
}
return comment;
}
static void
fs_comment_free (FishSoundComment * comment)
{
if (!comment) return;
if (comment->name) fs_free (comment->name);
if (comment->value) fs_free (comment->value);
fs_free (comment);
}
static int
fs_comment_cmp (const FishSoundComment * comment1, const FishSoundComment * comment2)
{
if (comment1 == comment2) return 1;
if (!comment1 || !comment2) return 0;
if (strcasecmp (comment1->name, comment2->name)) return 0;
if (strcmp (comment1->value, comment2->value)) return 0;
return 1;
}
int
fish_sound_comment_set_vendor (FishSound * fsound, const char * vendor_string)
{
if (fsound == NULL) return FISH_SOUND_ERR_BAD;
if (fsound->vendor) fs_free (fsound->vendor);
if ((fsound->vendor = fs_strdup (vendor_string)) == NULL)
return FISH_SOUND_ERR_OUT_OF_MEMORY;
return 0;
}
/* Public API */
const char *
fish_sound_comment_get_vendor (FishSound * fsound)
{
if (fsound == NULL) return NULL;
return fsound->vendor;
}
const FishSoundComment *
fish_sound_comment_first (FishSound * fsound)
{
if (fsound == NULL) return NULL;
return fs_vector_nth (fsound->comments, 0);
}
const FishSoundComment *
fish_sound_comment_first_byname (FishSound * fsound, char * name)
{
FishSoundComment * comment;
int i;
if (fsound == NULL) return NULL;
if (name == NULL) return fs_vector_nth (fsound->comments, 0);
if (!fs_comment_validate_byname (name))
return NULL;
for (i = 0; i < fs_vector_size (fsound->comments); i++) {
comment = (FishSoundComment *) fs_vector_nth (fsound->comments, i);
if (comment->name && !strcasecmp (name, comment->name))
return comment;
}
return NULL;
}
const FishSoundComment *
fish_sound_comment_next (FishSound * fsound, const FishSoundComment * comment)
{
int i;
if (fsound == NULL || comment == NULL) return NULL;
i = fs_vector_find_index (fsound->comments, comment);
return fs_vector_nth (fsound->comments, i+1);
}
const FishSoundComment *
fish_sound_comment_next_byname (FishSound * fsound,
const FishSoundComment * comment)
{
FishSoundComment * v_comment;
int i;
if (fsound == NULL || comment == NULL) return NULL;
i = fs_vector_find_index (fsound->comments, comment);
for (i++; i < fs_vector_size (fsound->comments); i++) {
v_comment = (FishSoundComment *) fs_vector_nth (fsound->comments, i);
if (v_comment->name && !strcasecmp (comment->name, v_comment->name))
return v_comment;
}
return NULL;
}
#define _fs_comment_add(f,c) fs_vector_insert ((f)->comments, (c))
int
fish_sound_comment_add (FishSound * fsound, FishSoundComment * comment)
{
#if FS_ENCODE
FishSoundComment * new_comment;
#endif
if (fsound == NULL) return FISH_SOUND_ERR_BAD;
if (fsound->mode != FISH_SOUND_ENCODE)
return FISH_SOUND_ERR_INVALID;
#if FS_ENCODE
if (!fs_comment_validate_byname (comment->name))
return FISH_SOUND_ERR_COMMENT_INVALID;
if ((new_comment = fs_comment_new (comment->name, comment->value)) == NULL)
return FISH_SOUND_ERR_OUT_OF_MEMORY;
if (_fs_comment_add (fsound, new_comment) == NULL)
return FISH_SOUND_ERR_OUT_OF_MEMORY;
return FISH_SOUND_OK;
#else
return FISH_SOUND_ERR_DISABLED;
#endif
}
int
fish_sound_comment_add_byname (FishSound * fsound, const char * name,
const char * value)
{
#if FS_ENCODE
FishSoundComment * comment;
#endif
if (fsound == NULL) return FISH_SOUND_ERR_BAD;
if (fsound->mode != FISH_SOUND_ENCODE)
return FISH_SOUND_ERR_INVALID;
#if FS_ENCODE
if (!fs_comment_validate_byname (name))
return FISH_SOUND_ERR_COMMENT_INVALID;
if ((comment = fs_comment_new (name, value)) == NULL)
return FISH_SOUND_ERR_OUT_OF_MEMORY;
if (_fs_comment_add (fsound, comment) == NULL)
return FISH_SOUND_ERR_OUT_OF_MEMORY;
return FISH_SOUND_OK;
return 0;
#else
return FISH_SOUND_ERR_DISABLED;
#endif
}
int
fish_sound_comment_remove (FishSound * fsound, FishSoundComment * comment)
{
#if FS_ENCODE
FishSoundComment * v_comment;
#endif
if (fsound == NULL) return FISH_SOUND_ERR_BAD;
if (fsound->mode != FISH_SOUND_ENCODE)
return FISH_SOUND_ERR_INVALID;
#if FS_ENCODE
v_comment = fs_vector_find (fsound->comments, comment);
if (v_comment == NULL) return 0;
fs_vector_remove (fsound->comments, v_comment);
fs_comment_free (v_comment);
return 1;
#else
return FISH_SOUND_ERR_DISABLED;
#endif
}
int
fish_sound_comment_remove_byname (FishSound * fsound, char * name)
{
#if FS_ENCODE
FishSoundComment * comment;
int i;
#endif
int ret = 0;
if (fsound == NULL) return FISH_SOUND_ERR_BAD;
if (fsound->mode != FISH_SOUND_ENCODE)
return FISH_SOUND_ERR_INVALID;
#if FS_ENCODE
for (i = 0; i < fs_vector_size (fsound->comments); i++) {
comment = (FishSoundComment *) fs_vector_nth (fsound->comments, i);
if (!strcasecmp (name, comment->name)) {
fish_sound_comment_remove (fsound, comment);
i--;
ret++;
}
}
return ret;
#else
return FISH_SOUND_ERR_DISABLED;
#endif
}
/* Internal API */
int
fish_sound_comments_init (FishSound * fsound)
{
fsound->vendor = NULL;
fsound->comments = fs_vector_new ((FishSoundCmpFunc) fs_comment_cmp);
return 0;
}
int
fish_sound_comments_free (FishSound * fsound)
{
fs_vector_foreach (fsound->comments, (FishSoundFunc)fs_comment_free);
fs_vector_delete (fsound->comments);
fsound->comments = NULL;
if (fsound->vendor) fs_free (fsound->vendor);
fsound->vendor = NULL;
return 0;
}
int
fish_sound_comments_decode (FishSound * fsound, unsigned char * comments,
long length)
{
char *c= (char *)comments;
int i, nb_fields, n;
size_t len;
char *end;
char * name, * value, * nvalue = NULL;
FishSoundComment * comment;
if (length<8)
return -1;
end = c+length;
len=readint(c, 0);
c+=4;
if (len > (unsigned long) length - 4) return -1;
/* Vendor */
if (len > 0) {
if ((nvalue = fs_strdup_len (c, len)) == NULL)
return FISH_SOUND_ERR_OUT_OF_MEMORY;
if (fish_sound_comment_set_vendor (fsound, nvalue) == FISH_SOUND_ERR_OUT_OF_MEMORY) {
fs_free (nvalue);
return FISH_SOUND_ERR_OUT_OF_MEMORY;
}
fs_free (nvalue);
}
#ifdef DEBUG
fwrite(c, 1, len, stderr); fputc ('\n', stderr);
#endif
c+=len;
if (c+4>end) return -1;
/* This value gets checked effectively by the 'for' condition
and the checks within the loop for c running off the end. */
nb_fields=readint(c, 0);
debug_printf (1, "%d comments", nb_fields);
c+=4;
for (i=0;iend) return -1;
len=readint(c, 0);
debug_printf (1, "[%d] len %d\n", i, len);
c+=4;
if (len > (unsigned long) (end-c)) return -1;
n = 0;
name = c;
value = fs_index_len (c, '=', len);
if (value) {
*value = '\0';
value++;
n = c+len - value;
}
if (n != 0) {
if ((nvalue = fs_strdup_len (value, n)) == NULL)
return FISH_SOUND_ERR_OUT_OF_MEMORY;
debug_printf (1, "[%d] %s -> %s (length %d)", i, name, nvalue, n);
if ((comment = fs_comment_new (name, nvalue)) == NULL) {
fs_free (nvalue);
return FISH_SOUND_ERR_OUT_OF_MEMORY;
}
if (_fs_comment_add (fsound, comment) == NULL) {
fs_free (nvalue);
return FISH_SOUND_ERR_OUT_OF_MEMORY;
}
fs_free (nvalue);
} else {
/* For the case of a comment which is not in key=value form,
* duplicate exactly the length of the comment, as it is
* not NUL-terminated. In the case of the last comment of the
* packet, it will be followed immediately by a framing bit.
*/
if ((nvalue = fs_strdup_len (name, len)) == NULL)
return FISH_SOUND_ERR_OUT_OF_MEMORY;
debug_printf (1, "[%d] %s (no value) (length %d)", i, nvalue, len);
if ((comment = fs_comment_new (nvalue, NULL)) == NULL) {
fs_free (nvalue);
return FISH_SOUND_ERR_OUT_OF_MEMORY;
}
if (_fs_comment_add (fsound, comment) == NULL) {
fs_free (nvalue);
return FISH_SOUND_ERR_OUT_OF_MEMORY;
}
fs_free (nvalue);
}
c+=len;
}
debug_printf (1, "OUT");
return FISH_SOUND_OK;
}
/*
* Pre-condition: at least one of accum, delta are non-zero,
* ie. don't call accum_length (0, 0);
* \retval 0 Failure: integer overflow
*/
static unsigned long
accum_length (unsigned long * accum, unsigned long delta)
{
/* Pre-condition: don't call accum_length (0, 0) */
if (*accum == 0 && delta == 0)
return 0;
/* Check for integer overflow */
if (delta > ULONG_MAX - (*accum))
return 0;
*accum += delta;
return *accum;
}
long
fish_sound_comments_encode (FishSound * fsound, unsigned char * buf,
long length)
{
char * c = (char *)buf;
const FishSoundComment * comment;
int nb_fields = 0, vendor_length = 0;
unsigned long actual_length = 0, remaining = length, field_length;
/* Vendor string */
if (fsound->vendor)
vendor_length = fs_comment_len (fsound->vendor);
if (accum_length (&actual_length, 4 + vendor_length) == 0)
return 0;
/* user comment list length */
if (accum_length (&actual_length, 4) == 0)
return 0;
for (comment = fish_sound_comment_first (fsound); comment;
comment = fish_sound_comment_next (fsound, comment)) {
/* [size]"name" */
if (accum_length (&actual_length, 4 + fs_comment_len (comment->name)) == 0)
return 0;
if (comment->value) {
/* "=value" */
if (accum_length (&actual_length, 1 + fs_comment_len (comment->value)) == 0)
return 0;
}
debug_printf (1, "%s = %s", comment->name, comment->value);
nb_fields++;
}
/* framing bit */
if (accum_length (&actual_length, 1) == 0)
return 0;
/* NB. actual_length is not modified from here onwards */
if (buf == NULL) return actual_length;
remaining -= 4;
if (remaining <= 0) return actual_length;
writeint (c, 0, vendor_length);
c += 4;
if (fsound->vendor) {
field_length = fs_comment_len (fsound->vendor);
memcpy (c, fsound->vendor, MIN (field_length, remaining));
c += field_length; remaining -= field_length;
if (remaining <= 0) return actual_length;
}
remaining -= 4;
if (remaining <= 0) return actual_length;
writeint (c, 0, nb_fields);
c += 4;
for (comment = fish_sound_comment_first (fsound); comment;
comment = fish_sound_comment_next (fsound, comment)) {
field_length = fs_comment_len (comment->name); /* [size]"name" */
if (comment->value)
field_length += 1 + fs_comment_len (comment->value); /* "=value" */
remaining -= 4;
if (remaining <= 0) return actual_length;
writeint (c, 0, field_length);
c += 4;
field_length = fs_comment_len (comment->name);
memcpy (c, comment->name, MIN (field_length, remaining));
c += field_length; remaining -= field_length;
if (remaining <= 0) return actual_length;
if (comment->value) {
remaining --;
if (remaining <= 0) return actual_length;
*c = '=';
c++;
field_length = fs_comment_len (comment->value);
memcpy (c, comment->value, MIN (field_length, remaining));
c += field_length; remaining -= field_length;
if (remaining <= 0) return actual_length;
}
}
if (remaining <= 0) return actual_length;
*c = 0x01;
return actual_length;
}
libfishsound-1.0.0/src/libfishsound/speex.c 0000644 0001750 0001750 00000051237 11332275512 015703 0000000 0000000 /*
Copyright (C) 2003 Commonwealth Scientific and Industrial Research
Organisation (CSIRO) Australia
Redistribution and use in source and binary forms, with or without
modification, are permitted provided that the following conditions
are met:
- Redistributions of source code must retain the above copyright
notice, this list of conditions and the following disclaimer.
- Redistributions in binary form must reproduce the above copyright
notice, this list of conditions and the following disclaimer in the
documentation and/or other materials provided with the distribution.
- Neither the name of CSIRO Australia nor the names of its
contributors may be used to endorse or promote products derived from
this software without specific prior written permission.
THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS
``AS IS'' AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT
LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A
PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE ORGANISATION OR
CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL,
EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO,
PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR
PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF
LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING
NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS
SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
*/
#include "config.h"
#include
#include
#include
#if HAVE_STDINT_H
#include
#endif
#include
#include "private.h"
#include "convert.h"
/*#define DEBUG*/
#include "debug.h"
#if HAVE_SPEEX
#if HAVE_SPEEX_1_1
#include
#include
#include
#include
#else /* Speex 1.0 */
#include
#include
#include
#include
#endif
/* Format for the vendor string: "Encoded with Speex VERSION", where VERSION
* is the libspeex version as read from a newly-generated Speex header.
*/
#define VENDOR_FORMAT "Encoded with Speex %s"
#define DEFAULT_ENH_ENABLED 1
#define MAX_FRAME_BYTES 2000
typedef struct _FishSoundSpeexEnc {
int frame_offset; /* number of speex frames done in this packet */
int pcm_offset;
char cbits[MAX_FRAME_BYTES];
int id;
} FishSoundSpeexEnc;
typedef struct _FishSoundSpeexInfo {
int packetno;
void * st;
SpeexBits bits;
int frame_size;
int nframes;
int extra_headers;
SpeexStereoState stereo;
int pcm_len; /* nr frames in pcm */
float * ipcm; /* interleaved pcm */
float * pcm[2]; /* Speex does max 2 channels */
FishSoundSpeexEnc * enc;
} FishSoundSpeexInfo;
int
fish_sound_speex_identify (unsigned char * buf, long bytes)
{
SpeexHeader * header;
if (bytes < 8) return FISH_SOUND_UNKNOWN;
if (!strncmp ((char *)buf, "Speex ", 8)) {
/* if only a short buffer was passed, do a weak identify */
if (bytes == 8) return FISH_SOUND_SPEEX;
/* otherwise, assume the buffer is an entire initial header and
* feed it to speex_packet_to_header() */
if ((header = speex_packet_to_header ((char *)buf, (int)bytes)) != NULL) {
fs_free(header);
return FISH_SOUND_SPEEX;
}
}
return FISH_SOUND_UNKNOWN;
}
static int
fs_speex_command (FishSound * fsound, int command, void * data, int datasize)
{
return 0;
}
#if FS_DECODE
static void *
process_header(unsigned char * buf, long bytes, int enh_enabled,
int * frame_size, int * rate,
int * nframes, int forceMode, int * channels,
SpeexStereoState * stereo, int * extra_headers)
{
void *st;
SpeexMode *mode;
SpeexHeader *header;
int modeID;
SpeexCallback callback;
header = speex_packet_to_header((char*)buf, (int)bytes);
if (!header) {
/* cannot read header */
return NULL;
}
if (header->mode >= SPEEX_NB_MODES || header->mode < 0) {
/* Mode number does not (any longer) exist in this version */
return NULL;
}
modeID = header->mode;
if (forceMode!=-1)
modeID = forceMode;
#if HAVE_SPEEX_LIB_GET_MODE
mode = (SpeexMode *) speex_lib_get_mode (modeID);
#else
/* speex_mode_list[] is declared const in speex 1.1.x, hence the cast */
mode = (SpeexMode *)speex_mode_list[modeID];
#endif
if (header->speex_version_id > 1) {
/* Unknown bitstream version */
return NULL;
}
if (mode->bitstream_version < header->mode_bitstream_version) {
/* The file was encoded with a newer version of Speex,
* need to upgrade in order to play it */
return NULL;
}
if (mode->bitstream_version > header->mode_bitstream_version) {
/* The file was encoded with an older version of Speex.
* You would need to downgrade the version in order to play it */
return NULL;
}
st = speex_decoder_init(mode);
if (!st) {
/* Decoder initialization failed */
return NULL;
}
speex_decoder_ctl(st, SPEEX_SET_ENH, &enh_enabled);
speex_decoder_ctl(st, SPEEX_GET_FRAME_SIZE, frame_size);
if (!(*channels==1))
{
callback.callback_id = SPEEX_INBAND_STEREO;
callback.func = speex_std_stereo_request_handler;
callback.data = stereo;
speex_decoder_ctl(st, SPEEX_SET_HANDLER, &callback);
}
if (!*rate)
*rate = header->rate;
/* Adjust rate if --force-* options are used */
if (forceMode!=-1)
{
if (header->mode < forceMode)
*rate <<= (forceMode - header->mode);
if (header->mode > forceMode)
*rate >>= (header->mode - forceMode);
}
speex_decoder_ctl(st, SPEEX_SET_SAMPLING_RATE, rate);
*nframes = header->frames_per_packet;
if (*channels == -1)
*channels = header->nb_channels;
debug_printf (1, "Decoding %d Hz audio using %s mode",
*rate, mode->modeName);
#ifdef DEBUG
if (*channels==1)
fprintf (stderr, " (mono");
else
fprintf (stderr, " (stereo");
if (header->vbr)
fprintf (stderr, " (VBR)\n");
else
fprintf(stderr, "\n");
#endif
*extra_headers = header->extra_headers;
fs_free(header);
return st;
}
static int
fs_speex_free_buffers (FishSound * fsound)
{
FishSoundSpeexInfo * fss = (FishSoundSpeexInfo *)fsound->codec_data;
if (fsound->mode == FISH_SOUND_DECODE) {
if (fss->ipcm && fss->ipcm != fss->pcm[0]) fs_free (fss->ipcm);
if (fss->pcm[0]) fs_free (fss->pcm[0]);
if (fss->pcm[1]) fs_free (fss->pcm[1]);
} else {
if (fss->ipcm) fs_free (fss->ipcm);
}
return 0;
}
static inline int
fs_speex_float_dispatch (FishSound * fsound)
{
FishSoundSpeexInfo * fss = (FishSoundSpeexInfo *)fsound->codec_data;
FishSoundDecoded_FloatIlv df;
FishSoundDecoded_Float dfi;
int retval;
if (fsound->interleave) {
dfi = (FishSoundDecoded_FloatIlv)fsound->callback.decoded_float_ilv;
retval = dfi (fsound, (float **)fss->ipcm, fss->frame_size,
fsound->user_data);
} else {
df = (FishSoundDecoded_Float)fsound->callback.decoded_float;
retval = df (fsound, fss->pcm, fss->frame_size, fsound->user_data);
}
return retval;
}
static long
fs_speex_decode (FishSound * fsound, unsigned char * buf, long bytes)
{
FishSoundSpeexInfo * fss = (FishSoundSpeexInfo *)fsound->codec_data;
int enh_enabled = DEFAULT_ENH_ENABLED;
int rate = 0;
int channels = -1;
int forceMode = -1;
int i, j;
if (fss->packetno == 0) {
fss->st = process_header (buf, bytes, enh_enabled,
&fss->frame_size, &rate,
&fss->nframes, forceMode, &channels,
&fss->stereo,
&fss->extra_headers);
if (fss->st == NULL) {
/* TODO: Return more specific error identifiers for invalid header fields */
return FISH_SOUND_ERR_GENERIC;
}
debug_printf (1, "speex: got %d channels, %d Hz", channels, rate);
fsound->info.samplerate = rate;
fsound->info.channels = channels;
/* Sanity check the channels value, as we will use it to determine buffer
sizes below.
*/
if (channels < 1 || channels > 2)
return FISH_SOUND_ERR_GENERIC;
#if HAVE_UINTPTR_T
/* Sanity check: frame_size is not so large that the buffer size calculations
* would wrap. In reality, frame_size is set by libspeex according to the
* mode index specified in the file header, and is usually equal to 320.
*/
if ((unsigned int)fss->frame_size > UINTPTR_MAX / (sizeof(float) * channels))
return FISH_SOUND_ERR_GENERIC;
#endif
fss->ipcm = fs_malloc (sizeof (float) * fss->frame_size * channels);
if (fss->ipcm == NULL) {
return FISH_SOUND_ERR_OUT_OF_MEMORY;
}
if (channels == 1) {
fss->pcm[0] = fss->ipcm;
} else if (channels == 2) {
fss->pcm[0] = fs_malloc (sizeof (float) * fss->frame_size);
if (fss->pcm[0] == NULL) {
fs_free (fss->ipcm);
return FISH_SOUND_ERR_OUT_OF_MEMORY;
}
fss->pcm[1] = fs_malloc (sizeof (float) * fss->frame_size);
if (fss->pcm[1] == NULL) {
fs_free (fss->pcm[0]);
fs_free (fss->ipcm);
return FISH_SOUND_ERR_OUT_OF_MEMORY;
}
}
if (fss->nframes == 0) fss->nframes = 1;
} else if (fss->packetno == 1) {
/* Comments */
if (fish_sound_comments_decode (fsound, buf, bytes) == FISH_SOUND_ERR_OUT_OF_MEMORY) {
fss->packetno++;
return FISH_SOUND_ERR_OUT_OF_MEMORY;
}
} else if (fss->packetno <= 1+fss->extra_headers) {
/* Unknown extra headers */
} else {
speex_bits_read_from (&fss->bits, (char *)buf, (int)bytes);
for (i = 0; i < fss->nframes; i++) {
/* Decode frame */
speex_decode (fss->st, &fss->bits, fss->ipcm);
if (fsound->info.channels == 2) {
speex_decode_stereo (fss->ipcm, fss->frame_size, &fss->stereo);
if (fsound->interleave) {
for (j = 0; j < fss->frame_size * fsound->info.channels; j++) {
fss->ipcm[j] /= 32767.0;
}
} else {
_fs_deinterleave ((float **)fss->ipcm, fss->pcm,
fss->frame_size, 2, (float)(1/32767.0));
}
} else {
for (j = 0; j < fss->frame_size; j++) {
fss->ipcm[j] /= 32767.0;
}
}
fsound->frameno += fss->frame_size;
fs_speex_float_dispatch (fsound);
}
}
fss->packetno++;
return 0;
}
#else /* !FS_DECODE */
#define fs_speex_decode NULL
#endif
#if FS_ENCODE
static FishSound *
fs_speex_enc_headers (FishSound * fsound)
{
FishSoundSpeexInfo * fss = (FishSoundSpeexInfo *)fsound->codec_data;
int modeID;
SpeexMode * mode = NULL;
SpeexHeader header;
unsigned char * header_buf = NULL, * comments_buf = NULL;
int header_bytes, comments_bytes=0;
size_t buflen;
modeID = 1;
#if HAVE_SPEEX_LIB_GET_MODE
mode = (SpeexMode *) speex_lib_get_mode (modeID);
#else
/* speex_mode_list[] is declared const in speex 1.1.x, hence the cast */
mode = (SpeexMode *)speex_mode_list[modeID];
#endif
speex_init_header (&header, fsound->info.samplerate, 1, mode);
header.frames_per_packet = fss->nframes; /* XXX: frames per packet */
header.vbr = 1; /* XXX: VBR */
header.nb_channels = fsound->info.channels;
fss->st = speex_encoder_init (mode);
if (fsound->callback.encoded) {
char vendor_string[128];
/* Allocate and create header */
header_buf = (unsigned char *) speex_header_to_packet (&header, &header_bytes);
if (header_buf == NULL) {
return NULL;
}
/* Allocate and create comments */
snprintf (vendor_string, 128, VENDOR_FORMAT, header.speex_version);
if (fish_sound_comment_set_vendor (fsound, vendor_string) == FISH_SOUND_ERR_OUT_OF_MEMORY) {
fs_free (header_buf);
return NULL;
}
comments_bytes = fish_sound_comments_encode (fsound, NULL, 0);
comments_buf = fs_malloc (comments_bytes);
if (comments_buf == NULL) {
fs_free (header_buf);
return NULL;
}
}
speex_encoder_ctl (fss->st, SPEEX_SET_SAMPLING_RATE,
&fsound->info.samplerate);
speex_encoder_ctl (fss->st, SPEEX_GET_FRAME_SIZE, &fss->frame_size);
debug_printf (1, "got frame size %d", fss->frame_size);
/* XXX: set VBR etc. */
buflen = fss->frame_size * fsound->info.channels * sizeof (float);
fss->ipcm = fs_malloc (buflen);
if (fss->ipcm == NULL) {
if (comments_buf) fs_free (comments_buf);
if (header_buf) fs_free (header_buf);
return NULL;
}
memset (fss->ipcm, 0, buflen);
/* Allocations succeeded, actually call encoded callback for headers */
if (fsound->callback.encoded) {
FishSoundEncoded encoded = (FishSoundEncoded)fsound->callback.encoded;
/* header */
encoded (fsound, header_buf, (long)header_bytes, fsound->user_data);
fss->packetno++;
fs_free (header_buf);
/* comments */
comments_bytes = fish_sound_comments_encode (fsound, comments_buf, comments_bytes);
encoded (fsound, comments_buf, (long)comments_bytes, fsound->user_data);
fss->packetno++;
fs_free (comments_buf);
}
return fsound;
}
static long
fs_speex_encode_write (FishSound * fsound)
{
FishSoundSpeexInfo * fss = (FishSoundSpeexInfo *)fsound->codec_data;
FishSoundSpeexEnc * fse = (FishSoundSpeexEnc *)fss->enc;
int bytes;
speex_bits_insert_terminator (&fss->bits);
bytes = speex_bits_write (&fss->bits, fse->cbits, MAX_FRAME_BYTES);
speex_bits_reset (&fss->bits);
if (fsound->callback.encoded) {
FishSoundEncoded encoded = (FishSoundEncoded)fsound->callback.encoded;
encoded (fsound, (unsigned char *)fse->cbits, (long)bytes,
fsound->user_data);
}
return bytes;
}
static long
fs_speex_encode_block (FishSound * fsound)
{
FishSoundSpeexInfo * fss = (FishSoundSpeexInfo *)fsound->codec_data;
FishSoundSpeexEnc * fse = (FishSoundSpeexEnc *)fss->enc;
long nencoded = fse->pcm_offset;
if (fsound->info.channels == 2)
speex_encode_stereo (fss->ipcm, fse->pcm_offset, &fss->bits);
speex_encode (fss->st, fss->ipcm, &fss->bits);
fsound->frameno += fse->pcm_offset;
fse->frame_offset++;
if (fse->frame_offset == fss->nframes) {
fs_speex_encode_write (fsound);
fse->frame_offset = 0;
}
fse->pcm_offset = 0;
return nencoded;
}
static long
fs_speex_encode_f_ilv (FishSound * fsound, float ** pcm, long frames)
{
FishSoundSpeexInfo * fss = (FishSoundSpeexInfo *)fsound->codec_data;
FishSoundSpeexEnc * fse = (FishSoundSpeexEnc *)fss->enc;
long remaining = frames, len, nencoded = 0;
int j, start, end;
int channels = fsound->info.channels;
float * p = (float *)pcm;
if (fss->packetno == 0)
fs_speex_enc_headers (fsound);
while (remaining > 0) {
len = MIN (remaining, fss->frame_size - fse->pcm_offset);
start = fse->pcm_offset * channels;
end = (len + fse->pcm_offset) * channels;
for (j = start; j < end; j++) {
fss->ipcm[j] = *p++ * (float)32767.0;
}
fse->pcm_offset += len;
if (fse->pcm_offset == fss->frame_size) {
nencoded += fs_speex_encode_block (fsound);
}
remaining -= len;
}
return frames - remaining;
}
static long
fs_speex_encode_f (FishSound * fsound, float * pcm[], long frames)
{
FishSoundSpeexInfo * fss = (FishSoundSpeexInfo *)fsound->codec_data;
FishSoundSpeexEnc * fse = (FishSoundSpeexEnc *)fss->enc;
long remaining = frames, len, n = 0, nencoded = 0;
int j, start;
if (fss->packetno == 0)
fs_speex_enc_headers (fsound);
while (remaining > 0) {
len = MIN (remaining, fss->frame_size - fse->pcm_offset);
start = fse->pcm_offset;
fss->pcm[0] = &pcm[0][n];
if (fsound->info.channels == 2) {
fss->pcm[1] = &pcm[1][n];
_fs_interleave (fss->pcm, (float **)&fss->ipcm[start*2],
len, 2, 32767.0);
} else {
for (j = 0; j < len; j++) {
fss->ipcm[start + j] = fss->pcm[0][j] * (float)32767.0;
}
}
fse->pcm_offset += len;
if (fse->pcm_offset == fss->frame_size) {
nencoded += fs_speex_encode_block (fsound);
}
remaining -= len;
n += len;
}
return frames - remaining;
}
static long
fs_speex_flush (FishSound * fsound)
{
FishSoundSpeexInfo * fss = (FishSoundSpeexInfo *)fsound->codec_data;
FishSoundSpeexEnc * fse = (FishSoundSpeexEnc *)fss->enc;
long nencoded = 0;
if (fsound->mode != FISH_SOUND_ENCODE)
return 0;
if (fse->pcm_offset > 0) {
nencoded += fs_speex_encode_block (fsound);
}
/* If, at this point, fse->frame_offset == 0, then either:
- all remaining encoded data has just been flushed out via
fs_speex_encode_block(), OR
- there was no data remaining to flush at the beginning of this
function (fse->pcm_offset == 0 && fse->frame_offset == 0)
*/
if (fse->frame_offset == 0) return 0;
while (fse->frame_offset < fss->nframes) {
speex_bits_pack (&fss->bits, 15, 5);
fse->frame_offset++;
}
nencoded += fs_speex_encode_write (fsound);
fse->frame_offset = 0;
return nencoded;
}
#else /* !FS_ENCODE */
#define fs_speex_encode_f NULL
#define fs_speex_encode_f_ilv NULL
#define fs_speex_flush NULL
#endif
static int
fs_speex_reset (FishSound * fsound)
{
/*FishSoundSpeexInfo * fss = (FishSoundSpeexInfo *)fsound->codec_data;*/
return 0;
}
static int
fs_speex_update (FishSound * fsound, int interleave)
{
FishSoundSpeexInfo * fss = (FishSoundSpeexInfo *)fsound->codec_data;
size_t pcm_size = sizeof (float);
float *ipcm_new, *pcm0, *pcm1;
ipcm_new = (float *)fs_realloc (fss->ipcm,
pcm_size * fss->frame_size * fsound->info.channels);
if (ipcm_new == NULL) return FISH_SOUND_ERR_OUT_OF_MEMORY;
fss->ipcm = ipcm_new;
if (interleave) {
/* if transitioning from non-interleave to interleave,
free non-ilv buffers */
if (!fsound->interleave && fsound->info.channels == 2) {
if (fss->pcm[0]) fs_free (fss->pcm[0]);
if (fss->pcm[1]) fs_free (fss->pcm[1]);
fss->pcm[0] = NULL;
fss->pcm[1] = NULL;
}
} else {
if (fsound->info.channels == 1) {
fss->pcm[0] = (float *) fss->ipcm;
} else if (fsound->info.channels == 2) {
#if HAVE_UINTPTR_T
/* Sanity check: frame_size is not so large that the buffer size calculations
* would wrap. In reality, frame_size is set by libspeex according to the
* mode index specified in the file header, and is usually equal to 320.
*/
if ((unsigned int)fss->frame_size > UINTPTR_MAX / pcm_size)
return FISH_SOUND_ERR_GENERIC;
#endif
pcm0 = fs_realloc (fss->pcm[0], pcm_size * fss->frame_size);
if (pcm0 == NULL) {
return FISH_SOUND_ERR_OUT_OF_MEMORY;
}
pcm1 = fs_realloc (fss->pcm[1], pcm_size * fss->frame_size);
if (pcm1 == NULL) {
fs_free (pcm0);
return FISH_SOUND_ERR_OUT_OF_MEMORY;
}
fss->pcm[0] = pcm0;
fss->pcm[1] = pcm1;
}
}
return 0;
}
static FishSound *
fs_speex_enc_init (FishSound * fsound)
{
FishSoundSpeexInfo * fss = (FishSoundSpeexInfo *)fsound->codec_data;
FishSoundSpeexEnc * fse;
fse = fs_malloc (sizeof (FishSoundSpeexEnc));
if (fse == NULL) return NULL;
fse->frame_offset = 0;
fse->pcm_offset = 0;
fse->id = 0;
fss->enc = fse;
return fsound;
}
static FishSound *
fs_speex_init (FishSound * fsound)
{
FishSoundSpeexInfo * fss;
SpeexStereoState stereo_init = SPEEX_STEREO_STATE_INIT;
fss = fs_malloc (sizeof (FishSoundSpeexInfo));
if (fss == NULL) return NULL;
fss->packetno = 0;
fss->st = NULL;
fss->frame_size = 0;
fss->nframes = 1;
fss->pcm_len = 0;
fss->ipcm = NULL;
fss->pcm[0] = NULL;
fss->pcm[1] = NULL;
memcpy (&fss->stereo, &stereo_init, sizeof (SpeexStereoState));
speex_bits_init (&fss->bits);
fsound->codec_data = fss;
if (fsound->mode == FISH_SOUND_ENCODE)
fs_speex_enc_init (fsound);
return fsound;
}
static FishSound *
fs_speex_delete (FishSound * fsound)
{
FishSoundSpeexInfo * fss = (FishSoundSpeexInfo *)fsound->codec_data;
fs_speex_free_buffers (fsound);
if (fsound->mode == FISH_SOUND_DECODE) {
if (fss->st) speex_decoder_destroy (fss->st);
} else if (fsound->mode == FISH_SOUND_ENCODE) {
if (fss->st) speex_encoder_destroy (fss->st);
if (fss->enc) fs_free (fss->enc);
}
speex_bits_destroy (&fss->bits);
fs_free (fss);
fsound->codec_data = NULL;
return fsound;
}
FishSoundCodec *
fish_sound_speex_codec (void)
{
FishSoundCodec * codec;
codec = (FishSoundCodec *) fs_malloc (sizeof (FishSoundCodec));
if (codec == NULL) return NULL;
codec->format.format = FISH_SOUND_SPEEX;
codec->format.name = "Speex (Xiph.Org)";
codec->format.extension = "spx";
codec->init = fs_speex_init;
codec->del = fs_speex_delete;
codec->reset = fs_speex_reset;
codec->update = fs_speex_update;
codec->command = fs_speex_command;
codec->decode = fs_speex_decode;
codec->encode_f = fs_speex_encode_f;
codec->encode_f_ilv = fs_speex_encode_f_ilv;
codec->flush = fs_speex_flush;
return codec;
}
#else /* !HAVE_SPEEX */
int
fish_sound_speex_identify (unsigned char * buf, long bytes)
{
return FISH_SOUND_UNKNOWN;
}
FishSoundCodec *
fish_sound_speex_codec (void)
{
return NULL;
}
#endif
libfishsound-1.0.0/src/libfishsound/vorbis.c 0000644 0001750 0001750 00000032343 11332275512 016060 0000000 0000000 /*
Copyright (C) 2003 Commonwealth Scientific and Industrial Research
Organisation (CSIRO) Australia
Redistribution and use in source and binary forms, with or without
modification, are permitted provided that the following conditions
are met:
- Redistributions of source code must retain the above copyright
notice, this list of conditions and the following disclaimer.
- Redistributions in binary form must reproduce the above copyright
notice, this list of conditions and the following disclaimer in the
documentation and/or other materials provided with the distribution.
- Neither the name of CSIRO Australia nor the names of its
contributors may be used to endorse or promote products derived from
this software without specific prior written permission.
THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS
``AS IS'' AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT
LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A
PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE ORGANISATION OR
CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL,
EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO,
PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR
PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF
LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING
NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS
SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
*/
#include "config.h"
#include
#include
#include
#include
#include "private.h"
#include "convert.h"
/*#define DEBUG*/
#include "debug.h"
#if HAVE_VORBIS
#include
#include
typedef struct _FishSoundVorbisInfo {
int packetno;
int finished;
vorbis_info vi;
vorbis_comment vc;
vorbis_dsp_state vd; /** central working state for the PCM->packet encoder */
vorbis_block vb; /** local working space for PCM->packet encode */
float ** pcm; /** ongoing pcm working space for decoder (stateful) */
float * ipcm; /** interleaved pcm for interfacing with user */
long max_pcm;
} FishSoundVorbisInfo;
int
fish_sound_vorbis_identify (unsigned char * buf, long bytes)
{
struct vorbis_info vi;
struct vorbis_comment vc;
ogg_packet op;
int ret, id = FISH_SOUND_UNKNOWN;
if (!strncmp ((char *)&buf[1], "vorbis", 6)) {
/* if only a short buffer was passed, do a weak identify */
if (bytes == 8) return FISH_SOUND_VORBIS;
/* otherwise, assume the buffer is an entire initial header and
* feed it to vorbis_synthesis_headerin() */
vorbis_info_init (&vi);
vorbis_comment_init (&vc);
op.packet = buf;
op.bytes = bytes;
op.b_o_s = 1;
op.e_o_s = 0;
op.granulepos = 0;
op.packetno = 0;
if ((ret = vorbis_synthesis_headerin (&vi, &vc, &op)) == 0) {
if (vi.rate != 0) id = FISH_SOUND_VORBIS;
} else {
debug_printf (1, "vorbis_synthesis_headerin returned %d", ret);
}
vorbis_info_clear (&vi);
}
return id;
}
static int
fs_vorbis_command (FishSound * fsound, int command, void * data,
int datasize)
{
return 0;
}
#if FS_DECODE
static long
fs_vorbis_decode (FishSound * fsound, unsigned char * buf, long bytes)
{
FishSoundVorbisInfo * fsv = (FishSoundVorbisInfo *)fsound->codec_data;
ogg_packet op;
long samples;
float * pcm_new;
int ret;
/* Make an ogg_packet structure to pass the data to libvorbis */
op.packet = buf;
op.bytes = bytes;
op.b_o_s = (fsv->packetno == 0) ? 1 : 0;
op.e_o_s = fsound->next_eos;
op.granulepos = fsound->next_granulepos;
op.packetno = fsv->packetno;
if (fsv->packetno < 3) {
if ((ret = vorbis_synthesis_headerin (&fsv->vi, &fsv->vc, &op)) == 0) {
if (fsv->vi.rate != 0) {
debug_printf (1, "Got vorbis info: version %d\tchannels %d\trate %ld",
fsv->vi.version, fsv->vi.channels, fsv->vi.rate);
fsound->info.samplerate = fsv->vi.rate;
fsound->info.channels = fsv->vi.channels;
}
}
/* Decode comments from packet 1. Vorbis has 7 bytes of marker at the
* start of vorbiscomment packet. */
if (fsv->packetno == 1 && bytes > 7 && buf[0] == 0x03 &&
!strncmp ((char *)&buf[1], "vorbis", 6)) {
if (fish_sound_comments_decode (fsound, buf+7, bytes-7) == FISH_SOUND_ERR_OUT_OF_MEMORY) {
fsv->packetno++;
return FISH_SOUND_ERR_OUT_OF_MEMORY;
}
} else if (fsv->packetno == 2) {
vorbis_synthesis_init (&fsv->vd, &fsv->vi);
vorbis_block_init (&fsv->vd, &fsv->vb);
}
} else {
FishSoundDecoded_FloatIlv df;
FishSoundDecoded_Float dfi;
int r;
if ((r = vorbis_synthesis (&fsv->vb, &op)) == 0)
vorbis_synthesis_blockin (&fsv->vd, &fsv->vb);
if (r == OV_EBADPACKET) {
return FISH_SOUND_ERR_GENERIC;
}
while ((samples = vorbis_synthesis_pcmout (&fsv->vd, &fsv->pcm)) > 0) {
vorbis_synthesis_read (&fsv->vd, samples);
if (fsound->frameno != -1)
fsound->frameno += samples;
if (fsound->interleave) {
if (samples > fsv->max_pcm) {
pcm_new = realloc (fsv->ipcm, sizeof(float) * samples *
fsound->info.channels);
if (pcm_new == NULL) {
/* Allocation failure; just truncate here, fail gracefully elsewhere */
samples = fsv->max_pcm;
} else {
fsv->ipcm = pcm_new;
fsv->max_pcm = samples;
}
}
_fs_interleave (fsv->pcm, (float **)fsv->ipcm, samples,
fsound->info.channels, 1.0);
dfi = (FishSoundDecoded_FloatIlv)fsound->callback.decoded_float_ilv;
dfi (fsound, (float **)fsv->ipcm, samples, fsound->user_data);
} else {
df = (FishSoundDecoded_Float)fsound->callback.decoded_float;
df (fsound, fsv->pcm, samples, fsound->user_data);
}
}
}
if (fsound->next_granulepos != -1) {
fsound->frameno = fsound->next_granulepos;
fsound->next_granulepos = -1;
}
fsv->packetno++;
return 0;
}
#else /* !FS_DECODE */
#define fs_vorbis_decode NULL
#endif
#if FS_ENCODE && HAVE_VORBISENC
static FishSound *
fs_vorbis_enc_headers (FishSound * fsound)
{
FishSoundVorbisInfo * fsv = (FishSoundVorbisInfo *)fsound->codec_data;
const FishSoundComment * comment;
ogg_packet header;
ogg_packet header_comm;
ogg_packet header_code;
/* Vorbis streams begin with three headers:
* 1. The initial header (with most of the codec setup parameters),
* which is mandated by the Ogg bitstream spec,
* 2. The second header which holds any comment fields,
* 3. The third header which contains the bitstream codebook.
* We merely need to make the headers, then pass them to libvorbis one at
* a time; libvorbis handles the additional Ogg bitstream constraints.
*/
/* Update the comments */
for (comment = fish_sound_comment_first (fsound); comment;
comment = fish_sound_comment_next (fsound, comment)) {
debug_printf (1, "%s = %s", comment->name, comment->value);
vorbis_comment_add_tag (&fsv->vc, comment->name, comment->value);
}
/* Generate the headers */
vorbis_analysis_headerout(&fsv->vd, &fsv->vc,
&header, &header_comm, &header_code);
/* Pass the generated headers to the user */
if (fsound->callback.encoded) {
FishSoundEncoded encoded = (FishSoundEncoded)fsound->callback.encoded;
encoded (fsound, header.packet, header.bytes, fsound->user_data);
encoded (fsound, header_comm.packet, header_comm.bytes,
fsound->user_data);
encoded (fsound, header_code.packet, header_code.bytes,
fsound->user_data);
fsv->packetno = 3;
}
return fsound;
}
static long
fs_vorbis_encode_write (FishSound * fsound, long len)
{
FishSoundVorbisInfo * fsv = (FishSoundVorbisInfo *)fsound->codec_data;
ogg_packet op;
vorbis_analysis_wrote (&fsv->vd, len);
while (vorbis_analysis_blockout (&fsv->vd, &fsv->vb) == 1) {
vorbis_analysis (&fsv->vb, NULL);
vorbis_bitrate_addblock (&fsv->vb);
while (vorbis_bitrate_flushpacket (&fsv->vd, &op)) {
if (fsound->callback.encoded) {
FishSoundEncoded encoded = (FishSoundEncoded)fsound->callback.encoded;
if (op.granulepos != -1)
fsound->frameno = op.granulepos;
encoded (fsound, op.packet, op.bytes, fsound->user_data);
fsv->packetno++;
}
}
}
return len;
}
static int
fs_vorbis_finish (FishSound * fsound)
{
FishSoundVorbisInfo * fsv = (FishSoundVorbisInfo *)fsound->codec_data;
if (!fsv->finished) {
if (fsound->mode == FISH_SOUND_ENCODE) {
fs_vorbis_encode_write (fsound, 0);
}
fsv->finished = 1;
}
return 0;
}
static long
fs_vorbis_encode_f_ilv (FishSound * fsound, float ** pcm, long frames)
{
FishSoundVorbisInfo * fsv = (FishSoundVorbisInfo *)fsound->codec_data;
float ** vpcm;
long len, remaining = frames;
float * d = (float *)pcm;
if (fsv->packetno == 0) {
fs_vorbis_enc_headers (fsound);
}
if (frames == 0) {
fs_vorbis_finish (fsound);
return 0;
}
while (remaining > 0) {
len = MIN (1024, remaining);
/* expose the buffer to submit data */
vpcm = vorbis_analysis_buffer (&fsv->vd, 1024);
_fs_deinterleave ((float **)d, vpcm, len, fsound->info.channels, 1.0);
d += (len * fsound->info.channels);
fs_vorbis_encode_write (fsound, len);
remaining -= len;
}
/**
* End of input. Tell libvorbis we're at the end of stream so that it can
* handle the last frame and mark the end of stream in the output properly.
*/
if (fsound->next_eos)
fs_vorbis_finish (fsound);
return 0;
}
static long
fs_vorbis_encode_f (FishSound * fsound, float * pcm[], long frames)
{
FishSoundVorbisInfo * fsv = (FishSoundVorbisInfo *)fsound->codec_data;
float ** vpcm;
long len, remaining = frames;
int i;
if (fsv->packetno == 0) {
fs_vorbis_enc_headers (fsound);
}
if (frames == 0) {
fs_vorbis_finish (fsound);
return 0;
}
while (remaining > 0) {
len = MIN (1024, remaining);
debug_printf (1, "processing %ld frames", len);
/* expose the buffer to submit data */
vpcm = vorbis_analysis_buffer (&fsv->vd, 1024);
for (i = 0; i < fsound->info.channels; i++) {
memcpy (vpcm[i], pcm[i], sizeof (float) * len);
}
fs_vorbis_encode_write (fsound, len);
remaining -= len;
}
/**
* End of input. Tell libvorbis we're at the end of stream so that it can
* handle the last frame and mark the end of stream in the output properly.
*/
if (fsound->next_eos)
fs_vorbis_finish (fsound);
return 0;
}
static FishSound *
fs_vorbis_enc_init (FishSound * fsound)
{
FishSoundVorbisInfo * fsv = (FishSoundVorbisInfo *)fsound->codec_data;
debug_printf (1, "Vorbis enc init: %d channels, %d Hz", fsound->info.channels,
fsound->info.samplerate);
vorbis_encode_init_vbr (&fsv->vi, fsound->info.channels,
fsound->info.samplerate, (float)0.3 /* quality */);
/* set up the analysis state and auxiliary encoding storage */
vorbis_analysis_init (&fsv->vd, &fsv->vi);
vorbis_block_init (&fsv->vd, &fsv->vb);
return fsound;
}
#else /* ! FS_ENCODE && HAVE_VORBISENC */
#define fs_vorbis_encode_f NULL
#define fs_vorbis_encode_f_ilv NULL
#define fs_vorbis_finish NULL
#endif /* ! FS_ENCODE && HAVE_VORBISENC */
static int
fs_vorbis_reset (FishSound * fsound)
{
FishSoundVorbisInfo * fsv = (FishSoundVorbisInfo *)fsound->codec_data;
vorbis_block_init (&fsv->vd, &fsv->vb);
fsv->packetno = 0;
return 0;
}
static FishSound *
fs_vorbis_init (FishSound * fsound)
{
FishSoundVorbisInfo * fsv;
fsv = fs_malloc (sizeof (FishSoundVorbisInfo));
if (fsv == NULL) return NULL;
fsv->packetno = 0;
fsv->finished = 0;
vorbis_info_init (&fsv->vi);
vorbis_comment_init (&fsv->vc);
memset(&fsv->vd, 0, sizeof(fsv->vd));
vorbis_block_init (&fsv->vd, &fsv->vb);
fsv->pcm = NULL;
fsv->ipcm = NULL;
fsv->max_pcm = 0;
fsound->codec_data = fsv;
#if FS_ENCODE && HAVE_VORBISENC
if (fsound->mode == FISH_SOUND_ENCODE) {
fs_vorbis_enc_init (fsound);
}
#endif /* FS_ENCODE && HAVE_VORBISENC */
return fsound;
}
static FishSound *
fs_vorbis_delete (FishSound * fsound)
{
FishSoundVorbisInfo * fsv = (FishSoundVorbisInfo *)fsound->codec_data;
#if FS_ENCODE && HAVE_VORBISENC
fs_vorbis_finish (fsound);
#endif /* FS_ENCODE && HAVE_VORBISENC */
if (fsv->ipcm) fs_free (fsv->ipcm);
vorbis_block_clear (&fsv->vb);
vorbis_dsp_clear (&fsv->vd);
vorbis_comment_clear (&fsv->vc);
vorbis_info_clear (&fsv->vi);
fs_free (fsv);
fsound->codec_data = NULL;
return fsound;
}
FishSoundCodec *
fish_sound_vorbis_codec (void)
{
FishSoundCodec * codec;
codec = (FishSoundCodec *) fs_malloc (sizeof (FishSoundCodec));
if (codec == NULL) return NULL;
codec->format.format = FISH_SOUND_VORBIS;
codec->format.name = "Vorbis (Xiph.Org)";
codec->format.extension = "ogg";
codec->init = fs_vorbis_init;
codec->del = fs_vorbis_delete;
codec->reset = fs_vorbis_reset;
codec->update = NULL; /* XXX */
codec->command = fs_vorbis_command;
codec->decode = fs_vorbis_decode;
codec->encode_f = fs_vorbis_encode_f;
codec->encode_f_ilv = fs_vorbis_encode_f_ilv;
codec->flush = NULL;
return codec;
}
#else /* !HAVE_VORBIS */
int
fish_sound_vorbis_identify (unsigned char * buf, long bytes)
{
return FISH_SOUND_UNKNOWN;
}
FishSoundCodec *
fish_sound_vorbis_codec (void)
{
return NULL;
}
#endif
libfishsound-1.0.0/src/libfishsound/flac.c 0000644 0001750 0001750 00000057624 11332275512 015472 0000000 0000000 /*
Copyright (C) 2007 Annodex Association
Redistribution and use in source and binary forms, with or without
modification, are permitted provided that the following conditions
are met:
- Redistributions of source code must retain the above copyright
notice, this list of conditions and the following disclaimer.
- Redistributions in binary form must reproduce the above copyright
notice, this list of conditions and the following disclaimer in the
documentation and/or other materials provided with the distribution.
- Neither the name of the Annodex Association nor the names of its
contributors may be used to endorse or promote products derived from
this software without specific prior written permission.
THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS
``AS IS'' AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT
LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A
PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE ASSOCIATION OR
CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL,
EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO,
PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR
PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF
LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING
NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS
SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
*/
/* Original patches by Tobias Gehrig, 2005
* http://www.annodex.net/software/libfishsound/libfishsound-flac/
*
* The Ogg FLAC mapping is documented in:
* http://flac.sourceforge.net/ogg_mapping.html
*/
#include "config.h"
#include
#include
#include
#include "private.h"
#include "convert.h"
#define DEBUG_VERBOSE 2
/* #define DEBUG */
/* #define DEBUG_LEVEL DEBUG_VERBOSE */
#include "debug.h"
#if HAVE_FLAC
#include "FLAC/all.h"
#define BITS_PER_SAMPLE 24
typedef struct _FishSoundFlacInfo {
FLAC__StreamDecoder *fsd;
FLAC__StreamEncoder *fse;
unsigned char * buffer;
char header;
unsigned long bufferlength;
unsigned long packetno;
struct {
unsigned char major, minor;
} version;
unsigned short header_packets;
void * ipcm;
#if FS_DECODE
float * pcm_out[8]; /* non-interleaved pcm, output (decode only);
* FLAC does max 8 channels */
#endif
#if FS_ENCODE
FLAC__StreamMetadata * enc_vc_metadata; /* FLAC metadata structure for
* vorbiscomments (encode only) */
#endif
} FishSoundFlacInfo;
int
fish_sound_flac_identify (unsigned char * buf, long bytes)
{
if (bytes < 8) return FISH_SOUND_UNKNOWN;
if (buf[0] != 0x7f) return FISH_SOUND_UNKNOWN;
if (!strncmp ((char *)buf+1, "FLAC", 4)) {
debug_printf(1, "flac found");
/* if only a short buffer was passed, do a weak identify */
if (bytes == 8) return FISH_SOUND_FLAC;
/* otherwise, look for the fLaC header preceding STREAMINFO */
if (!strncmp ((char *)buf+9, "fLaC", 4)) {
return FISH_SOUND_FLAC;
}
}
return FISH_SOUND_UNKNOWN;
}
static int
fs_flac_command (FishSound * fsound, int command, void * data, int datasize)
{
return 0;
}
#if FS_DECODE
static FLAC__StreamDecoderReadStatus
fs_flac_read_callback(const FLAC__StreamDecoder *decoder,
FLAC__byte buffer[], unsigned int *bytes,
void *client_data)
{
FishSound* fsound = (FishSound*)client_data;
FishSoundFlacInfo* fi = (FishSoundFlacInfo *)fsound->codec_data;
debug_printf(DEBUG_VERBOSE, "fs_flac_read_callback: IN");
if (fi->bufferlength > *bytes) {
debug_printf(1, "too much data");
return FLAC__STREAM_DECODER_READ_STATUS_ABORT;
} else if (fi->bufferlength < 1) {
debug_printf(1, "no data, %ld",fi->bufferlength);
return FLAC__STREAM_DECODER_READ_STATUS_END_OF_STREAM;
}
memcpy(buffer, fi->buffer, fi->bufferlength);
*bytes = (unsigned int)fi->bufferlength;
fi->bufferlength = 0;
return FLAC__STREAM_DECODER_READ_STATUS_CONTINUE;
}
static FLAC__StreamDecoderWriteStatus
fs_flac_write_callback(const FLAC__StreamDecoder *decoder,
const FLAC__Frame *frame,
const FLAC__int32 * const buffer[],
void *client_data)
{
FishSound* fsound = (FishSound*)client_data;
FishSoundFlacInfo* fi = (FishSoundFlacInfo *)fsound->codec_data;
int i, j, channels, blocksize, offset;
float * ipcm;
channels = frame->header.channels;
blocksize = frame->header.blocksize;
debug_printf(DEBUG_VERBOSE, "IN, blocksize %d", blocksize);
fsound->frameno += blocksize;
if (fsound->callback.decoded_float) {
float norm = 1.0 / ((1 << (frame->header.bits_per_sample - 1)));
if (fsound->interleave) {
FishSoundDecoded_FloatIlv dfi;
float* retpcm;
if ((ipcm = realloc(fi->ipcm, sizeof(float) * channels * blocksize)) == NULL)
return FLAC__STREAM_DECODER_WRITE_STATUS_ABORT;
fi->ipcm = ipcm;
retpcm = (float*) fi->ipcm;
for (i = 0; i < blocksize; i++) {
offset = i * channels;
for (j = 0; j < channels; j++)
retpcm[offset + j] = buffer[j][i] * norm;
}
dfi = (FishSoundDecoded_FloatIlv)fsound->callback.decoded_float_ilv;
dfi (fsound, (float **)retpcm, blocksize, fsound->user_data);
} else {
FishSoundDecoded_Float df;
FLAC__int32 * s = (FLAC__int32 *)buffer; /* de-interleave source */
float *d; /* de-interleave dest */
for (j = 0; j < channels; j++) {
if ((ipcm = realloc(fi->pcm_out[j], sizeof(float) * blocksize)) == NULL)
return FLAC__STREAM_DECODER_WRITE_STATUS_ABORT;
fi->pcm_out[j] = ipcm;
}
for (i = 0; i < blocksize; i++)
for (j = 0; j < channels; j++) {
d = fi->pcm_out[j];
d[i] = s[i*channels + j] * norm;
}
df = (FishSoundDecoded_Float)fsound->callback.decoded_float;
df (fsound, fi->pcm_out, blocksize, fsound->user_data);
}
}
return FLAC__STREAM_DECODER_WRITE_STATUS_CONTINUE;
}
static void
fs_flac_meta_callback(const FLAC__StreamDecoder *decoder,
const FLAC__StreamMetadata *metadata,
void *client_data)
{
FishSound* fsound = (FishSound*)client_data;
/* FishSoundFlacInfo* fi = (FishSoundFlacInfo *)fsound->codec_data; */
debug_printf(1, "IN");
switch (metadata->type) {
case FLAC__METADATA_TYPE_STREAMINFO:
debug_printf(1, "channels %d, samplerate %d",
metadata->data.stream_info.channels,
metadata->data.stream_info.sample_rate);
fsound->info.channels = metadata->data.stream_info.channels;
fsound->info.samplerate = metadata->data.stream_info.sample_rate;
break;
default:
debug_printf(1, "not yet implemented type");
break;
}
}
static void
fs_flac_error_callback(const FLAC__StreamDecoder *decoder,
FLAC__StreamDecoderErrorStatus status,
void *client_data)
{
debug_printf(1, "IN");
fprintf(stderr, "FLAC ERROR: %s\n", FLAC__StreamDecoderErrorStatusString[status]);
}
#endif
#if FS_DECODE
static void*
fs_flac_decode_header (FishSound * fsound, unsigned char *buf, long bytes)
{
FishSoundFlacInfo *fi = fsound->codec_data;
if (bytes < 9) return NULL;
if (buf[0] != 0x7f) return NULL;
if (strncmp((char *)buf+1, "FLAC", 4) != 0) return NULL;
fi->version.major = buf[5];
fi->version.minor = buf[6];
debug_printf(1, "Flac Ogg Mapping Version: %d.%d",
fi->version.major, fi->version.minor);
fi->header_packets = buf[7] << 8 | buf[8];
debug_printf(1, "Number of Header packets: %d", fi->header_packets);
if ((fi->fsd = FLAC__stream_decoder_new()) == NULL) {
debug_printf (1, "unable to create new stream_decoder");
return NULL;
}
#if defined (HAVE_FLAC_1_1_2)
FLAC__stream_decoder_set_read_callback(fi->fsd, fs_flac_read_callback);
FLAC__stream_decoder_set_write_callback(fi->fsd, fs_flac_write_callback);
FLAC__stream_decoder_set_metadata_callback(fi->fsd, fs_flac_meta_callback);
FLAC__stream_decoder_set_error_callback(fi->fsd, fs_flac_error_callback);
FLAC__stream_decoder_set_client_data(fi->fsd, fsound);
if (FLAC__stream_decoder_init(fi->fsd) != FLAC__STREAM_DECODER_SEARCH_FOR_METADATA)
return NULL;
#elif defined (HAVE_FLAC_1_1_3)
if (FLAC__stream_decoder_init_stream
(fi->fsd,
fs_flac_read_callback,
NULL, /* seek callback */
NULL, /* tell callback */
NULL, /* length callback */
NULL, /* EOF callback */
fs_flac_write_callback,
fs_flac_meta_callback,
fs_flac_error_callback,
fsound
) != FLAC__STREAM_DECODER_SEARCH_FOR_METADATA)
return NULL;
#endif
return fi->fsd;
}
static long
fs_flac_decode (FishSound * fsound, unsigned char * buf, long bytes)
{
FishSoundFlacInfo *fi = fsound->codec_data;
debug_printf(DEBUG_VERBOSE, "IN, fi->packetno = %ld", fi->packetno);
if (fi->packetno == 0) {
if (fs_flac_decode_header (fsound, buf, bytes) == NULL) {
debug_printf(1, "Error reading header");
return -1;
}
if ((fi->buffer = fs_malloc(sizeof(unsigned char)*bytes)) == NULL)
return FISH_SOUND_ERR_OUT_OF_MEMORY;
memcpy(fi->buffer, buf+9, bytes-9);
fi->bufferlength = bytes-9;
}
else if (fi->packetno <= fi->header_packets){
unsigned char* tmp;
debug_printf(1, "handling header (fi->header_packets = %d)",
fi->header_packets);
#if 0
if (fi->packetno == 1) fish_sound_comments_decode (fsound, buf, bytes);
#endif
if ((buf[0] & 0x7) == 4) {
int len = (buf[1]<<16) + (buf[2]<<8) + buf[3];
debug_printf (1, "got vorbiscomments len %d", len);
if (fish_sound_comments_decode (fsound, buf+4, len) == FISH_SOUND_ERR_OUT_OF_MEMORY) {
fi->packetno++;
return FISH_SOUND_ERR_OUT_OF_MEMORY;
}
}
if ((tmp = fs_malloc(sizeof(unsigned char)*(fi->bufferlength+bytes))) == NULL)
return FISH_SOUND_ERR_OUT_OF_MEMORY;
memcpy(tmp, fi->buffer, fi->bufferlength);
memcpy(tmp+fi->bufferlength, buf, bytes);
fi->bufferlength += bytes;
fs_free(fi->buffer);
fi->buffer = tmp;
if (fi->packetno == fi->header_packets) {
if (FLAC__stream_decoder_process_until_end_of_metadata(fi->fsd) == false) {
goto dec_err;
}
fs_free(fi->buffer);
}
} else {
fi->buffer = buf;
fi->bufferlength = bytes;
if (FLAC__stream_decoder_process_single(fi->fsd) == false) {
goto dec_err;
}
}
fi->packetno++;
return 0;
dec_err:
switch (FLAC__stream_decoder_get_state(fi->fsd)) {
case FLAC__STREAM_DECODER_MEMORY_ALLOCATION_ERROR:
return FISH_SOUND_ERR_OUT_OF_MEMORY;
default:
return FISH_SOUND_ERR_GENERIC;
}
}
#else /* !FS_DECODE */
#define fs_flac_decode NULL
#endif
#if FS_ENCODE
static FLAC__StreamEncoderWriteStatus
fs_flac_enc_write_callback(const FLAC__StreamEncoder *encoder,
const FLAC__byte buffer[], unsigned bytes,
unsigned samples, unsigned current_frame,
void *client_data)
{
FishSound* fsound = (FishSound*)client_data;
FishSoundFlacInfo *fi = fsound->codec_data;
debug_printf(1, "IN");
debug_printf(1, "bytes: %d, samples: %d", bytes, samples);
if (fsound->callback.encoded) {
FishSoundEncoded encoded = (FishSoundEncoded) fsound->callback.encoded;
if (fi->packetno == 0 && fi->header <= 1) {
if (fi->header == 0) {
/* libFLAC has called us with data containing the normal fLaC header
* and a STREAMINFO block. Prepend the FLAC Ogg mapping header,
* as described in http://flac.sourceforge.net/ogg_mapping.html.
*/
debug_printf(1, "generating FLAC header packet: %c%c%c%c",
buffer[0], buffer[1], buffer[2], buffer[3]);
if ((fi->buffer = (unsigned char*)fs_malloc(sizeof(unsigned char)*(bytes+9))) == NULL)
return FLAC__STREAM_ENCODER_WRITE_STATUS_FATAL_ERROR;
fi->buffer[0] = 0x7f;
fi->buffer[1] = 0x46; /* 'F' */
fi->buffer[2] = 0x4c; /* 'L' */
fi->buffer[3] = 0x41; /* 'A' */
fi->buffer[4] = 0x43; /* 'C' */
fi->buffer[5] = 1; /* Version major generated by this file */
fi->buffer[6] = 0; /* Version minor generated by this file */
fi->buffer[7] = 0; /* MSB(be): Nr. other non-audio header packets */
fi->buffer[8] = 1; /* LSB(be): Nr. other non-audio header packets */
memcpy (fi->buffer+9, buffer, bytes); /* fLaC header ++ STREAMINFO */
fi->bufferlength = bytes+9;
fi->header++;
} else {
/* Make a temporary copy of the metadata header to pass to the user
* callback.
*/
unsigned char* tmp;
if ((tmp = (unsigned char*)fs_malloc(sizeof(unsigned char)*(bytes+fi->bufferlength))) == NULL)
return FLAC__STREAM_ENCODER_WRITE_STATUS_FATAL_ERROR;
memcpy (tmp, fi->buffer, fi->bufferlength);
memcpy (tmp+fi->bufferlength, buffer, bytes);
fs_free(fi->buffer);
fi->buffer = tmp;
fi->bufferlength += bytes;
fi->header++;
encoded (fsound, (unsigned char *)fi->buffer, (long)fi->bufferlength,
fsound->user_data);
}
} else {
fsound->frameno += samples;
encoded (fsound, (unsigned char *)buffer, (long)bytes,
fsound->user_data);
}
}
return FLAC__STREAM_ENCODER_WRITE_STATUS_OK;
}
static void
fs_flac_enc_meta_callback(const FLAC__StreamEncoder *encoder,
const FLAC__StreamMetadata *metadata,
void *client_data)
{
/* FishSound* fsound = (FishSound*)client_data; */
/* FishSoundFlacInfo* fi = (FishSoundFlacInfo *)fsound->codec_data; */
debug_printf(1, "IN");
switch (metadata->type) {
case FLAC__METADATA_TYPE_STREAMINFO:
debug_printf(1, "channels %d, samplerate %d",
metadata->data.stream_info.channels,
metadata->data.stream_info.sample_rate);
/*
fsound->info.channels = metadata->data.stream_info.channels;
fsound->info.samplerate = metadata->data.stream_info.sample_rate;
*/
break;
default:
debug_printf(1, "metadata type not yet implemented");
break;
}
return;
}
/* Create a local alias for an unwieldy type name */
typedef FLAC__StreamMetadata_VorbisComment_Entry FLAC__VCEntry;
static void
fs_flac_metadata_free (FLAC__StreamMetadata * metadata)
{
unsigned int i, length;
FLAC__VCEntry * comments;
if (metadata == NULL) return;
length = metadata->data.vorbis_comment.num_comments;
comments = metadata->data.vorbis_comment.comments;
for (i = 0; i < length; i++) {
fs_free (comments[i].entry);
}
fs_free (comments);
fs_free (metadata);
return;
}
static FLAC__byte *
fs_flac_encode_vcentry (const FishSoundComment * comment)
{
FLAC__byte * entry;
FLAC__uint32 length;
size_t name_len=0, value_len=0;
name_len = strlen(comment->name);
length = name_len + 1;
if (comment->value) {
value_len = strlen (comment->value);
length += value_len + 1;
}
if ((entry = fs_malloc (length)) == NULL)
return NULL;
/* We assume that comment->name, value are NUL terminated, as they were
* produced by our own comments.c */
strcpy ((char *)entry, comment->name);
if (comment->value) {
entry[name_len] = '=';
strcpy ((char *)&entry[name_len+1], comment->value);
}
entry[length-1] = '\0';
return entry;
}
static FLAC__StreamMetadata *
fs_flac_encode_vorbiscomments (FishSound * fsound)
{
FishSoundFlacInfo * fi = fsound->codec_data;
FLAC__StreamMetadata * metadata = NULL;
const FishSoundComment * comment;
unsigned int length=0, total_length;
int i=0;
FLAC__VCEntry * comments;
/* libFLAC seems to require us to know the total length of the generated
* vorbiscomment packet, even though it will silently generate the
* vendor string. Hence, this value was determined by inspection for
* the version "reference libFLAC 1.1.2"
*/
total_length = 40;
/* Count the number of comments */
for (comment = fish_sound_comment_first (fsound); comment;
comment = fish_sound_comment_next (fsound, comment)) {
length++;
}
if (length == 0) return NULL;
if ((comments = (FLAC__VCEntry *)fs_malloc (sizeof(FLAC__VCEntry) * length)) == NULL)
goto encode_vc_oom;
for (comment = fish_sound_comment_first (fsound); comment;
comment = fish_sound_comment_next (fsound, comment)) {
if ((comments[i].entry = fs_flac_encode_vcentry (comment)) == NULL) {
}
comments[i].length = strlen((char *)comments[i].entry);
/* In the generated vorbiscomment data, each entry is preceded by a
* 32bit length specifier. */
total_length += 4 + comments[i].length;
i++;
}
if ((metadata = (FLAC__StreamMetadata *) fs_malloc (sizeof (*metadata))) == NULL)
goto encode_vc_oom;
metadata->type = FLAC__METADATA_TYPE_VORBIS_COMMENT;
metadata->is_last = true;
metadata->length = total_length;
/* Don't bother setting the vendor_string, as libFLAC ignores it */
metadata->data.vorbis_comment.num_comments = length;
metadata->data.vorbis_comment.comments = comments;
/* Remember the allocated metadata */
fi->enc_vc_metadata = metadata;
return metadata;
encode_vc_oom:
if (metadata != NULL)
fs_free (metadata);
/* Unwind allocated comment entries */
for (i--; i >= 0; i--) {
if (comments[i].entry != NULL)
fs_free (comments[i].entry);
}
if (comments != NULL)
fs_free (comments);
return NULL;
}
static FishSound *
fs_flac_enc_headers (FishSound * fsound)
{
FishSoundFlacInfo * fi = fsound->codec_data;
FLAC__StreamMetadata * metadata;
fi->fse = FLAC__stream_encoder_new();
FLAC__stream_encoder_set_channels(fi->fse, fsound->info.channels);
FLAC__stream_encoder_set_sample_rate(fi->fse, fsound->info.samplerate);
FLAC__stream_encoder_set_bits_per_sample(fi->fse, BITS_PER_SAMPLE);
#if defined (HAVE_FLAC_1_1_2)
FLAC__stream_encoder_set_write_callback(fi->fse, fs_flac_enc_write_callback);
FLAC__stream_encoder_set_metadata_callback(fi->fse, fs_flac_enc_meta_callback);
FLAC__stream_encoder_set_client_data(fi->fse, fsound);
#endif
metadata = fs_flac_encode_vorbiscomments (fsound);
if (metadata != NULL)
FLAC__stream_encoder_set_metadata (fi->fse, &metadata, 1);
/* FLAC__stream_encoder_set_total_samples_estimate(fi->fse, ...);*/
#if defined (HAVE_FLAC_1_1_2)
if (FLAC__stream_encoder_init(fi->fse) != FLAC__STREAM_ENCODER_OK)
return NULL;
#elif defined (HAVE_FLAC_1_1_3)
if (FLAC__stream_encoder_init_stream
(fi->fse,
fs_flac_enc_write_callback,
NULL, /* seek callback */
NULL, /* tell callback */
fs_flac_enc_meta_callback,
fsound
) != FLAC__STREAM_ENCODER_OK)
return NULL;
#endif
return fsound;
}
static long
fs_flac_encode_fatal (FishSoundFlacInfo *fi, long err)
{
FLAC__stream_encoder_delete (fi->fse);
fi->fse = NULL;
return err;
}
static long
fs_flac_encode_f (FishSound * fsound, float * pcm[], long frames)
{
FishSoundFlacInfo *fi = fsound->codec_data;
FLAC__int32 *buffer, *ipcm;
float * p, norm = (1 << (BITS_PER_SAMPLE - 1));
long i;
int j, channels = fsound->info.channels;
debug_printf("IN, frames = %ld", frames);
if ((ipcm = realloc(fi->ipcm, sizeof(FLAC__int32) * channels * frames)) == NULL)
return FISH_SOUND_ERR_OUT_OF_MEMORY;
fi->ipcm = ipcm;
buffer = (FLAC__int32*) fi->ipcm;
for (i = 0; i < frames; i++) {
for (j = 0; j < channels; j++) {
p = pcm[j];
buffer[i*channels + j] = (FLAC__int32) (p[i] * norm);
}
}
if (fi->packetno == 0)
fs_flac_enc_headers (fsound);
/* We could have used FLAC__stream_encoder_process() and a more direct
* conversion loop above, rather than converting and interleaving. */
if (FLAC__stream_encoder_process_interleaved(fi->fse, buffer, frames) == false) {
switch (FLAC__stream_encoder_get_state (fi->fse)) {
case FLAC__STREAM_ENCODER_OK:
case FLAC__STREAM_ENCODER_UNINITIALIZED:
break;
case FLAC__STREAM_ENCODER_MEMORY_ALLOCATION_ERROR:
return fs_flac_encode_fatal (fi, FISH_SOUND_ERR_OUT_OF_MEMORY);
default:
return fs_flac_encode_fatal (fi, FISH_SOUND_ERR_GENERIC);
}
}
fi->packetno++;
return frames;
}
static long
fs_flac_encode_f_ilv (FishSound * fsound, float ** pcm, long frames)
{
FishSoundFlacInfo *fi = fsound->codec_data;
FLAC__int32 *buffer, *ipcm;
float * p = (float*)pcm, norm = (1 << (BITS_PER_SAMPLE - 1));
long i, length = frames * fsound->info.channels;
debug_printf(1, "IN, frames = %ld", frames);
if ((ipcm = realloc(fi->ipcm, sizeof(FLAC__int32)*fsound->info.channels*frames)) == NULL)
return FISH_SOUND_ERR_OUT_OF_MEMORY;
fi->ipcm = ipcm;
buffer = (FLAC__int32*) fi->ipcm;
for (i=0; ipacketno == 0)
fs_flac_enc_headers (fsound);
if (FLAC__stream_encoder_process_interleaved(fi->fse, buffer, frames) == false) {
switch (FLAC__stream_encoder_get_state (fi->fse)) {
case FLAC__STREAM_ENCODER_OK:
case FLAC__STREAM_ENCODER_UNINITIALIZED:
break;
case FLAC__STREAM_ENCODER_MEMORY_ALLOCATION_ERROR:
return fs_flac_encode_fatal (fi, FISH_SOUND_ERR_OUT_OF_MEMORY);
default:
return fs_flac_encode_fatal (fi, FISH_SOUND_ERR_GENERIC);
}
}
fi->packetno++;
return frames;
}
#else /* ! FS_ENCODE */
#define fs_flac_encode_f NULL
#define fs_flac_encode_f_ilv NULL
#endif /* ! FS_ENCODE */
static FishSound *
fs_flac_delete (FishSound * fsound)
{
FishSoundFlacInfo * fi = (FishSoundFlacInfo *)fsound->codec_data;
int i;
if (fsound->mode == FISH_SOUND_DECODE) {
if (fi->fsd) {
FLAC__stream_decoder_finish(fi->fsd);
FLAC__stream_decoder_delete(fi->fsd);
}
} else if (fsound->mode == FISH_SOUND_ENCODE) {
if (fi->fse) {
FLAC__stream_encoder_finish(fi->fse);
FLAC__stream_encoder_delete(fi->fse);
}
if (fi->buffer) {
fs_free(fi->buffer);
fi->buffer = NULL;
}
}
if (fi->ipcm) fs_free(fi->ipcm);
for (i = 0; i < 8; i++) {
if (fi->pcm_out[i]) fs_free (fi->pcm_out[i]);
}
#if FS_ENCODE
if (fi->enc_vc_metadata) {
fs_flac_metadata_free (fi->enc_vc_metadata);
}
#endif
fs_free (fi);
fsound->codec_data = NULL;
return fsound;
}
static int
fs_flac_update (FishSound * fsound, int interleave)
{
return 0;
}
static int
fs_flac_reset (FishSound * fsound)
{
/*FishSoundFlacInfo * fi = (FishSoundFlacInfo *)fsound->codec_data;*/
#if 0
if (fsound->mode == FISH_SOUND_DECODE) {
FLAC__stream_decoder_reset(fi->fsd);
} else if (fsound->mode == FISH_SOUND_ENCODE) {
}
#endif
return 0;
}
static long
fs_flac_flush (FishSound * fsound)
{
FishSoundFlacInfo * fi = (FishSoundFlacInfo *)fsound->codec_data;
debug_printf("IN (%s)", fsound->mode == FISH_SOUND_DECODE ? "decode" : "encode");
if (fsound->mode == FISH_SOUND_DECODE) {
FLAC__stream_decoder_finish(fi->fsd);
} else if (fsound->mode == FISH_SOUND_ENCODE) {
FLAC__stream_encoder_finish(fi->fse);
}
return 0;
}
static FishSound *
fs_flac_init (FishSound * fsound)
{
FishSoundFlacInfo *fi;
int i;
fi = fs_malloc (sizeof (FishSoundFlacInfo));
if (fi == NULL) return NULL;
fi->fsd = NULL;
fi->fse = NULL;
fi->buffer = NULL;
fi->packetno = 0;
fi->header = 0;
fi->header_packets = 0;
fi->ipcm = NULL;
for (i = 0; i < 8; i++) {
fi->pcm_out[i] = NULL;
}
#if FS_ENCODE
fi->enc_vc_metadata = NULL;
#endif
fsound->codec_data = fi;
return fsound;
}
FishSoundCodec *
fish_sound_flac_codec (void)
{
FishSoundCodec * codec;
codec = (FishSoundCodec *) fs_malloc (sizeof (FishSoundCodec));
if (codec == NULL) return NULL;
codec->format.format = FISH_SOUND_FLAC;
codec->format.name = "Flac (Xiph.Org)";
codec->format.extension = "ogg";
codec->init = fs_flac_init;
codec->del = fs_flac_delete;
codec->reset = fs_flac_reset;
codec->update = fs_flac_update;
codec->command = fs_flac_command;
codec->decode = fs_flac_decode;
codec->encode_f = fs_flac_encode_f;
codec->encode_f_ilv = fs_flac_encode_f_ilv;
codec->flush = fs_flac_flush;
return codec;
}
#else /* !HAVE_FLAC */
int
fish_sound_flac_identify (unsigned char * buf, long bytes)
{
return FISH_SOUND_UNKNOWN;
}
FishSoundCodec *
fish_sound_flac_codec (void)
{
return NULL;
}
#endif
libfishsound-1.0.0/src/libfishsound/fs_vector.c 0000644 0001750 0001750 00000012330 11163316023 016533 0000000 0000000 /*
Copyright (C) 2003 Commonwealth Scientific and Industrial Research
Organisation (CSIRO) Australia
Redistribution and use in source and binary forms, with or without
modification, are permitted provided that the following conditions
are met:
- Redistributions of source code must retain the above copyright
notice, this list of conditions and the following disclaimer.
- Redistributions in binary form must reproduce the above copyright
notice, this list of conditions and the following disclaimer in the
documentation and/or other materials provided with the distribution.
- Neither the name of CSIRO Australia nor the names of its
contributors may be used to endorse or promote products derived from
this software without specific prior written permission.
THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS
``AS IS'' AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT
LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A
PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE ORGANISATION OR
CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL,
EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO,
PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR
PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF
LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING
NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS
SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
*/
#include
#include
#include
#include "fs_compat.h"
typedef int (*FishSoundFunc) (void * data);
typedef int (*FishSoundCmpFunc) (const void * data1, const void * data2);
typedef struct _FishSoundVector FishSoundVector;
struct _FishSoundVector {
int max_elements;
int nr_elements;
FishSoundCmpFunc cmp;
void ** data;
};
/*
* A vector of void *. New elements will be appended at the tail.
*/
FishSoundVector *
fs_vector_new (FishSoundCmpFunc cmp)
{
FishSoundVector * vector;
vector = fs_malloc (sizeof (FishSoundVector));
if (vector == NULL) return NULL;
vector->max_elements = 0;
vector->nr_elements = 0;
vector->cmp = cmp;
vector->data = NULL;
return vector;
}
static void
fs_vector_clear (FishSoundVector * vector)
{
fs_free (vector->data);
vector->data = NULL;
vector->nr_elements = 0;
vector->max_elements = 0;
}
void
fs_vector_delete (FishSoundVector * vector)
{
fs_vector_clear (vector);
fs_free (vector);
}
int
fs_vector_size (FishSoundVector * vector)
{
if (vector == NULL) return 0;
return vector->nr_elements;
}
void *
fs_vector_nth (FishSoundVector * vector, int n)
{
if (vector == NULL) return NULL;
if (n >= vector->nr_elements) return NULL;
return vector->data[n];
}
int
fs_vector_find_index (FishSoundVector * vector, const void * data)
{
void * v_data;
int i;
for (i = 0; i < vector->nr_elements; i++) {
v_data = vector->data[i];
if (vector->cmp (v_data, data))
return i;
}
return -1;
}
void *
fs_vector_find (FishSoundVector * vector, const void * data)
{
void * v_data;
int i;
for (i = 0; i < vector->nr_elements; i++) {
v_data = vector->data[i];
if (vector->cmp (v_data, data))
return v_data;
}
return NULL;
}
int
fs_vector_foreach (FishSoundVector * vector, FishSoundFunc func)
{
int i;
for (i = 0; i < vector->nr_elements; i++) {
func (vector->data[i]);
}
return 0;
}
static FishSoundVector *
fs_vector_grow (FishSoundVector * vector)
{
void * new_elements;
int new_max_elements;
vector->nr_elements++;
if (vector->nr_elements > vector->max_elements) {
if (vector->max_elements == 0) {
new_max_elements = 1;
} else {
new_max_elements = vector->max_elements * 2;
}
new_elements =
fs_realloc (vector->data, (size_t)new_max_elements * sizeof (void *));
if (new_elements == NULL) {
vector->nr_elements--;
return NULL;
}
vector->max_elements = new_max_elements;
vector->data = new_elements;
}
return vector;
}
void *
fs_vector_insert (FishSoundVector * vector, void * data)
{
if (vector == NULL) return NULL;
if (fs_vector_grow (vector) == NULL)
return NULL;
vector->data[vector->nr_elements-1] = data;
return data;
}
static void *
fs_vector_remove_nth (FishSoundVector * vector, int n)
{
int i;
void * new_elements;
int new_max_elements;
vector->nr_elements--;
if (vector->nr_elements == 0) {
fs_vector_clear (vector);
} else {
for (i = n; i < vector->nr_elements; i++) {
vector->data[i] = vector->data[i+1];
}
if (vector->nr_elements < vector->max_elements/2) {
new_max_elements = vector->max_elements/2;
new_elements =
fs_realloc (vector->data,
(size_t)new_max_elements * sizeof (void *));
if (new_elements == NULL)
return NULL;
vector->max_elements = new_max_elements;
vector->data = new_elements;
}
}
return vector;
}
FishSoundVector *
fs_vector_remove (FishSoundVector * vector, void * data)
{
int i;
for (i = 0; i < vector->nr_elements; i++) {
if (vector->data[i] == data) {
return fs_vector_remove_nth (vector, i);
}
}
return vector;
}
libfishsound-1.0.0/src/examples/ 0000777 0001750 0001750 00000000000 11332275631 013616 5 0000000 0000000 libfishsound-1.0.0/src/examples/Makefile.am 0000644 0001750 0001750 00000002750 11163316023 015563 0000000 0000000 ## Process this file with automake to produce Makefile.in
AM_CFLAGS = -Wall -pedantic -g
INCLUDES = -I$(top_builddir) \
-I$(top_srcdir)/include -I$(top_srcdir)/src/libfishsound \
$(SNDFILE_CFLAGS) $(VORBIS_CFLAGS) $(SPEEX_CFLAGS) $(FLAC_CFLAGS) $(OGGZ_CFLAGS)
FISHSOUNDDIR = ../libfishsound
FISHSOUND_LIBS = $(FISHSOUNDDIR)/libfishsound.la \
$(VORBIS_LIBS) $(SPEEX_LIBS) $(FLAC_LIBS)
if HAVE_OGGZ
oggz_examples = fishsound-identify fishsound-info fishsound-decenc
endif
if HAVE_LIBSNDFILE1
sndfile_examples = fishsound-encdec
endif
if HAVE_OGGZ
if HAVE_LIBSNDFILE1
oggz_sndfile_examples = fishsound-decode fishsound-encode
endif
endif
# Programs to build
noinst_PROGRAMS = $(oggz_examples) $(sndfile_examples) $(oggz_sndfile_examples)
#bin_PROGRAMS = $(oggz_examples) $(sndfile_examples) $(oggz_sndfile_examples)
fishsound_identify_SOURCES = fishsound-identify.c
fishsound_identify_LDADD = $(FISHSOUND_LIBS) $(OGGZ_LIBS)
fishsound_info_SOURCES = fishsound-info.c
fishsound_info_LDADD = $(FISHSOUND_LIBS) $(OGGZ_LIBS)
fishsound_decode_SOURCES = fishsound-decode.c
fishsound_decode_LDADD = $(FISHSOUND_LIBS) $(OGGZ_LIBS) $(SNDFILE_LIBS)
fishsound_encode_SOURCES = fishsound-encode.c
fishsound_encode_LDADD = $(FISHSOUND_LIBS) $(OGGZ_LIBS) $(SNDFILE_LIBS)
fishsound_decenc_SOURCES = fishsound-decenc.c
fishsound_decenc_LDADD = $(FISHSOUND_LIBS) $(OGGZ_LIBS)
fishsound_encdec_SOURCES = fishsound-encdec.c
fishsound_encdec_LDADD = $(FISHSOUND_LIBS) $(SNDFILE_LIBS)
libfishsound-1.0.0/src/examples/Makefile.in 0000644 0001750 0001750 00000044270 11332275622 015606 0000000 0000000 # Makefile.in generated by automake 1.10.2 from Makefile.am.
# @configure_input@
# Copyright (C) 1994, 1995, 1996, 1997, 1998, 1999, 2000, 2001, 2002,
# 2003, 2004, 2005, 2006, 2007, 2008 Free Software Foundation, Inc.
# This Makefile.in is free software; the Free Software Foundation
# gives unlimited permission to copy and/or distribute it,
# with or without modifications, as long as this notice is preserved.
# This program is distributed in the hope that it will be useful,
# but WITHOUT ANY WARRANTY, to the extent permitted by law; without
# even the implied warranty of MERCHANTABILITY or FITNESS FOR A
# PARTICULAR PURPOSE.
@SET_MAKE@
VPATH = @srcdir@
pkgdatadir = $(datadir)/@PACKAGE@
pkglibdir = $(libdir)/@PACKAGE@
pkgincludedir = $(includedir)/@PACKAGE@
am__cd = CDPATH="$${ZSH_VERSION+.}$(PATH_SEPARATOR)" && cd
install_sh_DATA = $(install_sh) -c -m 644
install_sh_PROGRAM = $(install_sh) -c
install_sh_SCRIPT = $(install_sh) -c
INSTALL_HEADER = $(INSTALL_DATA)
transform = $(program_transform_name)
NORMAL_INSTALL = :
PRE_INSTALL = :
POST_INSTALL = :
NORMAL_UNINSTALL = :
PRE_UNINSTALL = :
POST_UNINSTALL = :
build_triplet = @build@
host_triplet = @host@
target_triplet = @target@
noinst_PROGRAMS = $(am__EXEEXT_1) $(am__EXEEXT_2) $(am__EXEEXT_3)
subdir = src/examples
DIST_COMMON = $(srcdir)/Makefile.am $(srcdir)/Makefile.in
ACLOCAL_M4 = $(top_srcdir)/aclocal.m4
am__aclocal_m4_deps = $(top_srcdir)/m4/as-ac-expand.m4 \
$(top_srcdir)/configure.ac
am__configure_deps = $(am__aclocal_m4_deps) $(CONFIGURE_DEPENDENCIES) \
$(ACLOCAL_M4)
mkinstalldirs = $(install_sh) -d
CONFIG_HEADER = $(top_builddir)/config.h
CONFIG_CLEAN_FILES =
@HAVE_OGGZ_TRUE@am__EXEEXT_1 = fishsound-identify$(EXEEXT) \
@HAVE_OGGZ_TRUE@ fishsound-info$(EXEEXT) \
@HAVE_OGGZ_TRUE@ fishsound-decenc$(EXEEXT)
@HAVE_LIBSNDFILE1_TRUE@am__EXEEXT_2 = fishsound-encdec$(EXEEXT)
@HAVE_LIBSNDFILE1_TRUE@@HAVE_OGGZ_TRUE@am__EXEEXT_3 = fishsound-decode$(EXEEXT) \
@HAVE_LIBSNDFILE1_TRUE@@HAVE_OGGZ_TRUE@ fishsound-encode$(EXEEXT)
PROGRAMS = $(noinst_PROGRAMS)
am_fishsound_decenc_OBJECTS = fishsound-decenc.$(OBJEXT)
fishsound_decenc_OBJECTS = $(am_fishsound_decenc_OBJECTS)
am__DEPENDENCIES_1 =
am__DEPENDENCIES_2 = $(FISHSOUNDDIR)/libfishsound.la \
$(am__DEPENDENCIES_1) $(am__DEPENDENCIES_1) \
$(am__DEPENDENCIES_1)
fishsound_decenc_DEPENDENCIES = $(am__DEPENDENCIES_2) \
$(am__DEPENDENCIES_1)
am_fishsound_decode_OBJECTS = fishsound-decode.$(OBJEXT)
fishsound_decode_OBJECTS = $(am_fishsound_decode_OBJECTS)
fishsound_decode_DEPENDENCIES = $(am__DEPENDENCIES_2) \
$(am__DEPENDENCIES_1) $(am__DEPENDENCIES_1)
am_fishsound_encdec_OBJECTS = fishsound-encdec.$(OBJEXT)
fishsound_encdec_OBJECTS = $(am_fishsound_encdec_OBJECTS)
fishsound_encdec_DEPENDENCIES = $(am__DEPENDENCIES_2) \
$(am__DEPENDENCIES_1)
am_fishsound_encode_OBJECTS = fishsound-encode.$(OBJEXT)
fishsound_encode_OBJECTS = $(am_fishsound_encode_OBJECTS)
fishsound_encode_DEPENDENCIES = $(am__DEPENDENCIES_2) \
$(am__DEPENDENCIES_1) $(am__DEPENDENCIES_1)
am_fishsound_identify_OBJECTS = fishsound-identify.$(OBJEXT)
fishsound_identify_OBJECTS = $(am_fishsound_identify_OBJECTS)
fishsound_identify_DEPENDENCIES = $(am__DEPENDENCIES_2) \
$(am__DEPENDENCIES_1)
am_fishsound_info_OBJECTS = fishsound-info.$(OBJEXT)
fishsound_info_OBJECTS = $(am_fishsound_info_OBJECTS)
fishsound_info_DEPENDENCIES = $(am__DEPENDENCIES_2) \
$(am__DEPENDENCIES_1)
DEFAULT_INCLUDES = -I.@am__isrc@ -I$(top_builddir)
depcomp = $(SHELL) $(top_srcdir)/depcomp
am__depfiles_maybe = depfiles
COMPILE = $(CC) $(DEFS) $(DEFAULT_INCLUDES) $(INCLUDES) $(AM_CPPFLAGS) \
$(CPPFLAGS) $(AM_CFLAGS) $(CFLAGS)
LTCOMPILE = $(LIBTOOL) --tag=CC $(AM_LIBTOOLFLAGS) $(LIBTOOLFLAGS) \
--mode=compile $(CC) $(DEFS) $(DEFAULT_INCLUDES) $(INCLUDES) \
$(AM_CPPFLAGS) $(CPPFLAGS) $(AM_CFLAGS) $(CFLAGS)
CCLD = $(CC)
LINK = $(LIBTOOL) --tag=CC $(AM_LIBTOOLFLAGS) $(LIBTOOLFLAGS) \
--mode=link $(CCLD) $(AM_CFLAGS) $(CFLAGS) $(AM_LDFLAGS) \
$(LDFLAGS) -o $@
SOURCES = $(fishsound_decenc_SOURCES) $(fishsound_decode_SOURCES) \
$(fishsound_encdec_SOURCES) $(fishsound_encode_SOURCES) \
$(fishsound_identify_SOURCES) $(fishsound_info_SOURCES)
DIST_SOURCES = $(fishsound_decenc_SOURCES) $(fishsound_decode_SOURCES) \
$(fishsound_encdec_SOURCES) $(fishsound_encode_SOURCES) \
$(fishsound_identify_SOURCES) $(fishsound_info_SOURCES)
ETAGS = etags
CTAGS = ctags
DISTFILES = $(DIST_COMMON) $(DIST_SOURCES) $(TEXINFOS) $(EXTRA_DIST)
ACLOCAL = @ACLOCAL@
ACLOCAL_AMFLAGS = @ACLOCAL_AMFLAGS@
AMTAR = @AMTAR@
AR = @AR@
AUTOCONF = @AUTOCONF@
AUTOHEADER = @AUTOHEADER@
AUTOMAKE = @AUTOMAKE@
AWK = @AWK@
BINDIR = @BINDIR@
CC = @CC@
CCDEPMODE = @CCDEPMODE@
CFLAGS = @CFLAGS@
CPP = @CPP@
CPPFLAGS = @CPPFLAGS@
CYGPATH_W = @CYGPATH_W@
DEFS = @DEFS@
DEPDIR = @DEPDIR@
DOCDIR = @DOCDIR@
DSYMUTIL = @DSYMUTIL@
DUMPBIN = @DUMPBIN@
ECHO_C = @ECHO_C@
ECHO_N = @ECHO_N@
ECHO_T = @ECHO_T@
EGREP = @EGREP@
EXEEXT = @EXEEXT@
FGREP = @FGREP@
FLAC_CFLAGS = @FLAC_CFLAGS@
FLAC_LIBS = @FLAC_LIBS@
GREP = @GREP@
HAVE_DOXYGEN = @HAVE_DOXYGEN@
HAVE_PKG_CONFIG = @HAVE_PKG_CONFIG@
HAVE_VALGRIND = @HAVE_VALGRIND@
INCLUDEDIR = @INCLUDEDIR@
INSTALL = @INSTALL@
INSTALL_DATA = @INSTALL_DATA@
INSTALL_PROGRAM = @INSTALL_PROGRAM@
INSTALL_SCRIPT = @INSTALL_SCRIPT@
INSTALL_STRIP_PROGRAM = @INSTALL_STRIP_PROGRAM@
LD = @LD@
LDFLAGS = @LDFLAGS@
LIBDIR = @LIBDIR@
LIBOBJS = @LIBOBJS@
LIBS = @LIBS@
LIBTOOL = @LIBTOOL@
LIPO = @LIPO@
LN_S = @LN_S@
LTLIBOBJS = @LTLIBOBJS@
MAKEINFO = @MAKEINFO@
MKDIR_P = @MKDIR_P@
NM = @NM@
NMEDIT = @NMEDIT@
OBJDUMP = @OBJDUMP@
OBJEXT = @OBJEXT@
OGGZ_CFLAGS = @OGGZ_CFLAGS@
OGGZ_LIBS = @OGGZ_LIBS@
OTOOL = @OTOOL@
OTOOL64 = @OTOOL64@
PACKAGE = @PACKAGE@
PACKAGE_BUGREPORT = @PACKAGE_BUGREPORT@
PACKAGE_NAME = @PACKAGE_NAME@
PACKAGE_STRING = @PACKAGE_STRING@
PACKAGE_TARNAME = @PACKAGE_TARNAME@
PACKAGE_VERSION = @PACKAGE_VERSION@
PATH_SEPARATOR = @PATH_SEPARATOR@
PKG_CONFIG = @PKG_CONFIG@
RANLIB = @RANLIB@
SED = @SED@
SET_MAKE = @SET_MAKE@
SHARED_VERSION_INFO = @SHARED_VERSION_INFO@
SHELL = @SHELL@
SHLIB_VERSION_ARG = @SHLIB_VERSION_ARG@
SNDFILE_CFLAGS = @SNDFILE_CFLAGS@
SNDFILE_LIBS = @SNDFILE_LIBS@
SPEEX_CFLAGS = @SPEEX_CFLAGS@
SPEEX_LIBS = @SPEEX_LIBS@
STRIP = @STRIP@
VALGRIND_ENVIRONMENT = @VALGRIND_ENVIRONMENT@
VERSION = @VERSION@
VORBISENC_CFLAGS = @VORBISENC_CFLAGS@
VORBISENC_LIBS = @VORBISENC_LIBS@
VORBIS_CFLAGS = @VORBIS_CFLAGS@
VORBIS_LIBS = @VORBIS_LIBS@
abs_builddir = @abs_builddir@
abs_srcdir = @abs_srcdir@
abs_top_builddir = @abs_top_builddir@
abs_top_srcdir = @abs_top_srcdir@
ac_ct_CC = @ac_ct_CC@
ac_ct_DUMPBIN = @ac_ct_DUMPBIN@
am__include = @am__include@
am__leading_dot = @am__leading_dot@
am__quote = @am__quote@
am__tar = @am__tar@
am__untar = @am__untar@
bindir = @bindir@
build = @build@
build_alias = @build_alias@
build_cpu = @build_cpu@
build_os = @build_os@
build_vendor = @build_vendor@
builddir = @builddir@
datadir = @datadir@
datarootdir = @datarootdir@
docdir = @docdir@
dvidir = @dvidir@
exec_prefix = @exec_prefix@
fishsound_pkgdeps = @fishsound_pkgdeps@
host = @host@
host_alias = @host_alias@
host_cpu = @host_cpu@
host_os = @host_os@
host_vendor = @host_vendor@
htmldir = @htmldir@
includedir = @includedir@
infodir = @infodir@
install_sh = @install_sh@
libdir = @libdir@
libexecdir = @libexecdir@
localedir = @localedir@
localstatedir = @localstatedir@
lt_ECHO = @lt_ECHO@
mandir = @mandir@
mkdir_p = @mkdir_p@
oldincludedir = @oldincludedir@
pdfdir = @pdfdir@
prefix = @prefix@
program_transform_name = @program_transform_name@
psdir = @psdir@
sbindir = @sbindir@
sharedstatedir = @sharedstatedir@
srcdir = @srcdir@
sysconfdir = @sysconfdir@
target = @target@
target_alias = @target_alias@
target_cpu = @target_cpu@
target_os = @target_os@
target_vendor = @target_vendor@
top_build_prefix = @top_build_prefix@
top_builddir = @top_builddir@
top_srcdir = @top_srcdir@
AM_CFLAGS = -Wall -pedantic -g
INCLUDES = -I$(top_builddir) \
-I$(top_srcdir)/include -I$(top_srcdir)/src/libfishsound \
$(SNDFILE_CFLAGS) $(VORBIS_CFLAGS) $(SPEEX_CFLAGS) $(FLAC_CFLAGS) $(OGGZ_CFLAGS)
FISHSOUNDDIR = ../libfishsound
FISHSOUND_LIBS = $(FISHSOUNDDIR)/libfishsound.la \
$(VORBIS_LIBS) $(SPEEX_LIBS) $(FLAC_LIBS)
@HAVE_OGGZ_TRUE@oggz_examples = fishsound-identify fishsound-info fishsound-decenc
@HAVE_LIBSNDFILE1_TRUE@sndfile_examples = fishsound-encdec
@HAVE_LIBSNDFILE1_TRUE@@HAVE_OGGZ_TRUE@oggz_sndfile_examples = fishsound-decode fishsound-encode
#bin_PROGRAMS = $(oggz_examples) $(sndfile_examples) $(oggz_sndfile_examples)
fishsound_identify_SOURCES = fishsound-identify.c
fishsound_identify_LDADD = $(FISHSOUND_LIBS) $(OGGZ_LIBS)
fishsound_info_SOURCES = fishsound-info.c
fishsound_info_LDADD = $(FISHSOUND_LIBS) $(OGGZ_LIBS)
fishsound_decode_SOURCES = fishsound-decode.c
fishsound_decode_LDADD = $(FISHSOUND_LIBS) $(OGGZ_LIBS) $(SNDFILE_LIBS)
fishsound_encode_SOURCES = fishsound-encode.c
fishsound_encode_LDADD = $(FISHSOUND_LIBS) $(OGGZ_LIBS) $(SNDFILE_LIBS)
fishsound_decenc_SOURCES = fishsound-decenc.c
fishsound_decenc_LDADD = $(FISHSOUND_LIBS) $(OGGZ_LIBS)
fishsound_encdec_SOURCES = fishsound-encdec.c
fishsound_encdec_LDADD = $(FISHSOUND_LIBS) $(SNDFILE_LIBS)
all: all-am
.SUFFIXES:
.SUFFIXES: .c .lo .o .obj
$(srcdir)/Makefile.in: $(srcdir)/Makefile.am $(am__configure_deps)
@for dep in $?; do \
case '$(am__configure_deps)' in \
*$$dep*) \
( cd $(top_builddir) && $(MAKE) $(AM_MAKEFLAGS) am--refresh ) \
&& { if test -f $@; then exit 0; else break; fi; }; \
exit 1;; \
esac; \
done; \
echo ' cd $(top_srcdir) && $(AUTOMAKE) --gnu src/examples/Makefile'; \
cd $(top_srcdir) && \
$(AUTOMAKE) --gnu src/examples/Makefile
.PRECIOUS: Makefile
Makefile: $(srcdir)/Makefile.in $(top_builddir)/config.status
@case '$?' in \
*config.status*) \
cd $(top_builddir) && $(MAKE) $(AM_MAKEFLAGS) am--refresh;; \
*) \
echo ' cd $(top_builddir) && $(SHELL) ./config.status $(subdir)/$@ $(am__depfiles_maybe)'; \
cd $(top_builddir) && $(SHELL) ./config.status $(subdir)/$@ $(am__depfiles_maybe);; \
esac;
$(top_builddir)/config.status: $(top_srcdir)/configure $(CONFIG_STATUS_DEPENDENCIES)
cd $(top_builddir) && $(MAKE) $(AM_MAKEFLAGS) am--refresh
$(top_srcdir)/configure: $(am__configure_deps)
cd $(top_builddir) && $(MAKE) $(AM_MAKEFLAGS) am--refresh
$(ACLOCAL_M4): $(am__aclocal_m4_deps)
cd $(top_builddir) && $(MAKE) $(AM_MAKEFLAGS) am--refresh
clean-noinstPROGRAMS:
@list='$(noinst_PROGRAMS)'; for p in $$list; do \
f=`echo $$p|sed 's/$(EXEEXT)$$//'`; \
echo " rm -f $$p $$f"; \
rm -f $$p $$f ; \
done
fishsound-decenc$(EXEEXT): $(fishsound_decenc_OBJECTS) $(fishsound_decenc_DEPENDENCIES)
@rm -f fishsound-decenc$(EXEEXT)
$(LINK) $(fishsound_decenc_OBJECTS) $(fishsound_decenc_LDADD) $(LIBS)
fishsound-decode$(EXEEXT): $(fishsound_decode_OBJECTS) $(fishsound_decode_DEPENDENCIES)
@rm -f fishsound-decode$(EXEEXT)
$(LINK) $(fishsound_decode_OBJECTS) $(fishsound_decode_LDADD) $(LIBS)
fishsound-encdec$(EXEEXT): $(fishsound_encdec_OBJECTS) $(fishsound_encdec_DEPENDENCIES)
@rm -f fishsound-encdec$(EXEEXT)
$(LINK) $(fishsound_encdec_OBJECTS) $(fishsound_encdec_LDADD) $(LIBS)
fishsound-encode$(EXEEXT): $(fishsound_encode_OBJECTS) $(fishsound_encode_DEPENDENCIES)
@rm -f fishsound-encode$(EXEEXT)
$(LINK) $(fishsound_encode_OBJECTS) $(fishsound_encode_LDADD) $(LIBS)
fishsound-identify$(EXEEXT): $(fishsound_identify_OBJECTS) $(fishsound_identify_DEPENDENCIES)
@rm -f fishsound-identify$(EXEEXT)
$(LINK) $(fishsound_identify_OBJECTS) $(fishsound_identify_LDADD) $(LIBS)
fishsound-info$(EXEEXT): $(fishsound_info_OBJECTS) $(fishsound_info_DEPENDENCIES)
@rm -f fishsound-info$(EXEEXT)
$(LINK) $(fishsound_info_OBJECTS) $(fishsound_info_LDADD) $(LIBS)
mostlyclean-compile:
-rm -f *.$(OBJEXT)
distclean-compile:
-rm -f *.tab.c
@AMDEP_TRUE@@am__include@ @am__quote@./$(DEPDIR)/fishsound-decenc.Po@am__quote@
@AMDEP_TRUE@@am__include@ @am__quote@./$(DEPDIR)/fishsound-decode.Po@am__quote@
@AMDEP_TRUE@@am__include@ @am__quote@./$(DEPDIR)/fishsound-encdec.Po@am__quote@
@AMDEP_TRUE@@am__include@ @am__quote@./$(DEPDIR)/fishsound-encode.Po@am__quote@
@AMDEP_TRUE@@am__include@ @am__quote@./$(DEPDIR)/fishsound-identify.Po@am__quote@
@AMDEP_TRUE@@am__include@ @am__quote@./$(DEPDIR)/fishsound-info.Po@am__quote@
.c.o:
@am__fastdepCC_TRUE@ $(COMPILE) -MT $@ -MD -MP -MF $(DEPDIR)/$*.Tpo -c -o $@ $<
@am__fastdepCC_TRUE@ mv -f $(DEPDIR)/$*.Tpo $(DEPDIR)/$*.Po
@AMDEP_TRUE@@am__fastdepCC_FALSE@ source='$<' object='$@' libtool=no @AMDEPBACKSLASH@
@AMDEP_TRUE@@am__fastdepCC_FALSE@ DEPDIR=$(DEPDIR) $(CCDEPMODE) $(depcomp) @AMDEPBACKSLASH@
@am__fastdepCC_FALSE@ $(COMPILE) -c $<
.c.obj:
@am__fastdepCC_TRUE@ $(COMPILE) -MT $@ -MD -MP -MF $(DEPDIR)/$*.Tpo -c -o $@ `$(CYGPATH_W) '$<'`
@am__fastdepCC_TRUE@ mv -f $(DEPDIR)/$*.Tpo $(DEPDIR)/$*.Po
@AMDEP_TRUE@@am__fastdepCC_FALSE@ source='$<' object='$@' libtool=no @AMDEPBACKSLASH@
@AMDEP_TRUE@@am__fastdepCC_FALSE@ DEPDIR=$(DEPDIR) $(CCDEPMODE) $(depcomp) @AMDEPBACKSLASH@
@am__fastdepCC_FALSE@ $(COMPILE) -c `$(CYGPATH_W) '$<'`
.c.lo:
@am__fastdepCC_TRUE@ $(LTCOMPILE) -MT $@ -MD -MP -MF $(DEPDIR)/$*.Tpo -c -o $@ $<
@am__fastdepCC_TRUE@ mv -f $(DEPDIR)/$*.Tpo $(DEPDIR)/$*.Plo
@AMDEP_TRUE@@am__fastdepCC_FALSE@ source='$<' object='$@' libtool=yes @AMDEPBACKSLASH@
@AMDEP_TRUE@@am__fastdepCC_FALSE@ DEPDIR=$(DEPDIR) $(CCDEPMODE) $(depcomp) @AMDEPBACKSLASH@
@am__fastdepCC_FALSE@ $(LTCOMPILE) -c -o $@ $<
mostlyclean-libtool:
-rm -f *.lo
clean-libtool:
-rm -rf .libs _libs
ID: $(HEADERS) $(SOURCES) $(LISP) $(TAGS_FILES)
list='$(SOURCES) $(HEADERS) $(LISP) $(TAGS_FILES)'; \
unique=`for i in $$list; do \
if test -f "$$i"; then echo $$i; else echo $(srcdir)/$$i; fi; \
done | \
$(AWK) '{ files[$$0] = 1; nonempty = 1; } \
END { if (nonempty) { for (i in files) print i; }; }'`; \
mkid -fID $$unique
tags: TAGS
TAGS: $(HEADERS) $(SOURCES) $(TAGS_DEPENDENCIES) \
$(TAGS_FILES) $(LISP)
tags=; \
here=`pwd`; \
list='$(SOURCES) $(HEADERS) $(LISP) $(TAGS_FILES)'; \
unique=`for i in $$list; do \
if test -f "$$i"; then echo $$i; else echo $(srcdir)/$$i; fi; \
done | \
$(AWK) '{ files[$$0] = 1; nonempty = 1; } \
END { if (nonempty) { for (i in files) print i; }; }'`; \
if test -z "$(ETAGS_ARGS)$$tags$$unique"; then :; else \
test -n "$$unique" || unique=$$empty_fix; \
$(ETAGS) $(ETAGSFLAGS) $(AM_ETAGSFLAGS) $(ETAGS_ARGS) \
$$tags $$unique; \
fi
ctags: CTAGS
CTAGS: $(HEADERS) $(SOURCES) $(TAGS_DEPENDENCIES) \
$(TAGS_FILES) $(LISP)
tags=; \
list='$(SOURCES) $(HEADERS) $(LISP) $(TAGS_FILES)'; \
unique=`for i in $$list; do \
if test -f "$$i"; then echo $$i; else echo $(srcdir)/$$i; fi; \
done | \
$(AWK) '{ files[$$0] = 1; nonempty = 1; } \
END { if (nonempty) { for (i in files) print i; }; }'`; \
test -z "$(CTAGS_ARGS)$$tags$$unique" \
|| $(CTAGS) $(CTAGSFLAGS) $(AM_CTAGSFLAGS) $(CTAGS_ARGS) \
$$tags $$unique
GTAGS:
here=`$(am__cd) $(top_builddir) && pwd` \
&& cd $(top_srcdir) \
&& gtags -i $(GTAGS_ARGS) $$here
distclean-tags:
-rm -f TAGS ID GTAGS GRTAGS GSYMS GPATH tags
distdir: $(DISTFILES)
@srcdirstrip=`echo "$(srcdir)" | sed 's/[].[^$$\\*]/\\\\&/g'`; \
topsrcdirstrip=`echo "$(top_srcdir)" | sed 's/[].[^$$\\*]/\\\\&/g'`; \
list='$(DISTFILES)'; \
dist_files=`for file in $$list; do echo $$file; done | \
sed -e "s|^$$srcdirstrip/||;t" \
-e "s|^$$topsrcdirstrip/|$(top_builddir)/|;t"`; \
case $$dist_files in \
*/*) $(MKDIR_P) `echo "$$dist_files" | \
sed '/\//!d;s|^|$(distdir)/|;s,/[^/]*$$,,' | \
sort -u` ;; \
esac; \
for file in $$dist_files; do \
if test -f $$file || test -d $$file; then d=.; else d=$(srcdir); fi; \
if test -d $$d/$$file; then \
dir=`echo "/$$file" | sed -e 's,/[^/]*$$,,'`; \
if test -d $(srcdir)/$$file && test $$d != $(srcdir); then \
cp -pR $(srcdir)/$$file $(distdir)$$dir || exit 1; \
fi; \
cp -pR $$d/$$file $(distdir)$$dir || exit 1; \
else \
test -f $(distdir)/$$file \
|| cp -p $$d/$$file $(distdir)/$$file \
|| exit 1; \
fi; \
done
check-am: all-am
check: check-am
all-am: Makefile $(PROGRAMS)
installdirs:
install: install-am
install-exec: install-exec-am
install-data: install-data-am
uninstall: uninstall-am
install-am: all-am
@$(MAKE) $(AM_MAKEFLAGS) install-exec-am install-data-am
installcheck: installcheck-am
install-strip:
$(MAKE) $(AM_MAKEFLAGS) INSTALL_PROGRAM="$(INSTALL_STRIP_PROGRAM)" \
install_sh_PROGRAM="$(INSTALL_STRIP_PROGRAM)" INSTALL_STRIP_FLAG=-s \
`test -z '$(STRIP)' || \
echo "INSTALL_PROGRAM_ENV=STRIPPROG='$(STRIP)'"` install
mostlyclean-generic:
clean-generic:
distclean-generic:
-test -z "$(CONFIG_CLEAN_FILES)" || rm -f $(CONFIG_CLEAN_FILES)
maintainer-clean-generic:
@echo "This command is intended for maintainers to use"
@echo "it deletes files that may require special tools to rebuild."
clean: clean-am
clean-am: clean-generic clean-libtool clean-noinstPROGRAMS \
mostlyclean-am
distclean: distclean-am
-rm -rf ./$(DEPDIR)
-rm -f Makefile
distclean-am: clean-am distclean-compile distclean-generic \
distclean-tags
dvi: dvi-am
dvi-am:
html: html-am
info: info-am
info-am:
install-data-am:
install-dvi: install-dvi-am
install-exec-am:
install-html: install-html-am
install-info: install-info-am
install-man:
install-pdf: install-pdf-am
install-ps: install-ps-am
installcheck-am:
maintainer-clean: maintainer-clean-am
-rm -rf ./$(DEPDIR)
-rm -f Makefile
maintainer-clean-am: distclean-am maintainer-clean-generic
mostlyclean: mostlyclean-am
mostlyclean-am: mostlyclean-compile mostlyclean-generic \
mostlyclean-libtool
pdf: pdf-am
pdf-am:
ps: ps-am
ps-am:
uninstall-am:
.MAKE: install-am install-strip
.PHONY: CTAGS GTAGS all all-am check check-am clean clean-generic \
clean-libtool clean-noinstPROGRAMS ctags distclean \
distclean-compile distclean-generic distclean-libtool \
distclean-tags distdir dvi dvi-am html html-am info info-am \
install install-am install-data install-data-am install-dvi \
install-dvi-am install-exec install-exec-am install-html \
install-html-am install-info install-info-am install-man \
install-pdf install-pdf-am install-ps install-ps-am \
install-strip installcheck installcheck-am installdirs \
maintainer-clean maintainer-clean-generic mostlyclean \
mostlyclean-compile mostlyclean-generic mostlyclean-libtool \
pdf pdf-am ps ps-am tags uninstall uninstall-am
# Tell versions [3.59,3.63) of GNU make to not export all variables.
# Otherwise a system limit (for SysV at least) may be exceeded.
.NOEXPORT:
libfishsound-1.0.0/src/examples/fishsound-decenc.c 0000644 0001750 0001750 00000016635 11163316023 017123 0000000 0000000 /*
Copyright (C) 2003 Commonwealth Scientific and Industrial Research
Organisation (CSIRO) Australia
Redistribution and use in source and binary forms, with or without
modification, are permitted provided that the following conditions
are met:
- Redistributions of source code must retain the above copyright
notice, this list of conditions and the following disclaimer.
- Redistributions in binary form must reproduce the above copyright
notice, this list of conditions and the following disclaimer in the
documentation and/or other materials provided with the distribution.
- Neither the name of CSIRO Australia nor the names of its
contributors may be used to endorse or promote products derived from
this software without specific prior written permission.
THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS
``AS IS'' AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT
LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A
PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE ORGANISATION OR
CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL,
EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO,
PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR
PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF
LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING
NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS
SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
*/
#include "config.h"
#include
#include
#include
1.5.8
libfishsound-1.0.0/doc/libfishsound/html/classes.html 0000644 0001750 0001750 00000003623 11332273474 017661 0000000 0000000