/home/raskolnikov/dev/psynth/trunk/src/psynth/sound/channel_base_algorithm.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_CHANNEL_BASE_ALGORITHM_HPP
#define PSYNTH_SOUND_CHANNEL_BASE_ALGORITHM_HPP

#include <algorithm>
#include <boost/type_traits.hpp>
#include <boost/utility/enable_if.hpp>
#include <boost/mpl/contains.hpp>
#include <boost/mpl/at.hpp>

#include <psynth/base/compat.hpp>
#include <psynth/sound/concept.hpp>
#include <psynth/sound/util.hpp>

namespace psynth
{
namespace sound
{

/*
 *
 *   size:   Semantic sample size
 *
 */

template <typename ChannelBase>
struct size : public boost::mpl::size<
    typename ChannelBase::layout::channel_space> {};


/*
 *
 *    semantic_at_c:   Semantic sample accessors
 *
 */

template <typename ChannelBase, int K>
struct kth_semantic_element_type
{
    BOOST_STATIC_CONSTANT(
        int, semantic_index = (
            boost::mpl::at_c<typename ChannelBase::layout::sample_mapping,
                      K>::type::value));
    typedef typename kth_element_type <ChannelBase, semantic_index>::type type;
};

template <typename ChannelBase, int K>
struct kth_semantic_element_reference_type
{
    BOOST_STATIC_CONSTANT(
        int, semantic_index = (
            boost::mpl::at_c<typename ChannelBase::layout::sample_mapping,
                      K>::type::value));
    typedef typename kth_element_reference_type<
        ChannelBase, semantic_index>::type type;

    static type get (ChannelBase& cb)
    {
        return sound::at_c<semantic_index>(cb);
    }
};


template <typename ChannelBase, int K>
struct kth_semantic_element_const_reference_type
{
    BOOST_STATIC_CONSTANT(
        int, semantic_index = (
            boost::mpl::at_c<typename ChannelBase::layout::sample_mapping,
                      K>::type::value));
    typedef typename kth_element_const_reference_type<
        ChannelBase, semantic_index>::type type;

    static type get (const ChannelBase& cb)
    {
        return sound::at_c<semantic_index> (cb);
    }
};

template <int K, typename ChannelBase> inline
typename boost::disable_if<
    boost::is_const<ChannelBase>,
    typename kth_semantic_element_reference_type<ChannelBase,K>::type>::type
semantic_at_c (ChannelBase& p)
{ 
    return kth_semantic_element_reference_type<ChannelBase, K>::get (p);
}

template <int K, typename ChannelBase> inline
typename kth_semantic_element_const_reference_type<ChannelBase,K>::type
semantic_at_c (const ChannelBase& p)
{ 
    return kth_semantic_element_const_reference_type<ChannelBase,K>::get (p); 
}


/*
 *
 *   get_channel:   Named sample accessors
 *
 */

template <typename ChannelBase, typename Channel>
struct contains_channel :
    public boost::mpl::contains<typename ChannelBase::layout::channel_space,
                         Channel> {};

template <typename ChannelBase, typename Channel>
struct channel_index_type :
    public detail::type_to_index<typename ChannelBase::layout::channel_space,
                                 Channel> {};

template <typename ChannelBase, typename Channel>
struct channel_element_type : public kth_semantic_element_type<
    ChannelBase, channel_index_type<ChannelBase,Channel>::value> {};

template <typename ChannelBase, typename Channel>
struct channel_element_reference_type :
    public kth_semantic_element_reference_type<
    ChannelBase, channel_index_type<ChannelBase, Channel>::value> {};

template <typename ChannelBase, typename Channel>
struct channel_element_const_reference_type :
    public kth_semantic_element_const_reference_type<
    ChannelBase, channel_index_type<ChannelBase, Channel>::value> {};

template <typename ChannelBase, typename Channel> 
typename channel_element_reference_type<ChannelBase,Channel>::type
get_channel (ChannelBase& cb, Channel = Channel())
{
    return channel_element_reference_type<ChannelBase, Channel>::get (cb);
}

template <typename ChannelBase, typename Channel> 
typename channel_element_const_reference_type<ChannelBase,Channel>::type
get_channel (const ChannelBase& cb, Channel=Channel())
{
    return channel_element_const_reference_type<ChannelBase,Channel>::get (cb);
}


/*
 *
 *    element_type, element_reference_type,
 *    element_const_reference_type: Support for homogeneous channel
 *    bases
 *
 */

template <typename ChannelBase>
struct element_type : public kth_element_type<ChannelBase, 0> {};

template <typename ChannelBase>
struct element_reference_type :
    public kth_element_reference_type<ChannelBase, 0> {};

template <typename ChannelBase>
struct element_const_reference_type :
    public kth_element_const_reference_type<ChannelBase, 0> {};


namespace detail
{

/* compile-time recursion for per-element operations on channel bases */
template <int N>
struct element_recursion
{
    // static_equal
    template <typename P1,typename P2>
    static bool static_equal (const P1& p1, const P2& p2)
    { 
        return element_recursion<N-1>::static_equal(p1,p2) &&
               semantic_at_c<N-1>(p1) == semantic_at_c<N-1>(p2); 
    }
    
