audio2.h

Go to the documentation of this file.

// Copyright (C) 1999-2005 Open Source Telecom Corporation.
// Copyright (C) 2006-2008 David Sugar, Tycho Softworks.
//
// This file is part of GNU ccAudio2.
//
// GNU ccAudio2 is free software: you can redistribute it and/or modify
// it under the terms of the GNU Lesser General Public License as published 
// by the Free Software Foundation, either version 3 of the License, or
// (at your option) any later version.
//
// GNU ccAudio2 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 Lesser General Public License for more details.
//
// You should have received a copy of the GNU Lesser General Public License
// along with GNU ccAudio2.  If not, see <http://www.gnu.org/licenses/>.

#ifndef CCXX_AUDIO_H_
#define CCXX_AUDIO_H_

#ifndef CCXX_PACKING
#if defined(__GNUC__)
#define CCXX_PACKED
#elif !defined(__hpux) && !defined(_AIX)
#define CCXX_PACKED
#endif
#endif

#ifndef W32
#if defined(_WIN32) && defined(_MSC_VER)
#pragma warning(disable: 4996)
#define W32
#endif
#if defined(__BORLANDC__) && defined(__Windows)
#define W32
#endif
#endif

#if !defined(__EXPORT) && defined(W32)
#define __EXPORT __declspec(dllimport)
#endif

#ifndef __EXPORT
#define __EXPORT
#endif

#ifdef  W32
#include <windows.h>
#ifndef ssize_t
#define ssize_t int
#endif
#else
#include <cstddef>
#include <cstdlib>
#include <sys/types.h>
#include <netinet/in.h>
#endif

#include <ctime>

namespace ost {

#define AUDIO_SIGNED_LINEAR_RAW 1
#define AUDIO_LINEAR_CONVERSION 1
#define AUDIO_CODEC_MODULES     1
#define AUDIO_LINEAR_FRAMING    1
#define AUDIO_NATIVE_METHODS    1
#define AUDIO_RATE_RESAMPLER    1

class __EXPORT AudioCodec;
class __EXPORT AudioDevice;

class __EXPORT Audio
{
public:
#ifdef  W32
        typedef short   Sample;
        typedef short   *Linear;
        typedef short   Level;
        typedef DWORD   timeout_t;
        typedef WORD    snd16_t;
        typedef DWORD   snd32_t;
#else
        typedef int16_t snd16_t;
        typedef int32_t snd32_t;
        typedef int16_t Level;
        typedef int16_t Sample;
        typedef int16_t *Linear;
        typedef unsigned long   timeout_t;
#endif

        static const unsigned ndata;

        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;

        typedef unsigned char *Encoded;

        enum    Rate {
                rateUnknown,
                rate6khz = 6000,
                rate8khz = 8000,
                rate16khz = 16000,
                rate32khz = 32000,
                rate44khz = 44100
        };

        typedef enum Rate Rate;

        enum    Mode {
                modeRead,
                modeReadAny,
                modeReadOne,
                modeWrite,
                modeCache,
                modeInfo,
                modeFeed,

                modeAppend,     // app specific placeholders...
                modeCreate
        };

        typedef enum Mode Mode;

        enum    Encoding {
                unknownEncoding = 0,
                g721ADPCM,
                g722Audio,
                g722_7bit,
                g722_6bit,
                g723_2bit,
                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,

                // speex codecs
                speexVoice,     // narrow band
                speexAudio,

                g729Audio,
                ilbcAudio,
                speexUltra,

                speexNarrow = speexVoice,
                speexWide = speexAudio,
                g723_4bit = g721ADPCM
        };
        typedef enum Encoding Encoding;

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

        enum DeviceMode {
                PLAY,
                RECORD,
                PLAYREC
        };
        typedef enum DeviceMode DeviceMode;

        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;


#ifdef  CCXX_PACKED
#pragma pack(1)
#endif

        typedef struct {
#if     __BYTE_ORDER == __LITTLE_ENDIAN
                unsigned char mp_sync1 : 8;
                unsigned char mp_crc   : 1;
                unsigned char mp_layer : 2;
                unsigned char mp_ver   : 2;
                unsigned char mp_sync2 : 3;

                unsigned char mp_priv  : 1;
                unsigned char mp_pad   : 1;
                unsigned char mp_srate : 2;
                unsigned char mp_brate : 4;

                unsigned char mp_emp   : 2;
                unsigned char mp_original : 1;
                unsigned char mp_copyright: 1;
                unsigned char mp_extend   : 2;
                unsigned char mp_channels : 2;

#else
                unsigned char mp_sync1 : 8;

                unsigned char mp_sync2 : 3;
                unsigned char mp_ver   : 2;
                unsigned char mp_layer : 2;
                unsigned char mp_crc   : 1;

                unsigned char mp_brate : 4;
                unsigned char mp_srate : 2;
                unsigned char mp_pad   : 1;
                unsigned char mp_priv  : 1;

                unsigned char mp_channels : 2;
                unsigned char mp_extend   : 2;
                unsigned char mp_copyright : 1;
                unsigned char mp_original : 1;
                unsigned char mp_emp : 2;
#endif
        }       mpeg_audio;

