bayonneaudio.h

Go to the documentation of this file.

// Copyright (C) 1999-2001 Open Source Telecom Corporation.
//  
// This program is free software; you can redistribute it and/or modify
// it under the terms of the GNU General Public License as published by
// the Free Software Foundation; either version 2 of the License, or
// (at your option) any later version.
// 
// This program is distributed in the hope that it will be useful,
// but WITHOUT ANY WARRANTY; without even the implied warranty of
// MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
// GNU General Public License for more details.
//
// You should have received a copy of the GNU General Public License
// along with this program; if not, write to the Free Software 
// Foundation, Inc., 59 Temple Place - Suite 330, Boston, MA 02111-1307, USA.
// 
// As a special exception to the GNU General Public License, permission is 
// granted for additional uses of the text contained in its release
// of ccaudio.
//
// The exception is that, if you link the ccaudio library with other
// files to produce an executable, this does not by itself cause the
// resulting executable to be covered by the GNU General Public License.
// Your use of that executable is in no way restricted on account of
// linking the ccaudio library code into it.
//
// This exception does not however invalidate any other reasons why
// the executable file might be covered by the GNU General Public License.
// 
// This exception applies only to the code released under the 
// name ccaudio.  If you copy code from other releases into a copy of
// ccaudio, as the General Public License permits, the exception does
// not apply to the code that you add in this way.  To avoid misleading
// anyone as to the status of such modified files, you must delete
// this exception notice from them.
// 
// If you write modifications of your own for ccaudio, it is your choice
// whether to permit this exception to apply to your modifications.
// If you do not wish that, delete this exception notice.  

#ifndef CCXX_BAYONNEAUDIO_H_
#define CCXX_BAYONNEAUDIO_H_

#ifndef CCXX_CONFIG_H_
#include <cc++/config.h>
#endif

#ifndef CCXX_THREAD_H_
#include <cc++/thread.h>
#endif

#ifdef  CCXX_NAMESPACES
namespace ost {
#endif

#define AUDIO_SIGNED_LINEAR_RAW 1
#define AUDIO_LINEAR_CONVERSION 1
#define AUDIO_CODEC_MODULES     1

typedef signed short *Linear;

typedef struct
{
        float v2;
        float v3;
        float fac;
} goertzel_state_t;

typedef struct
{
        int hit1;
        int hit2;
        int hit3;
        int hit4;
        int mhit;

        goertzel_state_t row_out[4];
        goertzel_state_t col_out[4];
        goertzel_state_t row_out2nd[4];
        goertzel_state_t col_out2nd[4];
        goertzel_state_t fax_tone;
        goertzel_state_t fax_tone2nd;
        float energy;

        int current_sample;
        char digits[129];
        int current_digits;
        int detected_digits;
        int lost_digits;
        int digit_hits[16];
        int fax_hits;
} dtmf_detect_state_t;

typedef struct
{
        float fac;
} tone_detection_descriptor_t;

class __EXPORT AudioCodec;

class __EXPORT Audio
{
public:
        enum    Rate
        {
                rateUnknown,
                rate6khz = 6000,
                rate8khz = 8000,
                rate44khz = 44100
        };

        typedef enum Rate Rate;

        enum    Mode
        {
                modeRead,
                modeWrite,
                modeCache,
                modeInfo
        };

        typedef enum Mode Mode;

        enum    Encoding
        {
                unknownEncoding = 0,
                g721ADPCM,
                g722Audio,
                g722_7bit,
                g722_6bit,
                g723_3bit,
                g723_5bit,
                gsmVoice,
                msgsmVoice,
                mulawAudio,
                alawAudio,
                mp1Audio,
                mp2Audio,
                mp3Audio,
                okiADPCM,
                voxADPCM,
                sx73Voice,
                sx96Voice,

                // Please keep the PCM types at the end of the list -
                // see the "is this PCM or not?" code in
                // AudioFile::close for why.
                cdaStereo,
                cdaMono,
                pcm8Stereo,
                pcm8Mono,
                pcm16Stereo,
                pcm16Mono,
                pcm32Stereo,
                pcm32Mono
        };
        typedef enum Encoding Encoding;

