audio_chunk

#include <audio_chunk.h>

Inheritance diagram for audio_chunk:

Data Structures
struct	spec_t

Public Types
enum	{ sample_rate_min = 1000, sample_rate_max = 2822400 }
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 }
enum	{ FLAG_LITTLE_ENDIAN = 1, FLAG_BIG_ENDIAN = 2, FLAG_SIGNED = 4, FLAG_UNSIGNED = 8 }

Public Member Functions
void	allocate (size_t size)
void	copy (const audio_chunk &p_source)
virtual unsigned	get_channel_config () const =0
unsigned	get_channel_count () const
virtual unsigned	get_channels () const =0
virtual audio_sample *	get_data ()=0
virtual const audio_sample *	get_data () const =0
size_t	get_data_length () const
virtual t_size	get_data_size () const =0
double	get_duration () const
audio_sample	get_peak (audio_sample p_peak) const
audio_sample	get_peak () const
virtual t_size	get_sample_count () const =0
unsigned	get_sample_rate () const
spec_t	get_spec () const
virtual unsigned	get_srate () const =0
size_t	get_used_size () const
void	grow_data_size (t_size p_requested)
void	insert_silence_fromstart (t_size samples)
bool	is_empty () const
bool	is_spec_valid () const
bool	is_valid () const
const audio_chunk &	operator= (const audio_chunk &p_source)
void	pad_with_silence (t_size samples)
void	pad_with_silence_ex (t_size samples, unsigned hint_nch, unsigned hint_srate)
bool	process_skip (double &skipDuration)
void	reset ()
void	scale (audio_sample p_value)
virtual void	set_channels (unsigned p_count, unsigned p_config)=0
void	set_channels (unsigned val)
void	set_data (const audio_sample *src, t_size samples, unsigned nch, unsigned srate, unsigned channel_config)
void	set_data (const audio_sample *src, t_size samples, unsigned nch, unsigned srate)
void	set_data_32 (const float *src, t_size samples, unsigned nch, unsigned srate)
void	set_data_fixedpoint (const void *ptr, t_size bytes, unsigned srate, unsigned nch, unsigned bps, unsigned channel_config)
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)
void	set_data_fixedpoint_ms (const void *ptr, size_t bytes, unsigned sampleRate, unsigned channels, unsigned bps, unsigned channelConfig)
void	set_data_fixedpoint_signed (const void *ptr, t_size bytes, unsigned srate, unsigned nch, unsigned bps, unsigned channel_config)
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)
void	set_data_int16 (const int16_t *src, t_size samples, unsigned nch, unsigned srate, unsigned channel_config)
virtual void	set_data_size (t_size p_new_size)=0
virtual void	set_sample_count (t_size val)=0
void	set_sample_rate (unsigned val)
void	set_silence (t_size samples)
void	set_silence_seconds (double seconds)
void	set_spec (const spec_t &)
virtual void	set_srate (unsigned val)=0
t_size	skip_first_samples (t_size samples)
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 Public Member Functions
static unsigned	flags_autoendian ()
static unsigned	g_channel_config_from_wfx (uint32_t p_wfx)
static uint32_t	g_channel_config_to_wfx (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_count_channels (unsigned p_config)
static unsigned	g_extract_channel_flag (unsigned p_config, unsigned p_index)
static unsigned	g_find_channel_idx (unsigned p_flag)
static void	g_formatChannelMaskDesc (unsigned flags, pfc::string_base &out)
static unsigned	g_guess_channel_config (unsigned count)
static unsigned	g_guess_channel_config_xiph (unsigned count)
static bool	g_is_valid_sample_rate (t_uint32 p_val)
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)
static spec_t	makeSpec (uint32_t rate, uint32_t channels)
static spec_t	makeSpec (uint32_t rate, uint32_t channels, uint32_t chanMask)

Protected Member Functions
	audio_chunk ()
	~audio_chunk ()

Detailed Description

Interface to container of a chunk of audio data. See audio_chunk_impl for an implementation.

Definition at line 5 of file audio_chunk.h.

Member Enumeration Documentation

anonymous enum

Enumerator
sample_rate_min
sample_rate_max

Definition at line 8 of file audio_chunk.h.

         {
        sample_rate_min = 1000, sample_rate_max = 2822400
    };

anonymous enum

Channel map flag declarations. Note that order of interleaved channel data in the stream is same as order of these flags.