        typedef struct {
                char tag_id[3];
                char tag_title[30];
                char tag_artist[30];
                char tag_album[30];
                char tag_year[4];
                char tag_note[30];
                unsigned char genre;
        }       mpeg_tagv1;

#ifdef  CCXX_PACKED
#pragma pack()
#endif

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

                Info();
                void clear(void);
                void set(void);
                void setFraming(timeout_t frame);
                void setRate(Rate rate);
        };

        static Level tolevel(float dbm);

        static float todbm(Level power);

        static bool hasDevice(unsigned device = 0);

        static AudioDevice *getDevice(unsigned device = 0, DeviceMode mode = PLAY);

        static const char *getCodecPath(void);

        static const char *getMIME(Info &info);

        static const char *getName(Encoding encoding);

        static const char *getExtension(Encoding encoding);

        static Encoding getEncoding(const char *name);

        static Encoding getStereo(Encoding encoding);

        static Encoding getMono(Encoding encoding);

        static bool isLinear(Encoding encoding);

        static bool isBuffered(Encoding encoding);

        static bool isMono(Encoding encoding);

        static bool isStereo(Encoding encoding);

        static Rate getRate(Encoding encoding);

        static Rate getRate(Encoding e, Rate request);

        static timeout_t getFraming(Encoding encoding, timeout_t timeout = 0);

        static timeout_t getFraming(Info &info, timeout_t timeout = 0);

        static bool isEndian(Encoding encoding);

        static bool isEndian(Info &info);

        static bool swapEndian(Encoding encoding, void *buffer, unsigned number);

        static void swapEncoded(Info &info, Encoded data, size_t bytes);

        static bool swapEndian(Info &info, void *buffer, unsigned number);

        static Level getImpulse(Encoding encoding, void *buffer, unsigned number);

        static Level getImpulse(Info &info, void *buffer, unsigned number = 0);

        static Level getPeak(Encoding encoding, void *buffer, unsigned number);

        static Level getPeak(Info &info, void *buffer, unsigned number = 0);

        static void toTimestamp(timeout_t duration, char *address, size_t size);

        static timeout_t toTimeout(const char *timestamp);

        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 number);

        static size_t toBytes(Encoding encoding, unsigned long number);

        static void fill(unsigned char *address, int number, Encoding encoding);

        static bool loadPlugin(const char *path);

        static size_t maxFramesize(Info &info);
};

class __EXPORT AudioResample : public Audio
{
protected:
        unsigned mfact, dfact, max;
        unsigned gpos, ppos;
        Sample last;
        Linear buffer;

public:
        AudioResample(Rate mul, Rate div);
        ~AudioResample();

        size_t process(Linear from, Linear to, size_t count);
        size_t estimate(size_t count);
};

class __EXPORT AudioTone : public Audio
{
protected:
        Rate rate;
        unsigned samples;
        Linear frame;
        double df1, df2, p1, p2;
        Level m1, m2;
        bool silencer;

        void silence(void);

        void reset(void);

        void cleanup(void);

        void single(unsigned freq, Level level);

        void dual(unsigned f1, unsigned f2, Level l1, Level l2);

public:
        inline Rate getRate(void)
                {return rate;};

        inline size_t getSamples(void)
                {return samples;};

        bool isSilent(void);

        virtual Linear getFrame(void);

        unsigned getFrames(Linear buffer, unsigned number);

        virtual bool isComplete(void);

        AudioTone(timeout_t duration = 20, Rate rate = rate8khz);

        AudioTone(unsigned f1, unsigned f2, Level l1, Level l2,
                timeout_t duration = 20, Rate sample = rate8khz);

        AudioTone(unsigned freq, Level level, timeout_t duration = 20, Rate sample = rate8khz);

        virtual ~AudioTone();
};

class __EXPORT AudioBase : public Audio
{
protected:
        Info info;

public:
        AudioBase();

        AudioBase(Info *info);

        virtual ~AudioBase();

        inline Encoding getEncoding(void)
                {return info.encoding;};

        inline unsigned getSampleRate(void)
                {return info.rate;};

        virtual ssize_t putBuffer(Encoded data, size_t size) = 0;