        enum Format
        {
                raw,
                snd,
                riff,
                mpeg,
                wave
        };
        typedef enum Format Format;

        enum Error
        {
                errSuccess = 0,
                errReadLast,
                errNotOpened,
                errEndOfFile,
                errStartOfFile,
                errRateInvalid,
                errEncodingInvalid,
                errReadInterrupt,
                errWriteInterrupt,
                errReadFailure,
                errWriteFailure,
                errReadIncomplete,
                errWriteIncomplete,
                errRequestInvalid,
                errTOCFailed,
                errStatFailed,
                errInvalidTrack,
                errPlaybackFailed,
                errNotPlaying,
                errNoCodec
        };
        typedef enum Error Error;

        class __EXPORT Info
        {
        public:
                Format format;
                Encoding encoding;
                unsigned long rate;
                unsigned long bitrate;
                unsigned order;
                unsigned framesize, framecount;
                timeout_t framing;
                char *annotation;

                Info();
                void set(void);
                void setFraming(timeout_t frame);
        };

        static bool isLinear(Encoding encoding);
        static bool isMono(Encoding encoding);
        static bool isStereo(Encoding encoding);
        static Rate getRate(Encoding encoding);
        static timeout_t getFraming(Encoding encoding);
        static bool isEndian(Encoding encoding);
        static bool isEndian(Info &info);
        static bool swapEndian(Encoding encoding, void *buffer, unsigned samples);
        static bool swapEndian(Info &info, void *buffer, unsigned samples);
        static short getImpulse(Encoding encoding, void *buffer, unsigned samples);
        static short getImpulse(Info &info, void *buffer, unsigned samples = 0);
        static short getPeak(Encoding encoding, void *buffer, unsigned samples);
        static short getPeak(Info &info, void *buffer, unsigned samples = 0);


        static int getFrame(Encoding encoding, int samples = 0);

        static int getCount(Encoding encoding);
        static unsigned long toSamples(Encoding encoding, size_t bytes);
        static unsigned long toSamples(Info &info, size_t bytes);
        static size_t toBytes(Info &info, unsigned long samples);
        static size_t toBytes(Encoding encoding, unsigned long samples);
        static void fill(unsigned char *addr, int samples, Encoding encoding);
};

class __EXPORT AudioFile: public Audio
{
protected:
        char *pathname;
        Error error;
        Info info;
        unsigned long header;           // offset to start of audio
        unsigned long minimum;          // minimum sample size required
        unsigned long length;           // current size of file, including header

        void initialize(void);
        void getWaveFormat(int size);

        union
        {
                int fd;
                void *handle;
        } file;

        Mode mode;
        unsigned long iolimit;

        virtual bool afCreate(const char *path, bool exclusive = false);
        virtual bool afOpen(const char *path, Mode m = modeWrite);
        virtual bool afPeek(unsigned char *data, unsigned size);

        AudioCodec *getCodec(void);

        virtual int afRead(unsigned char *data, unsigned size);

        virtual int afWrite(unsigned char *data, unsigned size);

        virtual bool afSeek(unsigned long pos);
        virtual void afClose(void);

        virtual char *getContinuation(void)
                {return NULL;};

        const char * getErrorStr(Error err);
        Error setError(Error err);

        unsigned long getHeader(void)
                {return header;};

        unsigned short getShort(unsigned char *data);
        void setShort(unsigned char *data, unsigned short value);
        unsigned long getLong(unsigned char *data);
        void setLong(unsigned char *data, unsigned long value);

public:
        AudioFile(const char *fname, unsigned long samples = 0);
        AudioFile(const char *fname, Info *info, unsigned long min = 0);

        AudioFile()
                {initialize();};

        virtual ~AudioFile()
                {clear();};

        void open(const char *fname, Mode m = modeWrite, timeout_t framing = 0);

        void create(const char *fname, Info *info, bool exclusive = false, timeout_t framing = 0);

---