Main Page   Modules   Class Hierarchy   Alphabetical List   Compound List   File List   Compound Members   File Members  

include/OggFLAC++/decoder.h

Go to the documentation of this file.
00001 /* libOggFLAC++ - Free Lossless Audio Codec + Ogg library
00002  * Copyright (C) 2002,2003,2004,2005  Josh Coalson
00003  *
00004  * Redistribution and use in source and binary forms, with or without
00005  * modification, are permitted provided that the following conditions
00006  * are met:
00007  *
00008  * - Redistributions of source code must retain the above copyright
00009  * notice, this list of conditions and the following disclaimer.
00010  *
00011  * - Redistributions in binary form must reproduce the above copyright
00012  * notice, this list of conditions and the following disclaimer in the
00013  * documentation and/or other materials provided with the distribution.
00014  *
00015  * - Neither the name of the Xiph.org Foundation nor the names of its
00016  * contributors may be used to endorse or promote products derived from
00017  * this software without specific prior written permission.
00018  *
00019  * THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS
00020  * ``AS IS'' AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT
00021  * LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR
00022  * A PARTICULAR PURPOSE ARE DISCLAIMED.  IN NO EVENT SHALL THE FOUNDATION OR
00023  * CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL,
00024  * EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO,
00025  * PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR
00026  * PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF
00027  * LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING
00028  * NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS
00029  * SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
00030  */
00031 
00032 #ifndef OggFLACPP__DECODER_H
00033 #define OggFLACPP__DECODER_H
00034 
00035 #include "export.h"
00036 
00037 #include "OggFLAC/file_decoder.h"
00038 #include "OggFLAC/seekable_stream_decoder.h"
00039 #include "OggFLAC/stream_decoder.h"
00040 // we only need this for the state abstraction really...
00041 #include "FLAC++/decoder.h"
00042 
00043 
00071 namespace OggFLAC {
00072     namespace Decoder {
00073 
00074         // ============================================================
00075         //
00076         //  Equivalent: OggFLAC__StreamDecoder
00077         //
00078         // ============================================================
00079 
00093         class OggFLACPP_API Stream {
00094         public:
00095             class OggFLACPP_API State {
00096             public:
00097                 inline State(::OggFLAC__StreamDecoderState state): state_(state) { }
00098                 inline operator ::OggFLAC__StreamDecoderState() const { return state_; }
00099                 inline const char *as_cstring() const { return ::OggFLAC__StreamDecoderStateString[state_]; }
00100                 inline const char *resolved_as_cstring(const Stream &decoder) const { return ::OggFLAC__stream_decoder_get_resolved_state_string(decoder.decoder_); }
00101             protected:
00102                 ::OggFLAC__StreamDecoderState state_;
00103             };
00104 
00105             Stream();
00106             virtual ~Stream();
00107 
00108             bool is_valid() const;
00109             inline operator bool() const { return is_valid(); }
00110 
00111             bool set_serial_number(long value);
00112             bool set_metadata_respond(::FLAC__MetadataType type);
00113             bool set_metadata_respond_application(const FLAC__byte id[4]);
00114             bool set_metadata_respond_all();
00115             bool set_metadata_ignore(::FLAC__MetadataType type);
00116             bool set_metadata_ignore_application(const FLAC__byte id[4]);
00117             bool set_metadata_ignore_all();
00118 
00119             State get_state() const;
00120             FLAC::Decoder::Stream::State get_FLAC_stream_decoder_state() const;
00121             unsigned get_channels() const;
00122             ::FLAC__ChannelAssignment get_channel_assignment() const;
00123             unsigned get_bits_per_sample() const;
00124             unsigned get_sample_rate() const;
00125             unsigned get_blocksize() const;
00126 
00131             State init();
00132 
00133             void finish();
00134 
00135             bool flush();
00136             bool reset();
00137 
00138             bool process_single();
00139             bool process_until_end_of_metadata();
00140             bool process_until_end_of_stream();
00141         protected:
00142             virtual ::FLAC__StreamDecoderReadStatus read_callback(FLAC__byte buffer[], unsigned *bytes) = 0;
00143             virtual ::FLAC__StreamDecoderWriteStatus write_callback(const ::FLAC__Frame *frame, const FLAC__int32 * const buffer[]) = 0;
00144             virtual void metadata_callback(const ::FLAC__StreamMetadata *metadata) = 0;
00145             virtual void error_callback(::FLAC__StreamDecoderErrorStatus status) = 0;
00146 
00147 #if (defined _MSC_VER) || (defined __GNUG__ && (__GNUG__ < 2 || (__GNUG__ == 2 && __GNUC_MINOR__ < 96))) || (defined __SUNPRO_CC)
00148             // lame hack: some MSVC/GCC versions can't see a protected decoder_ from nested State::resolved_as_cstring()
00149             friend State;
00150 #endif
00151             ::OggFLAC__StreamDecoder *decoder_;
00152         private:
00153             static ::FLAC__StreamDecoderReadStatus read_callback_(const ::OggFLAC__StreamDecoder *decoder, FLAC__byte buffer[], unsigned *bytes, void *client_data);
00154             static ::FLAC__StreamDecoderWriteStatus write_callback_(const ::OggFLAC__StreamDecoder *decoder, const ::FLAC__Frame *frame, const FLAC__int32 * const buffer[], void *client_data);
00155             static void metadata_callback_(const ::OggFLAC__StreamDecoder *decoder, const ::FLAC__StreamMetadata *metadata, void *client_data);
00156             static void error_callback_(const ::OggFLAC__StreamDecoder *decoder, ::FLAC__StreamDecoderErrorStatus status, void *client_data);
00157 
00158             // Private and undefined so you can't use them:
00159             Stream(const Stream &);
00160             void operator=(const Stream &);
00161         };
00162 
00163         /* \} */
00164 
00165         // ============================================================
00166         //
00167         //  Equivalent: OggFLAC__SeekableStreamDecoder
00168         //
00169         // ============================================================
00170 
00184         class OggFLACPP_API SeekableStream {
00185         public:
00186             class OggFLACPP_API State {
00187             public:
00188                 inline State(::OggFLAC__SeekableStreamDecoderState state): state_(state) { }
00189                 inline operator ::OggFLAC__SeekableStreamDecoderState() const { return state_; }
00190                 inline const char *as_cstring() const { return ::OggFLAC__SeekableStreamDecoderStateString[state_]; }
00191                 inline const char *resolved_as_cstring(const SeekableStream &decoder) const { return ::OggFLAC__seekable_stream_decoder_get_resolved_state_string(decoder.decoder_); }
00192             protected:
00193                 ::OggFLAC__SeekableStreamDecoderState state_;
00194             };
00195 
00196             SeekableStream();
00197             virtual ~SeekableStream();
00198 
00199             bool is_valid() const;
00200             inline operator bool() const { return is_valid(); }
00201 
00202             bool set_serial_number(long value);
00203             bool set_md5_checking(bool value);
00204             bool set_metadata_respond(::FLAC__MetadataType type);
00205             bool set_metadata_respond_application(const FLAC__byte id[4]);
00206             bool set_metadata_respond_all();
00207             bool set_metadata_ignore(::FLAC__MetadataType type);
00208             bool set_metadata_ignore_application(const FLAC__byte id[4]);
00209             bool set_metadata_ignore_all();
00210 
00211             State get_state() const;
00212             OggFLAC::Decoder::Stream::State get_stream_decoder_state() const;
00213             FLAC::Decoder::Stream::State get_FLAC_stream_decoder_state() const;
00214             bool get_md5_checking() const;
00215             unsigned get_channels() const;
00216             ::FLAC__ChannelAssignment get_channel_assignment() const;
00217             unsigned get_bits_per_sample() const;
00218             unsigned get_sample_rate() const;
00219             unsigned get_blocksize() const;
00220 
00221             State init();
00222 
00223             bool finish();
00224 
00225             bool flush();
00226             bool reset();
00227 
00228             bool process_single();
00229             bool process_until_end_of_metadata();
00230             bool process_until_end_of_stream();
00231 
00232             bool seek_absolute(FLAC__uint64 sample);
00233         protected:
00234             virtual ::OggFLAC__SeekableStreamDecoderReadStatus read_callback(FLAC__byte buffer[], unsigned *bytes) = 0;
00235             virtual ::OggFLAC__SeekableStreamDecoderSeekStatus seek_callback(FLAC__uint64 absolute_byte_offset) = 0;
00236             virtual ::OggFLAC__SeekableStreamDecoderTellStatus tell_callback(FLAC__uint64 *absolute_byte_offset) = 0;
00237             virtual ::OggFLAC__SeekableStreamDecoderLengthStatus length_callback(FLAC__uint64 *stream_length) = 0;
00238             virtual bool eof_callback() = 0;
00239             virtual ::FLAC__StreamDecoderWriteStatus write_callback(const ::FLAC__Frame *frame, const FLAC__int32 * const buffer[]) = 0;
00240             virtual void metadata_callback(const ::FLAC__StreamMetadata *metadata) = 0;
00241             virtual void error_callback(::FLAC__StreamDecoderErrorStatus status) = 0;
00242 
00243 #if (defined _MSC_VER) || (defined __GNUG__ && (__GNUG__ < 2 || (__GNUG__ == 2 && __GNUC_MINOR__ < 96))) || (defined __SUNPRO_CC)
00244             // lame hack: some MSVC/GCC versions can't see a protected decoder_ from nested State::resolved_as_cstring()
00245             friend State;
00246 #endif
00247             ::OggFLAC__SeekableStreamDecoder *decoder_;
00248         private:
00249             static ::OggFLAC__SeekableStreamDecoderReadStatus read_callback_(const ::OggFLAC__SeekableStreamDecoder *decoder, FLAC__byte buffer[], unsigned *bytes, void *client_data);
00250             static ::OggFLAC__SeekableStreamDecoderSeekStatus seek_callback_(const ::OggFLAC__SeekableStreamDecoder *decoder, FLAC__uint64 absolute_byte_offset, void *client_data);
00251             static ::OggFLAC__SeekableStreamDecoderTellStatus tell_callback_(const ::OggFLAC__SeekableStreamDecoder *decoder, FLAC__uint64 *absolute_byte_offset, void *client_data);
00252             static ::OggFLAC__SeekableStreamDecoderLengthStatus length_callback_(const ::OggFLAC__SeekableStreamDecoder *decoder, FLAC__uint64 *stream_length, void *client_data);
00253             static FLAC__bool eof_callback_(const ::OggFLAC__SeekableStreamDecoder *decoder, void *client_data);
00254             static ::FLAC__StreamDecoderWriteStatus write_callback_(const ::OggFLAC__SeekableStreamDecoder *decoder, const ::FLAC__Frame *frame, const FLAC__int32 * const buffer[], void *client_data);
00255             static void metadata_callback_(const ::OggFLAC__SeekableStreamDecoder *decoder, const ::FLAC__StreamMetadata *metadata, void *client_data);
00256             static void error_callback_(const ::OggFLAC__SeekableStreamDecoder *decoder, ::FLAC__StreamDecoderErrorStatus status, void *client_data);
00257 
00258             // Private and undefined so you can't use them:
00259             SeekableStream(const SeekableStream &);
00260             void operator=(const SeekableStream &);
00261         };
00262 
00263         /* \} */
00264 
00265         // ============================================================
00266         //
00267         //  Equivalent: OggFLAC__FileDecoder
00268         //
00269         // ============================================================
00270 
00284         class OggFLACPP_API File {
00285         public:
00286             class OggFLACPP_API State {
00287             public:
00288                 inline State(::OggFLAC__FileDecoderState state): state_(state) { }
00289                 inline operator ::OggFLAC__FileDecoderState() const { return state_; }
00290                 inline const char *as_cstring() const { return ::OggFLAC__FileDecoderStateString[state_]; }
00291                 inline const char *resolved_as_cstring(const File &decoder) const { return ::OggFLAC__file_decoder_get_resolved_state_string(decoder.decoder_); }
00292             protected:
00293                 ::OggFLAC__FileDecoderState state_;
00294             };
00295 
00296             File();
00297             virtual ~File();
00298 
00299             bool is_valid() const;
00300             inline operator bool() const { return is_valid(); }
00301 
00302             bool set_serial_number(long value);
00303             bool set_md5_checking(bool value);
00304             bool set_filename(const char *value); 
00305             bool set_metadata_respond(::FLAC__MetadataType type);
00306             bool set_metadata_respond_application(const FLAC__byte id[4]);
00307             bool set_metadata_respond_all();
00308             bool set_metadata_ignore(::FLAC__MetadataType type);
00309             bool set_metadata_ignore_application(const FLAC__byte id[4]);
00310             bool set_metadata_ignore_all();
00311 
00312             State get_state() const;
00313             OggFLAC::Decoder::SeekableStream::State get_seekable_stream_decoder_state() const;
00314             OggFLAC::Decoder::Stream::State get_stream_decoder_state() const;
00315             FLAC::Decoder::Stream::State get_FLAC_stream_decoder_state() const;
00316             bool get_md5_checking() const;
00317             unsigned get_channels() const;
00318             ::FLAC__ChannelAssignment get_channel_assignment() const;
00319             unsigned get_bits_per_sample() const;
00320             unsigned get_sample_rate() const;
00321             unsigned get_blocksize() const;
00322 
00323             State init();
00324 
00325             bool finish();
00326 
00327             bool process_single();
00328             bool process_until_end_of_metadata();
00329             bool process_until_end_of_file();
00330 
00331             bool seek_absolute(FLAC__uint64 sample);
00332         protected:
00333             virtual ::FLAC__StreamDecoderWriteStatus write_callback(const ::FLAC__Frame *frame, const FLAC__int32 * const buffer[]) = 0;
00334             virtual void metadata_callback(const ::FLAC__StreamMetadata *metadata) = 0;
00335             virtual void error_callback(::FLAC__StreamDecoderErrorStatus status) = 0;
00336 
00337 #if (defined _MSC_VER) || (defined __GNUG__ && (__GNUG__ < 2 || (__GNUG__ == 2 && __GNUC_MINOR__ < 96))) || (defined __SUNPRO_CC)
00338             // lame hack: some MSVC/GCC versions can't see a protected decoder_ from nested State::resolved_as_cstring()
00339             friend State;
00340 #endif
00341             ::OggFLAC__FileDecoder *decoder_;
00342         private:
00343             static ::FLAC__StreamDecoderWriteStatus write_callback_(const ::OggFLAC__FileDecoder *decoder, const ::FLAC__Frame *frame, const FLAC__int32 * const buffer[], void *client_data);
00344             static void metadata_callback_(const ::OggFLAC__FileDecoder *decoder, const ::FLAC__StreamMetadata *metadata, void *client_data);
00345             static void error_callback_(const ::OggFLAC__FileDecoder *decoder, ::FLAC__StreamDecoderErrorStatus status, void *client_data);
00346 
00347             // Private and undefined so you can't use them:
00348             File(const File &);
00349             void operator=(const File &);
00350         };
00351 
00352         /* \} */
00353 
00354     }
00355 }
00356 
00357 #endif

Generated on Fri Feb 4 18:39:09 2005 for FLAC by doxygen1.2.14 written by Dimitri van Heesch, © 1997-2002