Enumerator
channel_front_left
channel_front_right
channel_front_center
channel_lfe
channel_back_left
channel_back_right
channel_front_center_left
channel_front_center_right
channel_back_center
channel_side_left
channel_side_right
channel_top_center
channel_top_front_left
channel_top_front_center
channel_top_front_right
channel_top_back_left
channel_top_back_center
channel_top_back_right
channel_config_mono
channel_config_stereo
channel_config_5point1
channel_config_5point1_side
channel_config_7point1
defined_channel_count

Definition at line 14 of file audio_chunk.h.

    {
        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,
    };

anonymous enum

Enumerator
FLAG_LITTLE_ENDIAN
FLAG_BIG_ENDIAN
FLAG_SIGNED
FLAG_UNSIGNED

Definition at line 162 of file audio_chunk.h.

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

Constructor & Destructor Documentation

audio_chunk::audio_chunk ( )

inlineprotected

Definition at line 236 of file audio_chunk.h.

{}

audio_chunk::~audio_chunk ( )

inlineprotected

Definition at line 237 of file audio_chunk.h.

{}  

Member Function Documentation

void audio_chunk::allocate ( size_t  size )

inline

Sanity helper, same as set_data_size.

Definition at line 79 of file audio_chunk.h.

{ set_data_size( size ); }

void audio_chunk::copy ( const audio_chunk &  p_source )

inline

Helper; copies content of another audio chunk to this chunk.

Definition at line 212 of file audio_chunk.h.

                                            {
        set_data(p_source.get_data(),p_source.get_sample_count(),p_source.get_channels(),p_source.get_srate(),p_source.get_channel_config());
    }

static unsigned audio_chunk::flags_autoendian ( )

inlinestatic

Definition at line 170 of file audio_chunk.h.

                                              {
        return pfc::byte_order_is_big_endian ? FLAG_BIG_ENDIAN : FLAG_LITTLE_ENDIAN;
    }

unsigned audio_chunk::g_channel_config_from_wfx ( uint32_t  p_wfx )

static

Helper function; translates WAVEFORMATEXTENSIBLE channel map to audio_chunk channel map.

Definition at line 67 of file audio_chunk_channel_config.cpp.

{
    return p_wfx;
#if 0
    unsigned ret = 0;
    unsigned n;
    for(n=0;n<PFC_TABSIZE(g_translation_table);n++)
    {
        if (p_wfx & g_translation_table[n].m_wfx) ret |= g_translation_table[n].m_native;
    }
    return ret;
#endif
}

uint32_t audio_chunk::g_channel_config_to_wfx ( unsigned  p_config )

static

Helper function; translates audio_chunk channel map to WAVEFORMATEXTENSIBLE channel map.

Definition at line 53 of file audio_chunk_channel_config.cpp.

{
    return p_config;
#if 0
    DWORD ret = 0;
    unsigned n;
    for(n=0;n<PFC_TABSIZE(g_translation_table);n++)
    {
        if (p_config & g_translation_table[n].m_native) ret |= g_translation_table[n].m_wfx;
    }
    return ret;
#endif
}

unsigned audio_chunk::g_channel_index_from_flag ( unsigned  p_config, unsigned  p_flag  )

static

Calculates index of a channel specified by p_flag in a stream where channel map is described by p_config.

Definition at line 119 of file audio_chunk_channel_config.cpp.

                                                                                 {
    unsigned index = 0;
    for(unsigned walk = 0; walk < 32; walk++) {
        unsigned query = 1 << walk;
        if (p_flag & query) return index;
        if (p_config & query) index++;
    }
    return ~0;
}

const char * audio_chunk::g_channel_name ( unsigned  p_flag )

static

Definition at line 192 of file audio_chunk_channel_config.cpp.

                                                        {
    return g_channel_name_byidx(g_find_channel_idx(p_flag));
}

const char * audio_chunk::g_channel_name_byidx ( unsigned  p_index )

static

Definition at line 196 of file audio_chunk_channel_config.cpp.

                                                               {
    if (p_index < PFC_TABSIZE(chanNames)) return chanNames[p_index];
    else return "?";
}

unsigned audio_chunk::g_count_channels ( unsigned  p_config )

static

Counts channels specified by channel map.

Definition at line 145 of file audio_chunk_channel_config.cpp.

{
    return pfc::countBits32(p_config);
}

unsigned audio_chunk::g_extract_channel_flag ( unsigned  p_config, unsigned  p_index  )

static

Extracts flag describing Nth channel from specified map. Usable to figure what specific channel in a stream means.