    //static_copy
    template <typename P1,typename P2>
    static void static_copy(const P1& p1, P2& p2)
    {
        element_recursion<N-1>::static_copy(p1,p2);
        semantic_at_c<N-1>(p2) = semantic_at_c<N-1>(p1);
    }
    
    //static_fill
    template <typename P,typename T2>
    static void static_fill(P& p, T2 v)
    {
        element_recursion<N-1>::static_fill (p,v);
        semantic_at_c<N-1>(p) = v;
    }
    
    //static_generate
    template <typename Dst,typename Op> 
    static void static_generate (Dst& dst, Op op)
    {
        element_recursion<N-1>::static_generate (dst, op);
        semantic_at_c<N-1>(dst) = op();
    }
    
    //static_for_each with one source
    template <typename P1,typename Op> 
    static Op static_for_each (P1& p1, Op op)
    {
        Op op2 (element_recursion<N-1>::static_for_each (p1,op));
        op2 (semantic_at_c<N-1> (p1));
        return op2;
    }
    
    template <typename P1,typename Op> 
    static Op static_for_each (const P1& p1, Op op)
    {
        Op op2 (element_recursion<N-1>::static_for_each (p1,op));
        op2 (semantic_at_c<N-1> (p1));
        return op2;
    }
    
    //static_for_each with two sources
    template <typename P1,typename P2,typename Op> 
    static Op static_for_each (P1& p1, P2& p2, Op op)
    {
        Op op2(element_recursion<N-1>::static_for_each (p1, p2, op));
        op2(semantic_at_c<N-1>(p1), semantic_at_c<N-1>(p2));
        return op2;
    }
    
    template <typename P1,typename P2,typename Op> 
    static Op static_for_each(P1& p1, const P2& p2, Op op)
    {
        Op op2(element_recursion<N-1>::static_for_each(p1,p2,op));
        op2(semantic_at_c<N-1>(p1), semantic_at_c<N-1>(p2));
        return op2;
    }

    template <typename P1,typename P2,typename Op> 
    static Op static_for_each(const P1& p1, P2& p2, Op op)
    {
        Op op2(element_recursion<N-1>::static_for_each(p1,p2,op));
        op2(semantic_at_c<N-1>(p1), semantic_at_c<N-1>(p2));
        return op2;
    }

    template <typename P1,typename P2,typename Op> 
    static Op static_for_each(const P1& p1, const P2& p2, Op op)
    {
        Op op2(element_recursion<N-1>::static_for_each(p1,p2,op));
        op2(semantic_at_c<N-1>(p1), semantic_at_c<N-1>(p2));
        return op2;
    }

    //static_for_each with three sources
    template <typename P1,typename P2,typename P3,typename Op>
    static Op static_for_each (P1& p1, P2& p2, P3& p3, Op op)
    {
        Op op2(element_recursion<N-1>::static_for_each(p1,p2,p3,op));
        op2(semantic_at_c<N-1>(p1),
            semantic_at_c<N-1>(p2),
            semantic_at_c<N-1>(p3));
        return op2;
    }
    
