Nsound::Mixer Class Reference

This class enables easy scheduling and mixing of multiple AudioStreams. More...

#include <Nsound/Mixer.h>

Public Member Functions
	Mixer ()
	Constructor. More...
	~Mixer ()
	Destuctor. More...
void	add (float64 first_beat_time, float64 beats_per_minute, const AudioStream &audio_stream)
	This method inserts the AudioStream to the Mixer's LinkList. More...
AudioStream	getStream (float64 end_time)
	This method returns one AudioStream composed of all AudioStreams stored in the Mixer's LinkList. More...
AudioStream	getStream (float64 start_time, float64 end_time)
void	clear ()
	This method removes all streams from the mixer. More...
uint32	size () const
	This method returns the number of stream stored in it. More...

Private Attributes
Nsound::uint32	max_channels_
	Stores the maximum number of channels. More...
Nsound::MixerSet	mixer_set_
	This stores all the MixerNodes. More...

Detailed Description

This class enables easy scheduling and mixing of multiple AudioStreams.

This class can que up AudioStreams using beats per minute and first beat time.

Definition at line 63 of file Mixer.h.

Constructor & Destructor Documentation

Mixer::Mixer

(

)

Constructor.

Constructor

Definition at line 47 of file Mixer.cc.

    : max_channels_(0),
      mixer_set_()
{}

Mixer::~Mixer

(

)

Destuctor.

Destuctor

Definition at line 54 of file Mixer.cc.

{}

Member Function Documentation

void Mixer::add	(	float64	first_beat_time,
		float64	beats_per_minute,
		const AudioStream &	audio_stream
	)

This method inserts the AudioStream to the Mixer's LinkList.

This method inserts the AudioStream into the Mixer's LinkList.

Parameters

first_beat_time	- The time this AudioStream starts playing in the Mixer, must be >= zero.
beats_per_minute	- The number of times this AudioStream will play per minute. If this is <= zero, the AudioStream will play only once.
audio_stream	- The AudioStream object to be stored.

Definition at line 59 of file Mixer.cc.

References Nsound::AudioStream::getNChannels(), M_ASSERT_VALUE, max_channels_, and mixer_set_.

Referenced by main().

{
    M_ASSERT_VALUE(first_beat_time, >=, 0.0);

    if(beats_per_minute < 0.0)
    {
        beats_per_minute = 0.0;
    }

    MixerNode new_node = MixerNode(
        first_beat_time, beats_per_minute, audio_stream);

    mixer_set_.insert(new_node);

    if(audio_stream.getNChannels() > max_channels_)
    {
        max_channels_ = audio_stream.getNChannels();
    }
}

AudioStream Mixer::getStream

(

float64

end_time

)

This method returns one AudioStream composed of all AudioStreams stored in the Mixer's LinkList.

This method returns one AudioStream composed of all AudioStreams stored in the Mixer's LinkList.

Definition at line 91 of file Mixer.cc.

Referenced by main().

{
    return getStream(0,end_time);
}

AudioStream Mixer::getStream	(	float64	start_time,
		float64	end_time
	)

Definition at line 123 of file Mixer.cc.

References Nsound::AudioStream::add(), Nsound::AudioStream::getLength(), M_ASSERT_VALUE, max_channels_, mixer_set_, Nsound::start_time, and Nsound::AudioStream::substream().

