audio_membuffer Class Reference

#include <audio_membuffer.hpp>

Inheritance diagram for audio_membuffer:

Collaboration diagram for audio_membuffer:

Public Member Functions
	audio_membuffer (void)
	audio_membuffer (audio_format aud_fmt)
	audio_membuffer (audio_format aud_fmt, unsigned int seconds)
	audio_membuffer (audio_format aud_fmt, float seconds)
	audio_membuffer (unsigned int bytes)
virtual	~audio_membuffer (void)
unsigned int	mem_size (void) const
unsigned int	bytes_recorded (void) const
unsigned int	seconds_total (void) const
unsigned int	seconds_recorded (void) const
float	fseconds_total (void) const
float	fseconds_recorded (void) const
unsigned int	total_samples (void) const
unsigned int	samples_received (void) const
BYTE *	audio_buffer (void) const
void	clear (void)
audio_format &	audinfo (void)
void	reset (void)
void	truncate (void)
void	alloc_bytes (unsigned int)
void	alloc_seconds (unsigned int)
void	alloc_seconds (float)
void	resize_bytes (unsigned int)
void	resize_seconds (unsigned int)
void	resize_seconds (float)
void	audio_receive (unsigned char *, unsigned int)
unsigned int	read (BYTE *, unsigned int)
bool	finished (void)
Public Member Functions inherited from audio_receiver
	audio_receiver (void)
virtual	~audio_receiver (void)
virtual void	audio_receive (unsigned char *, unsigned int)=0
void	set_b_received (unsigned int r)
Public Member Functions inherited from audio_producer
	audio_producer ()
virtual	~audio_producer (void)
virtual unsigned int	read (BYTE *, unsigned int)=0
virtual bool	finished (void)=0
unsigned int	bytes_played (void) const
void	set_position (unsigned int pos)
void	set_position_start (void)
void	forward (unsigned int bytes)
void	backward (unsigned int bytes)

Public Attributes
void(*	audio_arrival )(unsigned int)
void(*	buffer_resized )(unsigned int)
Public Attributes inherited from audio_producer
void(*	play_finished )(void)

Protected Member Functions
void	alloc_mem_ (unsigned int)
void	free_mem_ (void)
void	resize_mem_ (unsigned int)
void	truncate_ (void)

Protected Attributes
BYTE *	audio_data
audio_format	aud_info
unsigned int	buf_size
unsigned int	init_size
Protected Attributes inherited from audio_receiver
unsigned int	bytes_received
Protected Attributes inherited from audio_producer
unsigned int	bytes_played_

Detailed Description

Definition at line 17 of file audio_membuffer.hpp.

Constructor & Destructor Documentation

audio_membuffer() [1/5]

audio_membuffer::audio_membuffer ( void  )

inline

Definition at line 41 of file audio_membuffer.hpp.

                              : audio_data(0),
                                aud_info(_AUDIO_DEFAULT_FORMAT),
                                buf_size(0),
                                init_size(0)
        {
            /* Allocs memory for at least 1 or some seconds of recording */
            init_size = (unsigned int)((float)aud_info.byte_rate() * _AUDIO_DEFAULT_BUFSECS);
            alloc_mem_(init_size);
        }

audio_membuffer() [2/5]

audio_membuffer::audio_membuffer ( audio_format  aud_fmt )

inline

Definition at line 51 of file audio_membuffer.hpp.

                                              : audio_data(0),
                                                aud_info(aud_fmt),
                                                buf_size(0),
                                                init_size(0)
        {
            /* Allocs memory for at least 1 or some seconds of recording */
            init_size = (unsigned int)((float)aud_info.byte_rate() * _AUDIO_DEFAULT_BUFSECS);
            alloc_mem_(init_size);
        }

audio_membuffer() [3/5]

audio_membuffer::audio_membuffer ( audio_format  aud_fmt, unsigned int  seconds  )

inline

Definition at line 61 of file audio_membuffer.hpp.

                                                                    : audio_data(0),
                                                                      aud_info(aud_fmt),
                                                                      buf_size(0),
                                                                      init_size(0)
        {
            /* Allocs memory for audio recording the specified number of seconds */
            init_size = aud_info.byte_rate() * seconds;
            alloc_mem_(init_size);
        }