    template <typename P1,typename P2,typename P3,typename Op>
    static Op static_for_each (P1& p1, P2& p2, const P3& p3, Op op)
    {
        Op op2(element_recursion<N-1>::static_for_each(p1,p2,p3,op));
        op2 (semantic_at_c<N-1>(p1),
             semantic_at_c<N-1>(p2),
             semantic_at_c<N-1>(p3));
        return op2;
    }
    
    template <typename P1,typename P2,typename P3,typename Op>
    static Op static_for_each (P1& p1, const P2& p2, P3& p3, Op op)
    {
        Op op2(element_recursion<N-1>::static_for_each(p1,p2,p3,op));
        op2 (semantic_at_c<N-1>(p1),
             semantic_at_c<N-1>(p2),
             semantic_at_c<N-1>(p3));
        return op2;
    }
    
    template <typename P1,typename P2,typename P3,typename Op>
    static Op static_for_each (P1& p1, const P2& p2, const P3& p3, Op op)
    {
        Op op2(element_recursion<N-1>::static_for_each(p1,p2,p3,op));
        op2 (semantic_at_c<N-1>(p1),
             semantic_at_c<N-1>(p2),
             semantic_at_c<N-1>(p3));
        return op2;
    }
    
    template <typename P1,typename P2,typename P3,typename Op>
    static Op static_for_each (const P1& p1, P2& p2, P3& p3, Op op)
    {
        Op op2(element_recursion<N-1>::static_for_each(p1,p2,p3,op));
        op2 (semantic_at_c<N-1>(p1),
             semantic_at_c<N-1>(p2),
             semantic_at_c<N-1>(p3));
        return op2;
    }
    
    template <typename P1,typename P2,typename P3,typename Op>
    static Op static_for_each (const P1& p1, P2& p2, const P3& p3, Op op)
    {
        Op op2(element_recursion<N-1>::static_for_each(p1,p2,p3,op));
        op2 (semantic_at_c<N-1>(p1),
             semantic_at_c<N-1>(p2),
             semantic_at_c<N-1>(p3));
        return op2;
    }
    
    template <typename P1,typename P2,typename P3,typename Op>
    static Op static_for_each (const P1& p1, const P2& p2, P3& p3, Op op)
    {
        Op op2(element_recursion<N-1>::static_for_each(p1,p2,p3,op));
        op2 (semantic_at_c<N-1>(p1),
             semantic_at_c<N-1>(p2),
             semantic_at_c<N-1>(p3));
        return op2;
    }
    
    template <typename P1,typename P2,typename P3,typename Op>
    static Op static_for_each (const P1& p1, const P2& p2, const P3& p3, Op op)
    {
        Op op2(element_recursion<N-1>::static_for_each(p1,p2,p3,op));
        op2 (semantic_at_c<N-1>(p1),
             semantic_at_c<N-1>(p2),
             semantic_at_c<N-1>(p3));
        return op2;
    }
    
    //static_transform with one source
    template <typename P1,typename Dst,typename Op> 
    static Op static_transform (P1& src, Dst& dst, Op op)
    {
        Op op2 (element_recursion<N-1>::static_transform (src,dst,op));
        semantic_at_c<N-1> (dst) = op2 (semantic_at_c<N-1> (src));
        return op2;
    }
    
    template <typename P1,typename Dst,typename Op> 
    static Op static_transform (const P1& src, Dst& dst, Op op)
    {
        Op op2(element_recursion<N-1>::static_transform(src,dst,op));
        semantic_at_c<N-1>(dst)=op2(semantic_at_c<N-1>(src));
        return op2;
    }
    
    //static_transform with two sources
    template <typename P1,typename P2,typename Dst,typename Op>
    static Op static_transform (P1& src1, P2& src2, Dst& dst, Op op)
    {
        Op op2(element_recursion<N-1>::static_transform(src1,src2,dst,op));
        semantic_at_c<N-1>(dst) = op2 (semantic_at_c<N-1>(src1),
                                       semantic_at_c<N-1>(src2));
        return op2;
    }
    