{
    M_ASSERT_VALUE(mixer_set_.size(), >, 0);
    M_ASSERT_VALUE(start_time, <, end_time);

    if(mixer_set_.size() == 0) return AudioStream(1,1);
    if(start_time >= end_time) return AudioStream(1,1);

    MixerSet::const_iterator node = mixer_set_.begin();

    // Grab the sample rate
    float64 sample_rate = node->audio_stream_->getSampleRate();

    // Create the new stream to return.  By default it is 2 channels and
    // has the same sample_rate as the first AudioStream.

    AudioStream new_stream(sample_rate, max_channels_);

    // Fill the stream with zeros.
    uint32 n_samples = static_cast<uint32>(
        sample_rate * (end_time - start_time));

    for(uint32 i = 0; i < n_samples; ++i)
    {
        new_stream << 0.0;
    }

    // Loop through the list of MixerNodes.  On each node, loop from start
    // time to end time and add the node's AudioStream data to new_stream.

    while(node != mixer_set_.end())
    {
        // Beats per minute is a frequency, but we want to calculate the
        // the time between beats.  Remember that f = 1/t, so to get time
        // we invert the equation, t = 1/f.  Here, we also need to multiply
        // by 60 to get beats per second.
        //
        // Therefore, t = 60/f

        float64 beat_time = 60.0 / node->bpm_;

        float64 beat_length =
            static_cast<float64>(node->audio_stream_->getLength())
            / static_cast<float64>(sample_rate);

        // We also need to keep track of the next_beat_time and end_time.
        float64 next_beat_time = node->first_beat_time_;
        float64 next_end_time = next_beat_time + beat_length;

        // initialize some indexes
        uint32 new_stream_offset_index = 0;
        uint32 node_max_index = node->audio_stream_->getLength();

        float64 mixer_time = start_time;

        // Go to the first beat that ends after current time.
        while(next_end_time < mixer_time)
        {
            next_beat_time += beat_time;
            next_end_time = next_beat_time + beat_length;
        }

        float64 new_stream_time = next_beat_time - start_time;
        float64 new_stream_end_time = end_time - start_time;

        // Case 1:  Start time is before next beat.
        //  ....[________].....[________].....[________]..
        //    ^
        //    start

        if(mixer_time < next_beat_time)
        {
            mixer_time = next_beat_time;
        }

        // Case 2:  Start time is inside next beat.
        //  ....[________].....[________].....[________]..
        //          ^
        //          start

        else if(next_beat_time < mixer_time)
        {
            // Add the remaing AudioStream to the output.

            uint32 node_index = static_cast<uint32>((next_end_time - mixer_time) * sample_rate);

            new_stream_offset_index = static_cast<uint32>(
                (mixer_time - start_time) * sample_rate);

            AudioStream temp = node->audio_stream_->substream(node_index);

            new_stream.add(temp, new_stream_offset_index);

            next_beat_time += beat_time;
            next_end_time = next_beat_time + beat_length;
            mixer_time = next_beat_time;
            new_stream_time = next_beat_time - start_time;
        }

        while(new_stream_time < new_stream_end_time)
        {
            new_stream_offset_index = static_cast<uint32>
                (new_stream_time * sample_rate);

            // add into new_stream
            uint32 add_n_samples = node_max_index;

            if(next_end_time > end_time)
            {
                add_n_samples -= static_cast<uint32>((next_end_time - end_time)
                    * static_cast<float64>(sample_rate));
            }

            new_stream.add(
                *node->audio_stream_,
                new_stream_offset_index,
                add_n_samples);

            next_beat_time += beat_time;
            next_end_time = next_beat_time + beat_length;
            mixer_time = next_beat_time;
            new_stream_time += beat_time;
        }

        // Move to the next MixerNode in the list.
        ++node;

    } // while(node != NULL)

    return new_stream;
}

void Mixer::clear

(

)

This method removes all streams from the mixer.

Definition at line 84 of file Mixer.cc.

References mixer_set_.

Referenced by main().

{
   mixer_set_.erase(mixer_set_.begin(), mixer_set_.end());
}

uint32 Nsound::Mixer::size ( ) const

inline

This method returns the number of stream stored in it.

Definition at line 124 of file Mixer.h.

References mixer_set_.

Referenced by main().

{ return static_cast<uint32>(mixer_set_.size()); };

Member Data Documentation

Nsound::uint32 Nsound::Mixer::max_channels_

private

Stores the maximum number of channels.

Definition at line 124 of file Mixer.h.

Referenced by add(), and getStream().

Nsound::MixerSet Nsound::Mixer::mixer_set_

private

This stores all the MixerNodes.

Definition at line 131 of file Mixer.h.

Referenced by add(), clear(), getStream(), and size().

---

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

• Nsound/Mixer.h
• Nsound/Mixer.cc