Definition at line 129 of file audio_chunk_channel_config.cpp.

{
    unsigned toskip = p_index;
    unsigned flag = 1;
    while(flag)
    {
        if (p_config & flag)
        {
            if (toskip == 0) break;
            toskip--;
        }
        flag <<= 1;
    }
    return flag;
}

unsigned audio_chunk::g_find_channel_idx ( unsigned  p_flag )

static

Definition at line 171 of file audio_chunk_channel_config.cpp.

                                                        {
    unsigned rv = 0;
    if ((p_flag & 0xFFFF) == 0) {
        rv += 16; p_flag >>= 16;
    }
    if ((p_flag & 0xFF) == 0) {
        rv += 8; p_flag >>= 8;
    }
    if ((p_flag & 0xF) == 0) {
        rv += 4; p_flag >>= 4;
    }
    if ((p_flag & 0x3) == 0) {
        rv += 2; p_flag >>= 2;
    }
    if ((p_flag & 0x1) == 0) {
        rv += 1; p_flag >>= 1;
    }
    PFC_ASSERT( p_flag & 1 );
    return rv;
}

void audio_chunk::g_formatChannelMaskDesc ( unsigned  flags, pfc::string_base &  out  )

static

Definition at line 201 of file audio_chunk_channel_config.cpp.

                                                                              {
    out.reset();
    unsigned idx = 0;
    while(flags) {
        if (flags & 1) {
            if (!out.is_empty()) out << " ";
            out << g_channel_name_byidx(idx);
        }
        flags >>= 1;
        ++idx;
    }
}

unsigned audio_chunk::g_guess_channel_config ( unsigned  count )

static

Helper function; guesses default channel map for the specified channel count. Returns 0 on failure.

Definition at line 108 of file audio_chunk_channel_config.cpp.

{
    if (count >= PFC_TABSIZE(g_audio_channel_config_table)) return 0;
    return g_audio_channel_config_table[count];
}

unsigned audio_chunk::g_guess_channel_config_xiph ( unsigned  count )

static

Helper function; determines channel map for the specified channel count according to Xiph specs. Throws exception_io_data on failure.

Definition at line 114 of file audio_chunk_channel_config.cpp.

                                                                {
    if (count == 0 || count >= PFC_TABSIZE(g_audio_channel_config_table_xiph)) throw exception_io_data();
    return g_audio_channel_config_table_xiph[count];
}

static bool audio_chunk::g_is_valid_sample_rate ( t_uint32  p_val )

inlinestatic

Definition at line 11 of file audio_chunk.h.

{return p_val >= sample_rate_min && p_val <= sample_rate_max;}

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

static

Convert a buffer of audio_samples to fixed-point PCM format.

Parameters

useUpperBits

relevant if bps != bpsValid, signals whether upper or lower bits of each sample should be used.

Definition at line 517 of file audio_chunk.cpp.

                                                                                                                                                   {
    const sampleToIntDesc d = {bps, bpsValid, useUpperBits, scale};
    if (bps == 0) {
        PFC_ASSERT(!"How did we get here?");
        return false;
    } else if (bps <= 8) {
        render_8bit(in, count, out, d);
    } else if (bps <= 16) {
        render_16bit(in, count, out, d);
    } else if (bps <= 24) {
        render_24bit(in, count, out, d);
    } else if (bps <= 32) {
        if (bpsValid <= 28) { // for speed
            render_32bit_<int32_t>(in, count, out, d);
        } else {
            render_32bit_<int64_t>(in, count, out, d);
        }
    } else {
        PFC_ASSERT(!"How did we get here?");
        return false;
    }

    return true;
}

virtual unsigned audio_chunk::get_channel_config ( ) const

pure virtual

Retrieves channel map of contained audio data. Conditions where number of channels specified by channel map don't match get_channels() return value should not be possible.

Implemented in audio_chunk_memref_impl, and audio_chunk_impl_t< container_t >.

unsigned audio_chunk::get_channel_count ( ) const

inline

Helper - for consistency - same as get_channels().

Definition at line 88 of file audio_chunk.h.

{return get_channels();}

virtual unsigned audio_chunk::get_channels ( ) const

pure virtual

Retrieves channel count of contained audio data.

Implemented in audio_chunk_memref_impl, and audio_chunk_impl_t< container_t >.

virtual audio_sample* audio_chunk::get_data ( )

pure virtual

