audio_chunk.h

Go to the documentation of this file.

PFC_DECLARE_EXCEPTION(exception_unexpected_audio_format_change, exception_io_data, "Unexpected audio format change" );

class NOVTABLE audio_chunk {
public:

    enum {
        sample_rate_min = 1000, sample_rate_max = 2822400
    };
    static bool g_is_valid_sample_rate(t_uint32 p_val) {return p_val >= sample_rate_min && p_val <= sample_rate_max;}
    
    enum
    {
        channel_front_left          = 1<<0,
        channel_front_right         = 1<<1,
        channel_front_center        = 1<<2,
        channel_lfe                 = 1<<3,
        channel_back_left           = 1<<4,
        channel_back_right          = 1<<5,
        channel_front_center_left   = 1<<6,
        channel_front_center_right  = 1<<7,
        channel_back_center         = 1<<8,
        channel_side_left           = 1<<9,
        channel_side_right          = 1<<10,
        channel_top_center          = 1<<11,
        channel_top_front_left      = 1<<12,
        channel_top_front_center    = 1<<13,
        channel_top_front_right     = 1<<14,
        channel_top_back_left       = 1<<15,
        channel_top_back_center     = 1<<16,
        channel_top_back_right      = 1<<17,

        channel_config_mono = channel_front_center,
        channel_config_stereo = channel_front_left | channel_front_right,
        channel_config_5point1 = channel_front_left | channel_front_right | channel_front_center | channel_lfe | channel_back_left | channel_back_right,
        channel_config_5point1_side = channel_front_left | channel_front_right | channel_front_center | channel_lfe | channel_side_left | channel_side_right,
        channel_config_7point1 = channel_config_5point1 | channel_side_left | channel_side_right,

        defined_channel_count = 18,
    };

    static unsigned g_guess_channel_config(unsigned count);
    static unsigned g_guess_channel_config_xiph(unsigned count);

    static uint32_t g_channel_config_to_wfx(unsigned p_config);
    static unsigned g_channel_config_from_wfx(uint32_t p_wfx);

    static unsigned g_extract_channel_flag(unsigned p_config,unsigned p_index);
    static unsigned g_count_channels(unsigned p_config);
    static unsigned g_channel_index_from_flag(unsigned p_config,unsigned p_flag);

    static const char * g_channel_name(unsigned p_flag);
    static const char * g_channel_name_byidx(unsigned p_index);
    static unsigned g_find_channel_idx(unsigned p_flag);
    static void g_formatChannelMaskDesc(unsigned flags, pfc::string_base & out);

    

    virtual audio_sample * get_data() = 0;
    virtual const audio_sample * get_data() const = 0;
    virtual t_size get_data_size() const = 0;
    virtual void set_data_size(t_size p_new_size) = 0;
    void allocate(size_t size) { set_data_size( size ); }
    
    virtual unsigned get_srate() const = 0;
    virtual void set_srate(unsigned val) = 0;
    virtual unsigned get_channels() const = 0;
    inline unsigned get_channel_count() const {return get_channels();}
    virtual unsigned get_channel_config() const = 0;
    virtual void set_channels(unsigned p_count,unsigned p_config) = 0;

    virtual t_size get_sample_count() const = 0;
    
    virtual void set_sample_count(t_size val) = 0;

    inline unsigned get_sample_rate() const {return get_srate();}
    inline void set_sample_rate(unsigned val) {set_srate(val);}

    void set_channels(unsigned val) {set_channels(val,g_guess_channel_config(val));}

    
    inline void grow_data_size(t_size p_requested) {if (p_requested > get_data_size()) set_data_size(p_requested);}


    inline double get_duration() const
    {
        double rv = 0;
        t_size srate = get_srate (), samples = get_sample_count();
        if (srate>0 && samples>0) rv = (double)samples/(double)srate;
        return rv;
    }
    
    inline bool is_empty() const {return get_channels()==0 || get_srate()==0 || get_sample_count()==0;}
    
    bool is_valid() const;
    
    bool is_spec_valid() const;

    size_t get_used_size() const {return get_sample_count() * get_channels();}
    size_t get_data_length() const {return get_sample_count() * get_channels();}
#pragma deprecated( get_data_length )

    inline void reset() {
        set_sample_count(0);
        set_srate(0);
        set_channels(0);
        set_data_size(0);
    }
    
    void set_data(const audio_sample * src,t_size samples,unsigned nch,unsigned srate,unsigned channel_config);
    
    inline void set_data(const audio_sample * src,t_size samples,unsigned nch,unsigned srate) {set_data(src,samples,nch,srate,g_guess_channel_config(nch));}

    void set_data_int16(const int16_t * src,t_size samples,unsigned nch,unsigned srate,unsigned channel_config);
    
    inline void set_data_fixedpoint(const void * ptr,t_size bytes,unsigned srate,unsigned nch,unsigned bps,unsigned channel_config) {
        this->set_data_fixedpoint_ms(ptr, bytes, srate, nch, bps, channel_config);
    }