        ssize_t putNative(Encoded data, size_t size);

        virtual ssize_t getBuffer(Encoded data, size_t size) = 0;

        inline ssize_t getPacket(Encoded data)
                {return getBuffer(data, 0);};

        ssize_t getNative(Encoded data, size_t size);
};

class __EXPORT AudioBuffer : public AudioBase
{
public:
        AudioBuffer(Info *info, size_t size = 4096);
        virtual ~AudioBuffer();

        ssize_t getBuffer(Encoded data, size_t number);

        ssize_t putBuffer(Encoded data, size_t number);

private:
        char *buf;
        size_t size, start, len;
        void *mutexObject;

        void enter(void);
        void leave(void);
};

class __EXPORT AudioFile: public AudioBase
{
protected:
        char *pathname;
        Error error;
        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);
        void mp3info(mpeg_audio *mp3);

        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);

        inline 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 *name, unsigned long offset = 0);

        AudioFile(const char *name, Info *info, unsigned long minimum = 0);

        inline AudioFile()
                {initialize();};

        virtual ~AudioFile();

        void open(const char *name, Mode mode = modeWrite, timeout_t framing = 0);

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

        time_t getAge(void);

        inline size_t getSize(void)
                {return maxFramesize(info);};

        void close(void);

        void clear(void);

        ssize_t getBuffer(Encoded buffer, size_t len = 0);

        unsigned getLinear(Linear buffer, unsigned request = 0);

        ssize_t putBuffer(Encoded buffer, size_t len = 0);

        unsigned putLinear(Linear buffer, unsigned request = 0);

        Error getSamples(void *buffer, unsigned samples = 0);

        Error putSamples(void *buffer, unsigned samples = 0);

        Error skip(long number);

        Error setPosition(unsigned long samples = ~0l);

        Error position(const char *timestamp);

        void getPosition(char *timestamp, size_t size);

        Error setLimit(unsigned long maximum = 0l);

        Error getInfo(Info *info);

        Error setMinimum(unsigned long minimum);

        unsigned long getAbsolutePosition(void);

        unsigned long getPosition(void);

        virtual bool isOpen(void);

        virtual bool hasPositioning(void)
                {return true;};

        inline Encoding getEncoding(void)
                {return info.encoding;};

        inline Format getFormat(void)
                {return info.format;};

        inline unsigned getSampleRate(void)
                {return info.rate;};

        inline char *getAnnotation(void)
                {return info.annotation;};

        inline Error getError(void)
                {return error;};

        inline bool operator!(void)
                {return (bool)!isOpen();};

        bool isSigned(void);
};

class __EXPORT AudioStream : public AudioFile
{
protected:
        AudioCodec *codec;      // if needed
        Encoded framebuf;
        bool streamable;
        Linear bufferFrame;
        unsigned bufferPosition;
        unsigned bufferChannels;
        Linear encBuffer, decBuffer;
        unsigned encSize, decSize;

        unsigned bufAudio(Linear samples, unsigned count, unsigned size);

public:
        AudioStream();

        AudioStream(const char *name, Mode mode = modeRead, timeout_t framing = 0);

        AudioStream(const char *name, Info *info, bool exclusive = false, timeout_t framing = 0);

        virtual ~AudioStream();

        ssize_t getBuffer(Encoded data, size_t count);

        void open(const char *name, Mode mode = modeRead, timeout_t framing = 0);

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

        void close(void);

        void flush(void);

        bool isStreamable(void);

        unsigned getCount(void);        // frame count

        unsigned getEncoded(AudioCodec *codec, Encoded address, unsigned frames = 1);

        unsigned putEncoded(AudioCodec *codec, Encoded address, unsigned frames = 1);

        unsigned getEncoded(Encoded address, unsigned frames = 1);

        unsigned putEncoded(Encoded address, unsigned frames = 1);

        ssize_t getPacket(Encoded data);

        unsigned getMono(Linear buffer, unsigned frames = 1);

        unsigned getStereo(Linear buffer, unsigned frames = 1);

        unsigned putMono(Linear buffer, unsigned frames = 1);

        unsigned putStereo(Linear buffer, unsigned frames = 1);

        unsigned bufMono(Linear buffer, unsigned count);

        unsigned bufStereo(Linear buffer, unsigned count);

        inline AudioCodec *getCodec(void)
                {return codec;};
};

class __EXPORT AudioCodec : public Audio
{
protected:
        static AudioCodec *first;
        AudioCodec *next;
        Encoding encoding;
        const char *name;
        Info info;

        AudioCodec();

        virtual AudioCodec *getByFormat(const char *format)
                {return this;};

        virtual AudioCodec *getByInfo(Info &info)
                {return this;};

public:
        AudioCodec(const char *name, Encoding encoding);