Retrieves audio data buffer pointer (non-const version). Returned pointer is for temporary use only; it is valid until next set_data_size call, or until the object is destroyed.
Size of returned buffer is equal to get_data_size() return value (in audio_samples). Amount of actual data may be smaller, depending on sample count and channel count. Conditions where sample count * channel count are greater than data size should not be possible.

Implemented in audio_chunk_memref_impl, and audio_chunk_impl_t< container_t >.

virtual const audio_sample* audio_chunk::get_data ( ) const

pure virtual

Retrieves audio data buffer pointer (const version). Returned pointer is for temporary use only; it is valid until next set_data_size call, or until the object is destroyed.
Size of returned buffer is equal to get_data_size() return value (in audio_samples). Amount of actual data may be smaller, depending on sample count and channel count. Conditions where sample count * channel count are greater than data size should not be possible.

Implemented in audio_chunk_memref_impl, and audio_chunk_impl_t< container_t >.

size_t audio_chunk::get_data_length ( ) const

inline

Same as get_used_size(); old confusingly named version.

Definition at line 136 of file audio_chunk.h.

{return get_sample_count() * get_channels();}

virtual t_size audio_chunk::get_data_size ( ) const

pure virtual

Retrieves size of allocated buffer space, in audio_samples.

Implemented in audio_chunk_memref_impl, and audio_chunk_impl_t< container_t >.

double audio_chunk::get_duration ( ) const

inline

Retrieves duration of contained audio data, in seconds.

Definition at line 116 of file audio_chunk.h.

    {
        double rv = 0;
        t_size srate = get_srate (), samples = get_sample_count();
        if (srate>0 && samples>0) rv = (double)samples/(double)srate;
        return rv;
    }

audio_sample audio_chunk::get_peak

(

audio_sample

p_peak

)

const

Helper, calculates peak value of data in the chunk. The optional parameter specifies initial peak value, to simplify calling code.

Definition at line 437 of file audio_chunk.cpp.

                                                            {
    return pfc::max_t(p_peak, get_peak());
}

audio_sample audio_chunk::get_peak

(

)

const

Definition at line 441 of file audio_chunk.cpp.

                                         {
    return audio_math::calculate_peak(get_data(),get_sample_count() * get_channels());
}

virtual t_size audio_chunk::get_sample_count ( ) const

pure virtual

Retrieves number of valid samples in the buffer.
Note that a "sample" means a unit of interleaved PCM data representing states of each channel at given point of time, not a single PCM value.
For an example, duration of contained audio data is equal to sample count / sample rate, while actual size of contained data is equal to sample count * channel count.

Implemented in audio_chunk_memref_impl, and audio_chunk_impl_t< container_t >.

unsigned audio_chunk::get_sample_rate ( ) const

inline

Helper, same as get_srate().

Definition at line 103 of file audio_chunk.h.

{return get_srate();}

audio_chunk::spec_t audio_chunk::get_spec

(

)

const

Definition at line 580 of file audio_chunk.cpp.

                                              {
    spec_t spec = {};
    spec.sampleRate = this->get_sample_rate();
    spec.chanCount = this->get_channel_count();
    spec.chanMask = this->get_channel_config();
    return spec;
}

virtual unsigned audio_chunk::get_srate ( ) const

pure virtual

Retrieves sample rate of contained audio data.

Implemented in audio_chunk_memref_impl, and audio_chunk_impl_t< container_t >.

size_t audio_chunk::get_used_size ( ) const

inline

Returns actual amount of audio data contained in the buffer (sample count * channel count). Must not be greater than data size (see get_data_size()).

Definition at line 134 of file audio_chunk.h.

{return get_sample_count() * get_channels();}

void audio_chunk::grow_data_size ( t_size  p_requested )

inline

Helper; resizes audio data buffer when its current size is smaller than requested.

Definition at line 112 of file audio_chunk.h.

{if (p_requested > get_data_size()) set_data_size(p_requested);}

void audio_chunk::insert_silence_fromstart

(

t_size

samples

)

Definition at line 388 of file audio_chunk.cpp.

                                                         {
    t_size old_size = get_sample_count() * get_channels();
    t_size delta = samples * get_channels();
    t_size new_size = old_size + delta;
    set_data_size(new_size);
    audio_sample * ptr = get_data();
    pfc::memmove_t(ptr+delta,ptr,old_size);
    pfc::memset_t(ptr,(audio_sample)0,delta);
    set_sample_count(get_sample_count() + samples);
}

bool audio_chunk::is_empty ( ) const

inline