    void set_data_fixedpoint_signed(const void * ptr,t_size bytes,unsigned srate,unsigned nch,unsigned bps,unsigned channel_config);

    enum
    {
        FLAG_LITTLE_ENDIAN = 1,
        FLAG_BIG_ENDIAN = 2,
        FLAG_SIGNED = 4,
        FLAG_UNSIGNED = 8,
    };

    inline static unsigned flags_autoendian() {
        return pfc::byte_order_is_big_endian ? FLAG_BIG_ENDIAN : FLAG_LITTLE_ENDIAN;
    }

    void set_data_fixedpoint_ex(const void * ptr,t_size bytes,unsigned p_sample_rate,unsigned p_channels,unsigned p_bits_per_sample,unsigned p_flags,unsigned p_channel_config);//p_flags - see FLAG_* above

    void set_data_fixedpoint_ms(const void * ptr, size_t bytes, unsigned sampleRate, unsigned channels, unsigned bps, unsigned channelConfig);

    void set_data_floatingpoint_ex(const void * ptr,t_size bytes,unsigned p_sample_rate,unsigned p_channels,unsigned p_bits_per_sample,unsigned p_flags,unsigned p_channel_config);//signed/unsigned flags dont apply

    inline void set_data_32(const float * src,t_size samples,unsigned nch,unsigned srate) {return set_data(src,samples,nch,srate);}

    void pad_with_silence_ex(t_size samples,unsigned hint_nch,unsigned hint_srate);
    void pad_with_silence(t_size samples);
    void insert_silence_fromstart(t_size samples);
    t_size skip_first_samples(t_size samples);
    void set_silence(t_size samples);
    void set_silence_seconds( double seconds );

    bool process_skip(double & skipDuration);

    bool to_raw_data(class mem_block_container & out, t_uint32 bps, bool useUpperBits = true, float scale = 1.0) const;

    bool toFixedPoint(class mem_block_container & out, uint32_t bps, uint32_t bpsValid, bool useUpperBits = true, float scale = 1.0) const;

    static bool g_toFixedPoint(const audio_sample * in, void * out, size_t count, uint32_t bps, uint32_t bpsValid, bool useUpperBits = true, float scale = 1.0);


    audio_sample get_peak(audio_sample p_peak) const;
    audio_sample get_peak() const;

    void scale(audio_sample p_value);

    void copy(const audio_chunk & p_source) {
        set_data(p_source.get_data(),p_source.get_sample_count(),p_source.get_channels(),p_source.get_srate(),p_source.get_channel_config());
    }

    const audio_chunk & operator=(const audio_chunk & p_source) {
        copy(p_source);
        return *this;
    }

    struct spec_t {
        uint32_t sampleRate;
        uint32_t chanCount, chanMask;
        
        static bool equals( const spec_t & v1, const spec_t & v2 );
        bool operator==(const spec_t & other) const { return equals(*this, other);}
        bool operator!=(const spec_t & other) const { return !equals(*this, other);}
        bool is_valid() const;
    };
    static spec_t makeSpec(uint32_t rate, uint32_t channels);
    static spec_t makeSpec(uint32_t rate, uint32_t channels, uint32_t chanMask);

    spec_t get_spec() const;
    void set_spec(const spec_t &);
protected:
    audio_chunk() {}
    ~audio_chunk() {}   
};

template<typename container_t = pfc::mem_block_aligned_t<audio_sample, 16> >
class audio_chunk_impl_t : public audio_chunk {
    typedef audio_chunk_impl_t<container_t> t_self;
    container_t m_data;
    unsigned m_srate,m_nch,m_setup;
    t_size m_samples;
public:
    audio_chunk_impl_t() : m_srate(0), m_nch(0), m_samples(0), m_setup(0) {}
    audio_chunk_impl_t(const audio_sample * src,unsigned samples,unsigned nch,unsigned srate) : m_srate(0), m_nch(0), m_samples(0)
    {set_data(src,samples,nch,srate);}
    audio_chunk_impl_t(const audio_chunk & p_source) : m_srate(0), m_nch(0), m_samples(0), m_setup(0) {copy(p_source);}
    audio_chunk_impl_t(const t_self & p_source) : m_srate(0), m_nch(0), m_samples(0), m_setup(0) {copy(p_source);}
    
    virtual audio_sample * get_data() {return m_data.get_ptr();}
    virtual const audio_sample * get_data() const {return m_data.get_ptr();}
    virtual t_size get_data_size() const {return m_data.get_size();}
    virtual void set_data_size(t_size new_size) {m_data.set_size(new_size);}
    
    virtual unsigned get_srate() const {return m_srate;}
    virtual void set_srate(unsigned val) {m_srate=val;}
    virtual unsigned get_channels() const {return m_nch;}
    virtual unsigned get_channel_config() const {return m_setup;}
    virtual void set_channels(unsigned val,unsigned setup) {m_nch = val;m_setup = setup;}
    void set_channels(unsigned val) {set_channels(val,g_guess_channel_config(val));}