    template <typename P1,typename P2,typename Dst,typename Op>
    static Op static_transform (P1& src1, const P2& src2, Dst& dst, Op op) {
        Op op2(element_recursion<N-1>::static_transform(src1,src2,dst,op));
        semantic_at_c<N-1>(dst) = op2 (semantic_at_c<N-1>(src1),
                                       semantic_at_c<N-1>(src2));
        return op2;
    }
    
    template <typename P1,typename P2,typename Dst,typename Op>
    static Op static_transform (const P1& src1, P2& src2, Dst& dst, Op op)
    {
        Op op2(element_recursion<N-1>::static_transform(src1,src2,dst,op));
        semantic_at_c<N-1>(dst) = op2 (semantic_at_c<N-1>(src1),
                                       semantic_at_c<N-1>(src2));
        return op2;
    }
    
    template <typename P1,typename P2,typename Dst,typename Op>
    static Op static_transform (const P1& src1, const P2& src2, Dst& dst, Op op)
    {
        Op op2(element_recursion<N-1>::static_transform(src1,src2,dst,op));
        semantic_at_c<N-1>(dst) = op2 (semantic_at_c<N-1>(src1),
                                       semantic_at_c<N-1>(src2));
        return op2;
    }
};

// Termination condition of the compile-time recursion for element
// operations on a channel base
template<> struct element_recursion<0>
{
    //static_equal
    template <typename P1,typename P2>
    static bool static_equal(const P1&, const P2&) { return true; }
    //static_copy
    template <typename P1,typename P2>
    static void static_copy(const P1&, const P2&) {}
    //static_fill
    template <typename P, typename T2>
    static void static_fill(const P&, T2) {}
    //static_generate
    template <typename Dst,typename Op>
    static void static_generate(const Dst&,Op) {}
    //static_for_each with one source
    template <typename P1,typename Op>
    static Op static_for_each(const P1&,Op op) { return op; }
    //static_for_each with two sources
    template <typename P1,typename P2,typename Op>
    static Op static_for_each(const P1&,const P2&,Op op) { return op; }
    //static_for_each with three sources
    template <typename P1,typename P2,typename P3,typename Op>
    static Op static_for_each(const P1&,const P2&,const P3&,Op op) { return op; }
    //static_transform with one source
    template <typename P1,typename Dst,typename Op>
    static Op static_transform(const P1&,const Dst&,Op op) { return op; }
    //static_transform with two sources
    template <typename P1,typename P2,typename Dst,typename Op>
    static Op static_transform(const P1&,const P2&,const Dst&,Op op) { return op; }
};

// std::min and std::max don't have the mutable overloads...
template <typename Q> inline const Q& mutable_min(const Q& x, const Q& y)
{ return x<y ? x : y; }
template <typename Q> inline       Q& mutable_min(      Q& x,       Q& y)
{ return x<y ? x : y; }
template <typename Q> inline const Q& mutable_max(const Q& x, const Q& y)
{ return x<y ? y : x; }
template <typename Q> inline       Q& mutable_max(      Q& x,       Q& y)
{ return x<y ? y : x; }

// compile-time recursion for min/max element
template <int N>
struct min_max_recur
{
    template <typename P>
    static typename element_const_reference_type<P>::type max_ (const P& p)
    {
        return mutable_max(min_max_recur<N-1>::max_(p), semantic_at_c<N-1>(p));
    }
    
    template <typename P>
    static typename element_reference_type<P>::type       max_ (P& p)
    {
        return mutable_max(min_max_recur<N-1>::max_(p), semantic_at_c<N-1>(p));
    }
    
    template <typename P>
    static typename element_const_reference_type<P>::type min_ (const P& p)
    {
        return mutable_min(min_max_recur<N-1>::min_(p), semantic_at_c<N-1>(p));
    }
    