Returns whether the chunk is empty (contains no audio data).

Definition at line 125 of file audio_chunk.h.

{return get_channels()==0 || get_srate()==0 || get_sample_count()==0;}

bool audio_chunk::is_spec_valid

(

)

const

Returns whether the chunk contains valid sample rate & channel info (but allows an empty chunk).

Definition at line 341 of file audio_chunk.cpp.

                                      {
    return this->get_spec().is_valid();
}

bool audio_chunk::is_valid

(

)

const

Returns whether the chunk contents are valid (for bug check purposes).

Definition at line 328 of file audio_chunk.cpp.

{
    unsigned nch = get_channels();
    if (nch==0 || nch>256) return false;
    if (!g_is_valid_sample_rate(get_srate())) return false;
    t_size samples = get_sample_count();
    if (samples==0 || samples >= 0x80000000 / (sizeof(audio_sample) * nch) ) return false;
    t_size size = get_data_size();
    if (samples * nch > size) return false;
    if (!get_data()) return false;
    return true;
}

audio_chunk::spec_t audio_chunk::makeSpec ( uint32_t  rate, uint32_t  channels  )

static

Definition at line 566 of file audio_chunk.cpp.

                                                                        {
    return makeSpec( rate, channels, g_guess_channel_config(channels) );
}

audio_chunk::spec_t audio_chunk::makeSpec ( uint32_t  rate, uint32_t  channels, uint32_t  chanMask  )

static

Definition at line 570 of file audio_chunk.cpp.

                                                                                       {
    spec_t spec = {};
    spec.sampleRate = rate; spec.chanCount = channels; spec.chanMask = mask;
    return spec;
}

const audio_chunk& audio_chunk::operator= ( const audio_chunk &  p_source )

inline

Definition at line 216 of file audio_chunk.h.

                                                                {
        copy(p_source);
        return *this;
    }

void audio_chunk::pad_with_silence

(

t_size

samples

)

Definition at line 366 of file audio_chunk.cpp.

                                                 {
    if (samples > get_sample_count())
    {
        t_size old_size = get_sample_count() * get_channels();
        t_size new_size = pfc::multiply_guarded(samples,(size_t)get_channels());
        set_data_size(new_size);
        pfc::memset_t(get_data() + old_size,(audio_sample)0,new_size - old_size);
        set_sample_count(samples);
    }
}

void audio_chunk::pad_with_silence_ex	(	t_size	samples,
		unsigned	hint_nch,
		unsigned	hint_srate
	)

Definition at line 345 of file audio_chunk.cpp.

                                                                                          {
    if (is_empty())
    {
        if (hint_srate && hint_nch) {
            return set_data(0,samples,hint_nch,hint_srate);
        } else throw exception_io_data();
    }
    else
    {
        if (hint_srate && hint_srate != get_srate()) samples = MulDiv_Size(samples,get_srate(),hint_srate);
        if (samples > get_sample_count())
        {
            t_size old_size = get_sample_count() * get_channels();
            t_size new_size = samples * get_channels();
            set_data_size(new_size);
            pfc::memset_t(get_data() + old_size,(audio_sample)0,new_size - old_size);
            set_sample_count(samples);
        }
    }
}

bool audio_chunk::process_skip

(

double &

skipDuration

)

Definition at line 399 of file audio_chunk.cpp.

                                                    {
    t_uint64 skipSamples = audio_math::time_to_samples(skipDuration, get_sample_rate());
    if (skipSamples == 0) {skipDuration = 0; return true;}
    const t_size mySamples = get_sample_count();
    if (skipSamples < mySamples) {
        skip_first_samples((t_size)skipSamples); 
        skipDuration = 0;
        return true;
    }
    if (skipSamples == mySamples) {
        skipDuration = 0;
        return false;
    }
    skipDuration -= audio_math::samples_to_time(mySamples, get_sample_rate());
    return false;
}

void audio_chunk::reset ( )

inline

Resets all audio_chunk data.

Definition at line 140 of file audio_chunk.h.

                        {
        set_sample_count(0);
        set_srate(0);
        set_channels(0);
        set_data_size(0);
    }

void audio_chunk::scale

(

audio_sample

p_value

)

Helper function; scales entire chunk content by specified value.

Definition at line 445 of file audio_chunk.cpp.

{
    audio_sample * ptr = get_data();
    audio_math::scale(ptr,get_sample_count() * get_channels(),ptr,p_value);
}

virtual void audio_chunk::set_channels ( unsigned  p_count, unsigned  p_config  )