        virtual ~AudioCodec() {};

        static void endCodec(AudioCodec *codec);

        static AudioCodec *getCodec(Encoding encoding, const char *format = NULL, bool loaded = false);

        static AudioCodec *getCodec(Info &info, bool loaded = false);

        static bool load(const char *name);

        static bool load(Encoding encoding);

        virtual Level getImpulse(void *buffer, unsigned number = 0);

        virtual Level getPeak(void *buffer, unsigned number = 0);

        virtual bool isSilent(Level threashold, void *buffer, unsigned number = 0);

        virtual unsigned encode(Linear buffer, void *dest, unsigned number = 0) = 0;

        virtual unsigned encodeBuffered(Linear Buffer, Encoded dest, unsigned number);

        virtual unsigned decode(Linear buffer, void *source, unsigned number = 0) = 0;

        virtual unsigned decodeBuffered(Linear buffer, Encoded source, unsigned len);

        virtual unsigned getEstimated(void);

        virtual unsigned getRequired(void);

        virtual unsigned getPacket(Encoded destination, Encoded data, unsigned size);

        inline Info getInfo(void)
                {return info;};
};

class __EXPORT AudioDevice : public AudioBase
{
protected:
        bool enabled;

public:
        virtual ~AudioDevice() {};

        virtual unsigned putSamples(Linear buffer, unsigned count) = 0;

        virtual unsigned getSamples(Linear buffer, unsigned count) = 0;

        virtual ssize_t putBuffer(Encoded data, size_t count);

        virtual ssize_t getBuffer(Encoded data, size_t count);

        virtual bool setEncoded(Info &info)
                {return false;};

        virtual bool setAudio(Rate rate = rate8khz, bool stereo = false, timeout_t framing = 20) = 0;

        virtual void sync(void)
                {return;};

        virtual void flush(void) = 0;

        unsigned bufMono(Linear buffer, unsigned count);

        unsigned bufStereo(Linear buffer, unsigned count);

        inline Info *getInfo(void)
                {return &info;};

        inline bool isEnabled(void)
                {return enabled;};
};

class __EXPORT TelTone : public AudioTone
{
public:
        typedef struct _tonedef {
                struct _tonedef *next;
                timeout_t duration, silence;
                unsigned count;
                unsigned short f1, f2;
        } tonedef_t;

        typedef struct _tonekey {
                struct _tonekey *next;
                struct _tonedef *first;
                struct _tonedef *last;
                char id[1];
        } tonekey_t;

        TelTone(tonekey_t *key, Level level, timeout_t frame = 20);
        ~TelTone();

        Linear getFrame(void);

        bool isComplete(void);


        static bool load(const char *pathname, const char *locale = NULL);

        static tonekey_t *find(const char *tone, const char *locale = NULL);

protected:
        tonekey_t *tone;
        tonedef_t *def;
        unsigned remaining, silent, count;
        timeout_t framing;
        Level level;
        bool complete;
};

class __EXPORT DTMFTones : public AudioTone
{
protected:
        unsigned remaining, dtmfframes;
        timeout_t frametime;
        const char *digits;
        Level level;
        bool complete;

public:
        DTMFTones(const char *digits, Level level, timeout_t duration = 20, timeout_t interdigit = 60);

        ~DTMFTones();

        Linear getFrame(void);
        bool isComplete(void);
};

class __EXPORT MFTones : public AudioTone
{
protected:
        unsigned remaining, mfframes;
        timeout_t frametime;
        const char *digits;
        Level level;
        bool complete, kflag;

public:
        MFTones(const char *digits, Level level, timeout_t duration = 20, timeout_t interdigit = 60);

        ~MFTones();

        Linear getFrame(void);
        bool isComplete(void);
};


class __EXPORT DTMFDetect : public Audio
{
public:
        DTMFDetect();
        ~DTMFDetect();

        int putSamples(Linear buffer, int count);

        int getResult(char *data, int size);

protected:
        void goertzelInit(goertzel_state_t *s, tone_detection_descriptor_t *t);
        void goertzelUpdate(goertzel_state_t *s, Sample x[], int samples);
        float goertzelResult(goertzel_state_t *s);

private:
        dtmf_detect_state_t *state;
        tone_detection_descriptor_t dtmf_detect_row[4];
        tone_detection_descriptor_t dtmf_detect_col[4];
        tone_detection_descriptor_t dtmf_detect_row_2nd[4];
        tone_detection_descriptor_t dtmf_detect_col_2nd[4];
        tone_detection_descriptor_t fax_detect;
        tone_detection_descriptor_t fax_detect_2nd;
};

}

#endif