audio_membuffer() [4/5]

audio_membuffer::audio_membuffer ( audio_format  aud_fmt, float  seconds  )

inline

Definition at line 71 of file audio_membuffer.hpp.

                                                             : audio_data(0),
                                                               aud_info(aud_fmt),
                                                               buf_size(0),
                                                               init_size(0)
        {
            /* Allocs memory for audio recording the specified number of seconds */
            init_size = (unsigned int)((float)aud_info.byte_rate() * seconds <= 0 ? 1 : seconds);
            alloc_mem_(init_size);
        }

audio_membuffer() [5/5]

audio_membuffer::audio_membuffer ( unsigned int  bytes )

inline

Definition at line 81 of file audio_membuffer.hpp.

                                            : audio_data(0),
                                              aud_info(_AUDIO_DEFAULT_FORMAT),
                                              buf_size(0),
                                              init_size(0)
        {
            /* Allocs memory for the specified bytes */
            init_size = bytes;
            alloc_mem_(init_size);
        }

~audio_membuffer()

virtual audio_membuffer::~audio_membuffer ( void  )

inlinevirtual

Definition at line 92 of file audio_membuffer.hpp.

        {
            /* Frees memory and reset values */
            clear();
        }

Member Function Documentation

alloc_bytes()

void audio_membuffer::alloc_bytes

(

unsigned int

bytes

)

Definition at line 126 of file audio_membuffer.cpp.

{
    alloc_mem_(bytes);
}

alloc_mem_()

_AUDIO_NAMESPACE_START_ void audio_membuffer::alloc_mem_ ( unsigned int  bytes )

protected

Definition at line 16 of file audio_membuffer.cpp.

{
    /* Some checking */
    if (bytes == 0)
        return;
 
    /* Checks previously alloc'd memory and frees it */
    if (audio_data)
        delete[] audio_data;
 
    /* Allocs new memory and zeros it */
    audio_data = new BYTE[bytes];
    memset(audio_data, 0, bytes * sizeof(BYTE));
 
    /* Sets the correct buffer size */
    buf_size = bytes;
    init_size = bytes;
}

Referenced by alloc_bytes(), alloc_seconds(), audio_membuffer(), audio_receive(), and reset().

alloc_seconds() [1/2]

void audio_membuffer::alloc_seconds

(

float

secs

)

Definition at line 138 of file audio_membuffer.cpp.

{
    alloc_mem_((unsigned int)((float)aud_info.byte_rate() * secs));
}

alloc_seconds() [2/2]

void audio_membuffer::alloc_seconds

(

unsigned int

secs

)

Definition at line 132 of file audio_membuffer.cpp.

{
    alloc_mem_(aud_info.byte_rate() * secs);
}

audinfo()

audio_format & audio_membuffer::audinfo ( void  )

inline

Definition at line 155 of file audio_membuffer.hpp.

        {
            return aud_info;
        }

audio_buffer()

BYTE * audio_membuffer::audio_buffer ( void  ) const

inline

Definition at line 147 of file audio_membuffer.hpp.

        {
            return audio_data;
        }

audio_receive()

void audio_membuffer::audio_receive ( unsigned char *  data, unsigned int  size  )

virtual

Implements audio_receiver.

Definition at line 164 of file audio_membuffer.cpp.

{
    /* If there isn't a buffer, allocs memory for it of size*2, and copies audio data arrival */
    if ((audio_data == 0) || (buf_size == 0))
    {
        alloc_mem_(size * 2);
        memcpy(audio_data, data, size);
        return;
    }
 
    /* If buffer's free memory is < of `size', we have to realloc buffer memory
       of buf_size*2, while free memory is enough to contain `size' bytes.
       In this case free memory is represented by `buf_size - bytes_recorded' */
    unsigned int tot_mem = buf_size, free_mem = buf_size - bytes_received;
    if (free_mem < size)
    {
        /* Calcs new buffer size */
        /* TODO: flags for other behaviour? */
        while (free_mem < size)
        {
            tot_mem *= 2;
            free_mem = tot_mem - bytes_received;
        }
 
        /* Resize buffer memory */
        resize_mem_(tot_mem);
    }
 
    /* Now we have enough free space in the buffer, so let's copy audio data arrivals */
    memcpy(audio_data + bytes_received, data, size);
 
    if (audio_arrival)
        audio_arrival(aud_info.samples_in_bytes(size));
}