pure virtual

Sets channel count / channel map.

Implemented in audio_chunk_memref_impl, and audio_chunk_impl_t< container_t >.

void audio_chunk::set_channels ( unsigned  val )

inline

Helper; sets channel count to specified value and uses default channel map for this channel count.

Definition at line 108 of file audio_chunk.h.

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

void audio_chunk::set_data	(	const audio_sample *	src,
		t_size	samples,
		unsigned	nch,
		unsigned	srate,
		unsigned	channel_config
	)

Helper, sets chunk data to contents of specified buffer, with specified number of channels / sample rate / channel map.

Definition at line 3 of file audio_chunk.cpp.

{
    t_size size = samples * nch;
    set_data_size(size);
    if (src)
        pfc::memcpy_t(get_data(),src,size);
    else
        pfc::memset_t(get_data(),(audio_sample)0,size);
    set_sample_count(samples);
    set_channels(nch,channel_config);
    set_srate(srate);
}

void audio_chunk::set_data ( const audio_sample *  src, t_size  samples, unsigned  nch, unsigned  srate  )

inline

Helper, sets chunk data to contents of specified buffer, with specified number of channels / sample rate, using default channel map for specified channel count.

Definition at line 151 of file audio_chunk.h.

{set_data(src,samples,nch,srate,g_guess_channel_config(nch));}

void audio_chunk::set_data_32 ( const float *  src, t_size  samples, unsigned  nch, unsigned  srate  )

inline

Definition at line 180 of file audio_chunk.h.

{return set_data(src,samples,nch,srate);}

void audio_chunk::set_data_fixedpoint ( const void *  ptr, t_size  bytes, unsigned  srate, unsigned  nch, unsigned  bps, unsigned  channel_config  )

inline

Helper, sets chunk data to contents of specified buffer, using default win32/wav conventions for signed/unsigned switch.

Definition at line 156 of file audio_chunk.h.

                                                                                                                                    {
        this->set_data_fixedpoint_ms(ptr, bytes, srate, nch, bps, channel_config);
    }

void audio_chunk::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
	)

Definition at line 123 of file audio_chunk.cpp.

{
    PFC_ASSERT( check_exclusive(flags,FLAG_SIGNED|FLAG_UNSIGNED) );
    PFC_ASSERT( check_exclusive(flags,FLAG_LITTLE_ENDIAN|FLAG_BIG_ENDIAN) );

    bool byteSwap = !!(flags & FLAG_BIG_ENDIAN);
    if (pfc::byte_order_is_big_endian) byteSwap = !byteSwap;

    t_size count = size / (bps/8);
    set_data_size(count);
    audio_sample * buffer = get_data();
    bool isSigned = !!(flags & FLAG_SIGNED);

    switch(bps)
    {
    case 8:
        // byte order irrelevant
        if (isSigned) _import8s( (const uint8_t*) source , buffer, count);
        else _import8u( (const uint8_t*) source , buffer, count);
        break;
    case 16:
        if (byteSwap) {
            if (isSigned) {
                _import16any<true, true>( source, buffer, count );
            } else {
                _import16any<true, false>( source, buffer, count );
            }
        } else {
            if (isSigned) {
                //_import16any<false, true>( source, buffer, count );
                audio_math::convert_from_int16((const int16_t*)source,count,buffer,1.0);
            } else {
                _import16any<false, false>( source, buffer, count);
            }
        }
        break;
    case 24:
        if (byteSwap) {
            if (isSigned) {
                _import24any<true, true>( source, buffer, count );
            } else {
                _import24any<true, false>( source, buffer, count );
            }
        } else {
            if (isSigned) {
                //_import24any<false, true>( source, buffer, count);
                _import24( source, buffer, count);
            } else {
                _import24any<false, false>( source, buffer, count);
            }
        }
        break;
    case 32:
        if (byteSwap) {
            if (isSigned) {
                _import32any<true, true>( source, buffer, count );
            } else {
                _import32any<true, false>( source, buffer, count );
            }
        } else {
            if (isSigned) {
                audio_math::convert_from_int32((const int32_t*)source,count,buffer,1.0);
            } else {
                _import32any<false, false>( source, buffer, count);
            }
        }
        break;
    default:
        //unknown size, cant convert
        pfc::memset_t(buffer,(audio_sample)0,count);
        break;
    }
    set_sample_count(count/nch);
    set_srate(srate);
    set_channels(nch,p_channel_config);
}

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