    virtual t_size get_sample_count() const {return m_samples;}
    virtual void set_sample_count(t_size val) {m_samples = val;}

    const t_self & operator=(const audio_chunk & p_source) {copy(p_source);return *this;}
    const t_self & operator=(const t_self & p_source) {copy(p_source);return *this;}
};

typedef audio_chunk_impl_t<> audio_chunk_impl;
typedef audio_chunk_impl_t<pfc::mem_block_aligned_incremental_t<audio_sample, 16> > audio_chunk_fast_impl;

class audio_chunk_memref_impl : public audio_chunk {
public:
    audio_chunk_memref_impl(const audio_sample * p_data,t_size p_samples,t_uint32 p_sample_rate,t_uint32 p_channels,t_uint32 p_channel_config) :
    m_data(p_data), m_samples(p_samples), m_sample_rate(p_sample_rate), m_channels(p_channels), m_channel_config(p_channel_config)
    {
        PFC_ASSERT(is_valid());
    }

    audio_sample * get_data() {throw pfc::exception_not_implemented();}
    const audio_sample * get_data() const {return m_data;}
    t_size get_data_size() const {return m_samples * m_channels;}
    void set_data_size(t_size p_new_size) {throw pfc::exception_not_implemented();}
    
    unsigned get_srate() const {return m_sample_rate;}
    void set_srate(unsigned val) {throw pfc::exception_not_implemented();}
    unsigned get_channels() const {return m_channels;}
    unsigned get_channel_config() const {return m_channel_config;}
    void set_channels(unsigned p_count,unsigned p_config) {throw pfc::exception_not_implemented();}

    t_size get_sample_count() const {return m_samples;}
    
    void set_sample_count(t_size val) {throw pfc::exception_not_implemented();}

private:
    t_size m_samples;
    t_uint32 m_sample_rate,m_channels,m_channel_config;
    const audio_sample * m_data;
};


// Compatibility typedefs.
typedef audio_chunk_fast_impl audio_chunk_impl_temporary;
typedef audio_chunk_impl audio_chunk_i;
typedef audio_chunk_memref_impl audio_chunk_temp_impl;

class duration_counter {
public:
    duration_counter() : m_offset() {
    }
    void set(double v) {
        m_sampleCounts.remove_all();
        m_offset = v;
    }
    void reset() {
        set(0);
    }

    void add(double v) {m_offset += v;}
    void subtract(double v) {m_offset -= v;}

    double query() const;
    uint64_t queryAsSampleCount( uint32_t rate );

    void add(const audio_chunk & c) {
        add(c.get_sample_count(), c.get_sample_rate());
    }
    void add(t_uint64 sampleCount, t_uint32 sampleRate) {
        PFC_ASSERT( sampleRate > 0 );
        if (sampleRate > 0 && sampleCount > 0) {
            m_sampleCounts.find_or_add(sampleRate) += sampleCount;
        }
    }
    void add(const duration_counter & other) {
        add(other.m_offset);
        for(t_map::const_iterator walk = other.m_sampleCounts.first(); walk.is_valid(); ++walk) {
            add(walk->m_value, walk->m_key);
        }
    }
    void subtract(const duration_counter & other) {
        subtract(other.m_offset);
        for(t_map::const_iterator walk = other.m_sampleCounts.first(); walk.is_valid(); ++walk) {
            subtract(walk->m_value, walk->m_key);
        }
    }
    void subtract(t_uint64 sampleCount, t_uint32 sampleRate) {
        PFC_ASSERT( sampleRate > 0 );
        if (sampleRate > 0 && sampleCount > 0) {
            t_uint64 * val = m_sampleCounts.query_ptr(sampleRate);
            if (val == NULL) throw pfc::exception_invalid_params();
            if (*val < sampleCount) throw pfc::exception_invalid_params();
            else if (*val == sampleCount) {
                m_sampleCounts.remove(sampleRate);
            } else {
                *val -= sampleCount;
            }
            
        }
    }
    void subtract(const audio_chunk & c) {
        subtract(c.get_sample_count(), c.get_sample_rate());
    }
    template<typename t_source> duration_counter & operator+=(const t_source & source) {add(source); return *this;}
    template<typename t_source> duration_counter & operator-=(const t_source & source) {subtract(source); return *this;}
    template<typename t_source> duration_counter & operator=(const t_source & source) {reset(); add(source); return *this;}
private:
    double m_offset;
    typedef pfc::map_t<t_uint32, t_uint64> t_map;
    t_map m_sampleCounts;
};

class audio_chunk_partial_ref : public audio_chunk_temp_impl {
public:
    audio_chunk_partial_ref(const audio_chunk & chunk, t_size base, t_size count) : audio_chunk_temp_impl(chunk.get_data() + base * chunk.get_channels(), count, chunk.get_sample_rate(), chunk.get_channels(), chunk.get_channel_config()) {}
};