libs/ardour/ardour/chan_mapping.h

   1 /*
   2     Copyright (C) 2009 Paul Davis
   3     Author: David Robillard
   4
   5     This program is free software; you can redistribute it and/or modify
   6     it under the terms of the GNU General Public License as published by
   7     the Free Software Foundation; either version 2 of the License, or
   8     (at your option) any later version.
   9
  10     This program is distributed in the hope that it will be useful,
  11     but WITHOUT ANY WARRANTY; without even the implied warranty of
  12     MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
  13     GNU General Public License for more details.
  14
  15     You should have received a copy of the GNU General Public License
  16     along with this program; if not, write to the Free Software
  17     Foundation, Inc., 675 Mass Ave, Cambridge, MA 02139, USA.
  18 */
  19
  20 #ifndef __ardour_chan_mapping_h__
  21 #define __ardour_chan_mapping_h__
  22
  23 #include <map>
  24 #include <cassert>
  25 #include <ostream>
  26 #include <utility>
  27
  28 #include "ardour/data_type.h"
  29 #include "ardour/chan_count.h"
  30
  31 namespace ARDOUR {
  32
  33
  34 /** A mapping from one set of channels to another.
  35  * The general form is  1 source (from), many sinks (to).
  36  * numeric IDs are used to identify sources and sinks.
  37  *
  38  * for plugins this is used to map "plugin-pin" to "audio-buffer"
  39  */
  40 class LIBARDOUR_API ChanMapping {
  41 public:
  42         ChanMapping() {}
  43         ChanMapping(ARDOUR::ChanCount identity);
  44         ChanMapping(const ChanMapping&);
  45
  46         uint32_t get(DataType t, uint32_t from, bool* valid) const;
  47
  48         /** reverse lookup
  49          * @param type data type
  50          * @param to pin
  51          * @param valid pointer to a boolean. If not NULL it is set to true if the mapping is found, and false otherwise.
  52          * @returns first "from" that matches given "to"
  53          */
  54         uint32_t get_src(DataType t, uint32_t to, bool* valid) const;
  55
  56         /** get buffer mapping for given data type and pin
  57          * @param type data type
  58          * @param from numeric source id
  59          * @returns mapped buffer number (or ChanMapping::Invalid)
  60          */
  61         uint32_t get (DataType t, uint32_t from) const { return get (t, from, NULL); }
  62
  63         /** set buffer mapping for given data type
  64          * @param type data type
  65          * @param from numeric source id
  66          * @param to buffer
  67          */
  68         void     set(DataType t, uint32_t from, uint32_t to);
  69         void     offset_from(DataType t, int32_t delta);
  70         void     offset_to(DataType t, int32_t delta);
  71
  72         /** remove mapping
  73          * @param type data type
  74          * @param from numeric source to remove from mapping
  75          */
  76         void     unset(DataType t, uint32_t from);
  77
  78         /** Test mapping matrix for identity
  79          * @param offset per data-type offset to take into account
  80          * @returns true if the mapping is a channel identity map
  81          */
  82         bool     is_identity (ARDOUR::ChanCount offset = ARDOUR::ChanCount()) const;
  83
  84         /** Test if this mapping is monotonic (useful to see if inplace processing is feasible)
  85          * @returns true if the map is a strict monotonic set
  86          */
  87         bool     is_monotonic () const;
  88
  89         /** Test if this mapping is a subset
  90          * @param superset to test against
  91          * @returns true if all mapping are also present in the superset
  92          */
  93         bool     is_subset (const ChanMapping& superset) const;
  94
  95         typedef std::map<uint32_t, uint32_t>    TypeMapping;
  96         typedef std::map<DataType, TypeMapping> Mappings;
  97
  98         Mappings       mappings()       { return _mappings; }
  99         const Mappings mappings() const { return _mappings; }
 100
 101         bool operator==(const ChanMapping& other) const {
 102                 return (_mappings == other._mappings);
 103         }
 104
 105         bool operator!=(const ChanMapping& other) const {
 106                 return ! (*this == other);
 107         }
 108
 109 private:
 110         Mappings _mappings;
 111 };
 112
 113 } // namespace ARDOUR
 114
 115 std::ostream& operator<<(std::ostream& o, const ARDOUR::ChanMapping& m);
 116
 117 #endif // __ardour_chan_mapping_h__
 118