Definition at line 200 of file audio_chunk.cpp.

                                                                                                                                                     {
    //set_data_fixedpoint_ex(ptr,bytes,sampleRate,channels,bps,(bps==8 ? FLAG_UNSIGNED : FLAG_SIGNED) | flags_autoendian(), channelConfig);
    PFC_ASSERT( bps != 0 );
    size_t count = bytes / (bps/8);
    this->set_data_size( count );
    audio_sample * buffer = this->get_data();
    switch(bps) {
    case 8:
        _import8u((const uint8_t*)ptr, buffer, count);
        break;
    case 16:
        audio_math::convert_from_int16((const int16_t*) ptr, count, buffer, 1.0);
        break;
    case 24:
        _import24( ptr, buffer, count);
        break;
    case 32:
        audio_math::convert_from_int32((const int32_t*) ptr, count, buffer, 1.0);
        break;
    default:
        PFC_ASSERT(!"Unknown bit depth!");
        memset(buffer, 0, sizeof(audio_sample) * count);
        break;
    }
    set_sample_count(count/channels);
    set_srate(sampleRate);
    set_channels(channels,channelConfig);
}

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

Definition at line 229 of file audio_chunk.cpp.

                                                                                                                                                    {
    PFC_ASSERT( bps != 0 );
    size_t count = bytes / (bps/8);
    this->set_data_size( count );
    audio_sample * buffer = this->get_data();
    switch(bps) {
    case 8:
        _import8s((const uint8_t*)ptr, buffer, count);
        break;
    case 16:
        audio_math::convert_from_int16((const int16_t*) ptr, count, buffer, 1.0);
        break;
    case 24:
        _import24( ptr, buffer, count);
        break;
    case 32:
        audio_math::convert_from_int32((const int32_t*) ptr, count, buffer, 1.0);
        break;
    default:
        PFC_ASSERT(!"Unknown bit depth!");
        memset(buffer, 0, sizeof(audio_sample) * count);
        break;
    }
    set_sample_count(count/channels);
    set_srate(sampleRate);
    set_channels(channels,channelConfig);
}

void audio_chunk::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
	)

Definition at line 282 of file audio_chunk.cpp.

{
    PFC_ASSERT(bps==32 || bps==64 || bps == 16 || bps == 24);
    PFC_ASSERT( check_exclusive(flags,FLAG_LITTLE_ENDIAN|FLAG_BIG_ENDIAN) );
    PFC_ASSERT( ! (flags & (FLAG_SIGNED|FLAG_UNSIGNED) ) );

    bool use_swap = pfc::byte_order_is_big_endian ? !!(flags & FLAG_LITTLE_ENDIAN) : !!(flags & FLAG_BIG_ENDIAN);

    const t_size count = size / (bps/8);
    set_data_size(count);
    audio_sample * out = get_data();

    if (bps == 32)
    {
        if (use_swap)
            process_float_multi_swap(out,reinterpret_cast<const float*>(ptr),count);
        else
            process_float_multi(out,reinterpret_cast<const float*>(ptr),count);
    }
    else if (bps == 64)
    {
        if (use_swap)
            process_float_multi_swap(out,reinterpret_cast<const double*>(ptr),count);
        else
            process_float_multi(out,reinterpret_cast<const double*>(ptr),count);
    } else if (bps == 16) {
        const uint16_t * in = reinterpret_cast<const uint16_t*>(ptr);
        if (use_swap) {
            for(size_t walk = 0; walk < count; ++walk) out[walk] = audio_math::decodeFloat16(pfc::byteswap_t(in[walk]));
        } else {
            for(size_t walk = 0; walk < count; ++walk) out[walk] = audio_math::decodeFloat16(in[walk]);
        }
    } else if (bps == 24) {
        const uint8_t * in = reinterpret_cast<const uint8_t*>(ptr);
        if (use_swap) {
            for(size_t walk = 0; walk < count; ++walk) out[walk] = audio_math::decodeFloat24ptrbs(&in[walk*3]);
        } else {
            for(size_t walk = 0; walk < count; ++walk) out[walk] = audio_math::decodeFloat24ptr(&in[walk*3]);
        }
    } else pfc::throw_exception_with_message< exception_io_data >("invalid bit depth");

    set_sample_count(count/nch);
    set_srate(srate);
    set_channels(nch,p_channel_config);
}

void audio_chunk::set_data_int16	(	const int16_t *	src,
		t_size	samples,
		unsigned	nch,
		unsigned	srate,
		unsigned	channel_config
	)