bytes_recorded()

unsigned int audio_membuffer::bytes_recorded ( void  ) const

inline

Definition at line 107 of file audio_membuffer.hpp.

        {
            return bytes_received;
        }

clear()

void audio_membuffer::clear

(

void

)

Definition at line 110 of file audio_membuffer.cpp.

{
    free_mem_();
    bytes_received = 0;
}

Referenced by reset(), and ~audio_membuffer().

finished()

bool audio_membuffer::finished ( void  )

virtual

Implements audio_producer.

Definition at line 228 of file audio_membuffer.cpp.

{
    if (bytes_played_ < bytes_received)
        return false;
    else
        return true;
}

free_mem_()

void audio_membuffer::free_mem_ ( void  )

protected

Definition at line 36 of file audio_membuffer.cpp.

{
    if (audio_data)
        delete[] audio_data;
 
    buf_size = 0;
    audio_data = 0;
}

Referenced by clear().

fseconds_recorded()

float audio_membuffer::fseconds_recorded ( void  ) const

inline

Definition at line 131 of file audio_membuffer.hpp.

        {
            return (float)((float)bytes_received / (float)aud_info.byte_rate());
        }

fseconds_total()

float audio_membuffer::fseconds_total ( void  ) const

inline

Definition at line 125 of file audio_membuffer.hpp.

        {
            return (float)((float) buf_size / (float)aud_info.byte_rate());
        }

Referenced by total_samples().

mem_size()

unsigned int audio_membuffer::mem_size ( void  ) const

inline

Definition at line 101 of file audio_membuffer.hpp.

        {
            return buf_size;
        }

read()

unsigned int audio_membuffer::read ( BYTE *  out_buf, unsigned int  bytes  )

virtual

Implements audio_producer.

Definition at line 200 of file audio_membuffer.cpp.

{
    /* Some checking */
    if (!audio_data)
        return 0;
 
    if (bytes_played_ >= bytes_received)
        return 0;
 
    unsigned int to_play = bytes_received - bytes_played_;
    unsigned int to_copy = bytes > to_play ? to_play : bytes;
 
    /* Copies the audio data out */
    if ((out_buf) && (to_copy) && (audio_data))
        memcpy(out_buf, audio_data + bytes_played_, to_copy);
 
    /* Increments the number of total bytes played (audio data gone out from
       the `audio_producer' object) */
    bytes_played_ += to_copy;
 
    if (audio_arrival)
        audio_arrival(aud_info.samples_in_bytes(to_copy));
 
    /* Returns the exact size of audio data produced */
    return to_copy;
}

reset()

void audio_membuffer::reset

(

void

)

Definition at line 117 of file audio_membuffer.cpp.

{
    /* Frees memory and reset to initial state */
    clear();
    /* Alloc memory of size specified at the constructor */
    alloc_mem_(init_size);
}

resize_bytes()

void audio_membuffer::resize_bytes

(

unsigned int

bytes

)

Definition at line 144 of file audio_membuffer.cpp.

{
    resize_mem_(bytes);
}

resize_mem_()

void audio_membuffer::resize_mem_ ( unsigned int  new_size )

protected

Definition at line 46 of file audio_membuffer.cpp.

{
    if (new_size == 0)
        return;
 
    /* The new_size, cannot be <= of the `bytes_received' member value of the
       parent class `audio_receiver'. We cannot touch received audio data,
       so we have to alloc at least bytes_received+1 bytes. But we can truncate
       unused memory, so `new_size' can be < of `buf_size' */
    if (new_size <= bytes_received)
        return;
 
    BYTE * new_mem;
 
    /* Allocs new memory and zeros it */
    new_mem = new BYTE[new_size];
    memset(new_mem, 0, new_size * sizeof(BYTE));
 
    if (audio_data)
    {
        /* Copies received audio data, and discard unused memory */
        memcpy(new_mem, audio_data, bytes_received);
        /* Frees old memory */
        delete[] audio_data;
        /* Commit new memory */
        audio_data = new_mem;
        buf_size = new_size;
    } else {
        audio_data = new_mem;
        buf_size = new_size;
    }
 
    if (buffer_resized)
        buffer_resized(new_size);
}

