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