process_context.h

Go to the documentation of this file.

#ifndef AUDIOGRAPHER_PROCESS_CONTEXT_H
#define AUDIOGRAPHER_PROCESS_CONTEXT_H
 
#include <boost/static_assert.hpp>
#include <boost/format.hpp>
 
#include "audiographer/visibility.h"
#include "exception.h"
#include "debug_utils.h"
#include "types.h"
#include "flag_field.h"
#include "throwing.h"
#include "type_utils.h"
 
namespace AudioGrapher
{
 
 
template <typename T = DefaultSampleType>
class /*LIBAUDIOGRAPHER_API*/ ProcessContext
  : public Throwing<>
{
        // Support older compilers that don't support template base class initialization without template parameters
        // This will need to be modified if if it's modified above
        static const ThrowLevel throwLevel = DEFAULT_THROW_LEVEL;
 
        BOOST_STATIC_ASSERT (boost::has_trivial_destructor<T>::value);
 
public:
 
        typedef FlagField::Flag Flag;
 
        enum Flags {
                EndOfInput = 0
        };
 
public:
 
        ProcessContext (T * data, samplecnt_t samples, ChannelCount channels)
                : _data (data), _samples (samples), _channels (channels)
        { validate_data(); }
 
        ProcessContext (ProcessContext<T> const & other)
                : Throwing<throwLevel>(), _data (other._data), _samples (other._samples), _channels (other._channels), _flags (other._flags)
        { /* No need to validate data */ }
 
        template<typename Y>
        ProcessContext (ProcessContext<Y> const & other, T * data, samplecnt_t samples, ChannelCount channels)
                : Throwing<throwLevel>(), _data (data), _samples (samples), _channels (channels), _flags (other.flags())
        { validate_data(); }
 
        template<typename Y>
        ProcessContext (ProcessContext<Y> const & other, T * data, samplecnt_t samples)
                : Throwing<throwLevel>(), _data (data), _samples (samples), _channels (other.channels()), _flags (other.flags())
        { validate_data(); }
 
        template<typename Y>
        ProcessContext (ProcessContext<Y> const & other, T * data)
                : Throwing<throwLevel>(), _data (data), _samples (other.samples()), _channels (other.channels()), _flags (other.flags())
        { /* No need to validate data */ }
 
        ProcessContext beginning (samplecnt_t samples)
        {
                if (throw_level (ThrowProcess) && samples > _samples) {
                        throw Exception (*this, boost::str (boost::format
                                ("Trying to use too many samples of %1% for a new Context: %2% instead of %3%")
                                % DebugUtils::demangled_name (*this) % samples % _samples));
                }
                validate_data ();
 
                return ProcessContext (*this, _data, samples);
        }
 
        virtual ~ProcessContext () {}
 
        inline T const *            data()     const { return _data; }
        inline T *                  data()           { return _data; }
 
        inline samplecnt_t const &    samples()   const { return _samples; }
 
        inline ChannelCount const & channels() const { return _channels; }
 
        inline samplecnt_t            samples_per_channel() const { return _samples / _channels; }
 
        /* Flags */
 
        inline bool has_flag (Flag flag)    const { return _flags.has (flag); }
        inline void set_flag (Flag flag)    const { _flags.set (flag); }
        inline void remove_flag (Flag flag) const { _flags.remove (flag); }
        inline FlagField const & flags ()   const { return _flags; }
 
protected:
        T * const              _data;
        samplecnt_t              _samples;
        ChannelCount           _channels;
 
        mutable FlagField      _flags;
 
  private:
        inline void validate_data()
        {
                if (throw_level (ThrowProcess) && (_samples % _channels != 0)) {
                        throw Exception (*this, boost::str (boost::format
                                ("Number of samples given to %1% was not a multiple of channels: %2% samples with %3% channels")
                                % DebugUtils::demangled_name (*this) % _samples % _channels));
                }
        }
};
 
template <typename T = DefaultSampleType>
class /*LIBAUDIOGRAPHER_API*/ AllocatingProcessContext : public ProcessContext<T>
{
public:
        AllocatingProcessContext (samplecnt_t samples, ChannelCount channels)
                : ProcessContext<T> (new T[samples], samples, channels) {}
 
        AllocatingProcessContext (T const * data, samplecnt_t samples, ChannelCount channels)
                : ProcessContext<T> (new T[samples], samples, channels)
        { TypeUtils<float>::copy (data, ProcessContext<T>::_data, samples); }
 
        AllocatingProcessContext (ProcessContext<T> const & other)
                : ProcessContext<T> (other, new T[other._samples])
        { TypeUtils<float>::copy (ProcessContext<T>::_data, other._data, other._samples); }
 
        template<typename Y>
        AllocatingProcessContext (ProcessContext<Y> const & other, samplecnt_t samples, ChannelCount channels)
                : ProcessContext<T> (other, new T[samples], samples, channels) {}
 
        template<typename Y>
        AllocatingProcessContext (ProcessContext<Y> const & other, samplecnt_t samples)
                : ProcessContext<T> (other, new T[samples], samples, other.channels()) {}
 
        template<typename Y>
        AllocatingProcessContext (ProcessContext<Y> const & other)
                : ProcessContext<T> (other, new T[other._samples]) {}
 
        ~AllocatingProcessContext () { delete [] ProcessContext<T>::_data; }
};
 
template <typename T = DefaultSampleType>
class /*LIBAUDIOGRAPHER_API*/ ConstProcessContext
{
  public:
        ConstProcessContext (T const * data, samplecnt_t samples, ChannelCount channels)
          : context (const_cast<T *>(data), samples, channels) {}
 
        ConstProcessContext (ProcessContext<T> const & other)
          : context (const_cast<ProcessContext<T> &> (other)) {}
 
        template<typename ProcessContext>
        ConstProcessContext (ProcessContext const & other, T const * data, samplecnt_t samples, ChannelCount channels)
                : context (other, const_cast<T *>(data), samples, channels) {}
 
        template<typename ProcessContext>
        ConstProcessContext (ProcessContext const & other, T const * data, samplecnt_t samples)
                : context (other, const_cast<T *>(data), samples) {}
 
        template<typename ProcessContext>
        ConstProcessContext (ProcessContext const & other, T const * data)
                : context (other, const_cast<T *>(data)) {}
 
        inline operator ProcessContext<T> const & () { return context; }
        inline ProcessContext<T> const & operator() () { return context; }
        inline ProcessContext<T> const * operator& () { return &context; }
 
  private:
          ProcessContext<T> const context;
};
 
} // namespace
 
#endif // AUDIOGRAPHER_PROCESS_CONTEXT_H