    template <typename P>
    static typename element_reference_type<P>::type       min_ (P& p)
    {
        return mutable_min(min_max_recur<N-1>::min_(p), semantic_at_c<N-1>(p));
    }    
};

// termination condition of the compile-time recursion for min/max
// element
template <>
struct min_max_recur<1>
{
    template <typename P>
    static typename element_const_reference_type<P>::type max_(const P& p)
    { return semantic_at_c<0>(p); }
    template <typename P>
    static typename element_reference_type<P>::type       max_(P& p)
    { return semantic_at_c<0>(p); }
    template <typename P>
    static typename element_const_reference_type<P>::type min_(const P& p)
    { return semantic_at_c<0>(p); }
    template <typename P>
    static typename element_reference_type<P>::type       min_(P& p)
    { return semantic_at_c<0>(p); }
};

} /* namespace detail */


template <typename P>
PSYNTH_FORCEINLINE
typename element_const_reference_type<P>::type static_max (const P& p)
{ return detail::min_max_recur<size<P>::value>::max_(p); }

template <typename P>
PSYNTH_FORCEINLINE
typename element_reference_type<P>::type       static_max (P& p)
{ return detail::min_max_recur<size<P>::value>::max_(p); }

template <typename P>
PSYNTH_FORCEINLINE
typename element_const_reference_type<P>::type static_min (const P& p)
{ return detail::min_max_recur<size<P>::value>::min_(p); }

template <typename P>
PSYNTH_FORCEINLINE
typename element_reference_type<P>::type       static_min (P& p)
{ return detail::min_max_recur<size<P>::value>::min_(p); }

template <typename P1,typename P2>
PSYNTH_FORCEINLINE
bool static_equal (const P1& p1, const P2& p2)
{ return detail::element_recursion<size<P1>::value>::static_equal(p1,p2); }

template <typename Src,typename Dst>
PSYNTH_FORCEINLINE
void static_copy(const Src& src, Dst& dst)
{  detail::element_recursion<size<Dst>::value>::static_copy(src,dst); }

template <typename P,typename V>
PSYNTH_FORCEINLINE
void static_fill (P& p, const V& v)
{  detail::element_recursion<size<P>::value>::static_fill(p,v); }
template <typename P1,typename Op>
PSYNTH_FORCEINLINE void static_generate(P1& dst,Op op)
{ detail::element_recursion<size<P1>::value>::static_generate(dst,op); }

//static_transform with one source
template <typename Src,typename Dst,typename Op>
PSYNTH_FORCEINLINE
Op static_transform (Src& src, Dst& dst,Op op)
{
    return detail::element_recursion<size<Dst>::value>::static_transform (
        src, dst, op);
}

template <typename Src,typename Dst,typename Op>
PSYNTH_FORCEINLINE
Op static_transform (const Src& src, Dst& dst, Op op)
{
    return detail::element_recursion<size<Dst>::value>::static_transform (
        src, dst, op);
}

//static_transform with two sources
template <typename P2,typename P3,typename Dst,typename Op>
PSYNTH_FORCEINLINE
Op static_transform (P2& p2, P3& p3, Dst& dst, Op op)
{
    return detail::element_recursion<size<Dst>::value>::static_transform (
        p2, p3, dst, op);
}

template <typename P2,typename P3,typename Dst,typename Op>
PSYNTH_FORCEINLINE
Op static_transform(P2& p2,const P3& p3,Dst& dst,Op op)
{
    return detail::element_recursion<size<Dst>::value>::static_transform (
        p2, p3, dst, op);
}

template <typename P2,typename P3,typename Dst,typename Op>
PSYNTH_FORCEINLINE
Op static_transform (const P2& p2, P3& p3, Dst& dst, Op op)
{
    return detail::element_recursion<size<Dst>::value>::static_transform (
        p2, p3, dst, op);
}

template <typename P2,typename P3,typename Dst,typename Op>
PSYNTH_FORCEINLINE
Op static_transform (const P2& p2, const P3& p3, Dst& dst, Op op)
{
    return detail::element_recursion<size<Dst>::value>::static_transform (
        p2, p3, dst, op);
}

//static_for_each with one source
template <typename P1,typename Op>
PSYNTH_FORCEINLINE
Op static_for_each (P1& p1, Op op)
{ return detail::element_recursion<size<P1>::value>::static_for_each (p1,op); }

template <typename P1,typename Op>
PSYNTH_FORCEINLINE
Op static_for_each (const P1& p1, Op op)
{ return detail::element_recursion<size<P1>::value>::static_for_each(p1,op); }

//static_for_each with two sources
template <typename P1,typename P2,typename Op>
PSYNTH_FORCEINLINE
Op static_for_each (P1& p1, P2& p2, Op op)
{
    return detail::element_recursion<size<P1>::value>::static_for_each (
        p1, p2, op);
}

template <typename P1,typename P2,typename Op>
PSYNTH_FORCEINLINE
Op static_for_each(P1& p1,const P2& p2, Op op)
{ return detail::element_recursion<size<P1>::value>::static_for_each(p1,p2,op); }

template <typename P1,typename P2,typename Op>
PSYNTH_FORCEINLINE
Op static_for_each(const P1& p1, P2& p2, Op op)
{ return detail::element_recursion<size<P1>::value>::static_for_each(p1,p2,op); }

template <typename P1,typename P2,typename Op>
PSYNTH_FORCEINLINE
Op static_for_each(const P1& p1,const P2& p2, Op op)
{ return detail::element_recursion<size<P1>::value>::static_for_each(p1,p2,op); }

//static_for_each with three sources
template <typename P1,typename P2,typename P3,typename Op>
PSYNTH_FORCEINLINE
Op static_for_each(P1& p1,P2& p2,P3& p3,Op op)
{
    return detail::element_recursion<size<P1>::value>::static_for_each(
        p1,p2,p3,op);
}

template <typename P1,typename P2,typename P3,typename Op>
PSYNTH_FORCEINLINE
Op static_for_each(P1& p1,P2& p2,const P3& p3,Op op)
{
    return detail::element_recursion<size<P1>::value>::static_for_each(
        p1,p2,p3,op);
}

template <typename P1,typename P2,typename P3,typename Op>
PSYNTH_FORCEINLINE
Op static_for_each(P1& p1,const P2& p2,P3& p3,Op op)
{
    return detail::element_recursion<size<P1>::value>::static_for_each(
        p1,p2,p3,op);
}

template <typename P1,typename P2,typename P3,typename Op>
PSYNTH_FORCEINLINE
Op static_for_each(P1& p1,const P2& p2,const P3& p3,Op op)
{
    return detail::element_recursion<size<P1>::value>::static_for_each (
        p1,p2,p3,op);
}

template <typename P1,typename P2,typename P3,typename Op>
PSYNTH_FORCEINLINE
Op static_for_each(const P1& p1,P2& p2,P3& p3,Op op)
{
    return detail::element_recursion<size<P1>::value>::static_for_each (
        p1,p2,p3,op);
}

template <typename P1,typename P2,typename P3,typename Op>
PSYNTH_FORCEINLINE
Op static_for_each(const P1& p1,P2& p2,const P3& p3,Op op)
{
    return detail::element_recursion<size<P1>::value>::static_for_each (
        p1,p2,p3,op);
}

template <typename P1,typename P2,typename P3,typename Op>
PSYNTH_FORCEINLINE
Op static_for_each(const P1& p1,const P2& p2,P3& p3,Op op)
{
    return detail::element_recursion<size<P1>::value>::static_for_each(
        p1,p2,p3,op);
}

template <typename P1,typename P2,typename P3,typename Op>
PSYNTH_FORCEINLINE
Op static_for_each(const P1& p1,const P2& p2,const P3& p3,Op op)
{ return detail::element_recursion<size<P1>::value>::static_for_each (
        p1,p2,p3,op);
}
} /* namespace sound */
} /* namespace psynth */

#endif /* PSYNTH_SOUND_CHANNEL_BASE_ALGORITHM */