Definition at line 257 of file audio_chunk.cpp.

                                                                                                                       {
    const size_t count = samples * nch;
    this->set_data_size( count );
    audio_sample * buffer = this->get_data();
    audio_math::convert_from_int16(src, count, buffer, 1.0);
    set_sample_count(samples);
    set_srate(srate);
    set_channels(nch,channel_config);
}

virtual void audio_chunk::set_data_size ( t_size  p_new_size )

pure virtual

Resizes audio data buffer to specified size. Throws std::bad_alloc on failure.

Implemented in audio_chunk_memref_impl, and audio_chunk_impl_t< container_t >.

virtual void audio_chunk::set_sample_count ( t_size  val )

pure virtual

Sets number of valid samples in the buffer. WARNING: sample count * channel count should never be above allocated buffer size.

Implemented in audio_chunk_memref_impl, and audio_chunk_impl_t< container_t >.

void audio_chunk::set_sample_rate ( unsigned  val )

inline

Helper, same as set_srate().

Definition at line 105 of file audio_chunk.h.

{set_srate(val);}

void audio_chunk::set_silence

(

t_size

samples

)

Definition at line 377 of file audio_chunk.cpp.

                                            {
    t_size items = samples * get_channels();
    set_data_size(items);
    pfc::memset_null_t(get_data(), items);
    set_sample_count(samples);
}

void audio_chunk::set_silence_seconds

(

double

seconds

)

Definition at line 384 of file audio_chunk.cpp.

                                                      {
    set_silence( (size_t) audio_math::time_to_samples( seconds, this->get_sample_rate() ) ); 
}

void audio_chunk::set_spec

(

const spec_t &

spec

)

Definition at line 587 of file audio_chunk.cpp.

                                              {
    set_sample_rate(spec.sampleRate);
    set_channels( spec.chanCount, spec.chanMask );
}

virtual void audio_chunk::set_srate ( unsigned  val )

pure virtual

Sets sample rate of contained audio data.

Implemented in audio_chunk_memref_impl, and audio_chunk_impl_t< container_t >.

t_size audio_chunk::skip_first_samples

(

t_size

samples

)

Definition at line 416 of file audio_chunk.cpp.

{
    t_size samples_old = get_sample_count();
    if (samples_delta >= samples_old)
    {
        set_sample_count(0);
        set_data_size(0);
        return samples_old;
    }
    else
    {
        t_size samples_new = samples_old - samples_delta;
        unsigned nch = get_channels();
        audio_sample * ptr = get_data();
        pfc::memmove_t(ptr,ptr+nch*samples_delta,nch*samples_new);
        set_sample_count(samples_new);
        set_data_size(nch*samples_new);
        return samples_delta;
    }
}

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

Simple function to get original PCM stream back. Assumes host's endianness, integers are signed - including the 8bit mode; 32bit mode assumed to be float.

Returns

false when the conversion could not be performed because of unsupported bit depth etc.

Definition at line 550 of file audio_chunk.cpp.

                                                                                                           {
    uint32_t bpsValid = bps;
    bps = (bps + 7) & ~7;
    const size_t count = get_sample_count() * get_channel_count();
    out.set_size( count * (bps/8) );
    void * outPtr = out.get_ptr();
    audio_sample const * inPtr = get_data();
    if (bps == 32) {
        float * f = (float*) outPtr;
        for(size_t w = 0; w < count; ++w) f[w] = inPtr[w] * scale;
        return true;
    } else {
        return g_toFixedPoint(inPtr, outPtr, count, bps, bpsValid, useUpperBits, scale);
    }
}

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

Convert audio_chunk contents to fixed-point PCM format.

Parameters

useUpperBits

relevant if bps != bpsValid, signals whether upper or lower bits of each sample should be used.

Definition at line 542 of file audio_chunk.cpp.

                                                                                                                                     {
    bps = (bps + 7) & ~7;
    if (bps < bpsValid) return false;
    const size_t count = get_sample_count() * get_channel_count();
    out.set_size( count * (bps/8) );
    return g_toFixedPoint(get_data(), out.get_ptr(), count, bps, bpsValid, useUpperBits, scale);
}

---

The documentation for this class was generated from the following files:

• foobar2000/SDK/audio_chunk.h
• foobar2000/SDK/audio_chunk.cpp
• foobar2000/SDK/audio_chunk_channel_config.cpp

---

Generated by   1.8.11