Referenced by audio_receive(), resize_bytes(), and resize_seconds().

resize_seconds() [1/2]

void audio_membuffer::resize_seconds

(

float

secs

)

Definition at line 156 of file audio_membuffer.cpp.

{
    resize_mem_((unsigned int)((float)aud_info.byte_rate() * secs));
}

resize_seconds() [2/2]

void audio_membuffer::resize_seconds

(

unsigned int

secs

)

Definition at line 150 of file audio_membuffer.cpp.

{
    resize_mem_(aud_info.byte_rate() * secs);
}

samples_received()

unsigned int audio_membuffer::samples_received ( void  ) const

inline

Definition at line 141 of file audio_membuffer.hpp.

        {
            return (aud_info.samples_in_bytes(bytes_received));
        }

seconds_recorded()

unsigned int audio_membuffer::seconds_recorded ( void  ) const

inline

Definition at line 119 of file audio_membuffer.hpp.

        {
            return bytes_received / aud_info.byte_rate();
        }

seconds_total()

unsigned int audio_membuffer::seconds_total ( void  ) const

inline

Definition at line 113 of file audio_membuffer.hpp.

        {
            return buf_size / aud_info.byte_rate();
        }

total_samples()

unsigned int audio_membuffer::total_samples ( void  ) const

inline

Definition at line 136 of file audio_membuffer.hpp.

        {
            return (aud_info.samples_in_seconds(fseconds_total()));
        }

truncate()

void audio_membuffer::truncate ( void  )

inline

Definition at line 166 of file audio_membuffer.hpp.

        {
            truncate_();
        } /* TODO: fare truncate N bytes */

truncate_()

void audio_membuffer::truncate_ ( void  )

protected

Definition at line 83 of file audio_membuffer.cpp.

{
    /* If `buf_size' is already = to the `bytes_received' of audio data,
       then this operation is useless; simply return */
    if (bytes_received == buf_size)
        return;
 
    if (audio_data)
    {
        /* Allocs a new buffer */
        BYTE * newbuf = new BYTE[bytes_received];
        /* Copies audio data */
        memcpy(newbuf, audio_data, bytes_received);
        /* Frees old memory */
        delete[] audio_data;
        /* Commit the new buffer */
        audio_data = newbuf;
        buf_size = bytes_received;
 
        /* Buffer truncation successful. Now the buffer size is exactly big
           as much audio data was received */
    }
}

Referenced by truncate().

Member Data Documentation

aud_info

audio_format audio_membuffer::aud_info

protected

Definition at line 21 of file audio_membuffer.hpp.

Referenced by alloc_seconds(), audinfo(), audio_membuffer(), audio_receive(), fseconds_recorded(), fseconds_total(), read(), resize_seconds(), samples_received(), seconds_recorded(), seconds_total(), and total_samples().

audio_arrival

void(* audio_membuffer::audio_arrival) (unsigned int)

Definition at line 37 of file audio_membuffer.hpp.

Referenced by audio_receive(), and read().

audio_data

BYTE* audio_membuffer::audio_data

protected

Definition at line 20 of file audio_membuffer.hpp.

Referenced by alloc_mem_(), audio_buffer(), audio_receive(), free_mem_(), read(), resize_mem_(), and truncate_().

buf_size

unsigned int audio_membuffer::buf_size

protected

Definition at line 22 of file audio_membuffer.hpp.

Referenced by alloc_mem_(), audio_receive(), free_mem_(), fseconds_total(), mem_size(), resize_mem_(), seconds_total(), and truncate_().

buffer_resized

void(* audio_membuffer::buffer_resized) (unsigned int)

Definition at line 38 of file audio_membuffer.hpp.

Referenced by resize_mem_().

init_size

unsigned int audio_membuffer::init_size

protected

Definition at line 23 of file audio_membuffer.hpp.

Referenced by alloc_mem_(), audio_membuffer(), and reset().

---

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

• base/applications/sndrec32/audio_membuffer.hpp
• base/applications/sndrec32/audio_membuffer.cpp