/home/raskolnikov/dev/psynth/trunk/src/psynth/sound/util.hpp

Go to the documentation of this file.

/*
 *  Copyright (C) 2010 Juan Pedro Bolivar Puente
 *
 *  This file is part of Psychosynth.
 *   
 *  Psychosynth is free software: you can redistribute it and/or modify
 *  it under the terms of the GNU General Public License as published by
 *  the Free Software Foundation, either version 3 of the License, or
 *  (at your option) any later version.
 *
 *  Psychosynth is distributed in the hope that it will be useful,
 *  but WITHOUT ANY WARRANTY; without even the implied warranty of
 *  MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
 *  GNU General Public License for more details.
 *
 *  You should have received a copy of the GNU General Public License
 *  along with this program.  If not, see <http://www.gnu.org/licenses/>.
 *
 */

/*
 *  Copyright 2005-2007 Adobe Systems Incorporated
 * 
 *  Use, modification and distribution are subject to the Boost
 *  Software License, Version 1.0. (See accompanying file
 *  LICENSE_1_0.txt or copy at http://www.boost.org/LICENSE_1_0.txt).
 */

#ifndef PSYNTH_SOUND_UTILITIES_H
#define PSYNTH_SOUND_UTILITIES_H

#include <psynth/base/compat.hpp>

#include <functional>
#include <boost/config/no_tr1/cmath.hpp>
#include <cstddef>
#include <algorithm>
#include <utility>
#include <iterator>

#include <boost/static_assert.hpp>
#include <boost/mpl/size.hpp>
#include <boost/mpl/distance.hpp>
#include <boost/mpl/begin.hpp>
#include <boost/mpl/find.hpp>
#include <boost/mpl/range_c.hpp>
#include <boost/iterator/iterator_adaptor.hpp>
#include <boost/iterator/iterator_facade.hpp>

namespace psynth
{
namespace sound
{

inline std::ptrdiff_t iround (float x)
{ return static_cast<std::ptrdiff_t>(x + (x < 0.0f ? -0.5f : 0.5f)); }
inline std::ptrdiff_t iround (double x)
{ return static_cast<std::ptrdiff_t>(x + (x < 0.0 ? -0.5 : 0.5)); }
inline std::ptrdiff_t ifloor (float x )
{ return static_cast<std::ptrdiff_t> (std::floor(x)); }
inline std::ptrdiff_t ifloor (double x)
{ return static_cast<std::ptrdiff_t> (std::floor(x)); }
inline std::ptrdiff_t iceil (float x )
{ return static_cast<std::ptrdiff_t> (std::ceil(x)); }
inline std::ptrdiff_t iceil(double x)
{ return static_cast<std::ptrdiff_t> (std::ceil(x)); }

/*
 *
 *    computing size with alignment
 *
 */

template <typename T> 
inline T align (T val, std::size_t alignment)
{ 
    return val + (alignment - val % alignment) % alignment; 
}

template <typename ConstT, typename Value, typename Reference,
          typename ConstReference, typename ArgType, typename ResultType,
          bool IsMutable>
struct deref_base : public std::unary_function<ArgType, ResultType>
{
    typedef ConstT         const_type;
    typedef Value          value_type;
    typedef Reference      reference;
    typedef ConstReference const_reference;
    BOOST_STATIC_CONSTANT(bool, is_mutable = IsMutable);
};

template <typename D1, typename D2>
class deref_compose : public deref_base<
    deref_compose<typename D1::const_type,
                  typename D2::const_type>,
    typename D1::value_type,
    typename D1::reference,
    typename D1::const_reference, 
    typename D2::argument_type,
    typename D1::result_type,
    D1::is_mutable && D2::is_mutable>
{
    D1 _fn1;
    D2 _fn2;

public:
    typedef typename D2::argument_type   argument_type;
    typedef typename D1::result_type     result_type;

    deref_compose () {}

    deref_compose (const D1& x, const D2& y)
        : _fn1(x)
        , _fn2(y) {}

    deref_compose (const deref_compose& dc)
        : _fn1(dc._fn1)
        , _fn2(dc._fn2) {}

    template <typename _D1, typename _D2>
    deref_compose (const deref_compose<_D1,_D2>& dc)
        : _fn1(dc._fn1)
        , _fn2(dc._fn2) {}

    result_type operator() (argument_type x) const { return _fn1(_fn2 (x)); }
    result_type operator() (argument_type x)       { return _fn1(_fn2 (x)); }
};

/* reinterpret_cast is implementation-defined. Static cast is not. */
template <typename OutPtr, typename In> PSYNTH_FORCEINLINE
OutPtr psynth_reinterpret_cast (In* p)
{
    return static_cast<OutPtr> (static_cast<void*> (p));
}

template <typename OutPtr, typename In> PSYNTH_FORCEINLINE
const OutPtr psynth_reinterpret_cast_c(const In* p)
{
    return static_cast<const OutPtr>(static_cast<const void*>(p));
}

namespace detail
{

template <class InputIter, class Size, class OutputIter>
std::pair<InputIter, OutputIter> do_copy_n (InputIter first, Size count,
                                            OutputIter result,
                                            std::input_iterator_tag)
{
   for ( ; count > 0; --count) {
      *result = *first;
      ++first;
      ++result;
   }
   return std::pair<InputIter, OutputIter>(first, result);
}

template <class RAIter, class Size, class OutputIter>
inline std::pair<RAIter, OutputIter>
do_copy_n (RAIter first, Size count, OutputIter result,
           std::random_access_iterator_tag)
{
   RAIter last = first + count;
   return std::pair<RAIter, OutputIter>(last, std::copy(first, last, result));
}

template <class InputIter, class Size, class OutputIter>
inline std::pair<InputIter, OutputIter>
do_copy_n (InputIter first, Size count, OutputIter result)
{
   return do_copy_n (
       first, count, result,
       typename std::iterator_traits<InputIter>::iterator_category());
}

template <class InputIter, class Size, class OutputIter>
inline std::pair<InputIter, OutputIter>
copy_n (InputIter first, Size count, OutputIter result)
{
    return detail::do_copy_n (first, count, result);
}

template <typename T> 
struct identity : public std::unary_function<T,T> {
    const T& operator()(const T& val) const { return val; }
};


template <typename T1, typename T2>
struct plus_asymmetric : public std::binary_function<T1,T2,T1> {
    T1 operator()(T1 f1, T2 f2) const {
        return f1+f2;
    }
};

template <typename T>
struct inc : public std::unary_function<T,T>
{
    T operator () (T x) const { return ++x; }
};

template <typename T>
struct dec : public std::unary_function<T,T>
{
    T operator () (T x) const { return --x; }
};

template <typename Types, typename T>
struct type_to_index 
    : public boost::mpl::distance<
    typename boost::mpl::begin<Types>::type, 
    typename boost::mpl::find<Types,T>::type>::type {};

} /* namespace detail */


template <typename ChannelSpace,
          typename SampleMapping = boost::mpl::range_c<
              int, 0, boost::mpl::size<ChannelSpace>::value> >
struct layout
{
    typedef ChannelSpace   channel_space;
    typedef SampleMapping  sample_mapping;
};

template <typename Value, typename T1, typename T2>
// where value_type<T1>  == value_type<T2> == Value
void swap_proxy (T1& left, T2& right)
{
    Value tmp = left;
    left  = right;
    right = tmp;
}

inline bool little_endian ()
{
    short tester = 0x0001;
    return  *(char*)&tester!=0;
}

inline bool big_endian()
{
    return !little_endian();
}

} /* namespace sound */
} /* namespace psynth */

#endif /* PSYNTH_SOUND_UTIL */